- Brand
- Finta
- Category
- Finance
- Primary Subcategory
- Accounting & Bookkeeping
Integration details
Description
Finta is accounting software and done-for-you tax filing for US startups. Connect your Finta account to work with your company's books from ChatGPT: get the income statement, balance sheet, cash flow statement and key metrics such as burn and runway; search, categorize and bulk edit transactions; reconcile bank and card accounts; manage rules and tags; build Sheets with live actuals; and check tax filings and what Finta needs from you. You sign in with your Finta account, so there is no API key to manage. The plugin can only see and do what your role in Finta allows. A Finta account is required.
- Integration type
- Plugin
- Verification status
- Not applicable
- Platform
- ChatGPT
- Primary Subcategory
- Accounting & Bookkeeping
- Secondary Subcategories
- None listed
- Brand
- Finta
- Access
- Account required
- First tracked
- 2026-11-20
- Tool count
- 80
- Market
- US
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
Not discoverable in ChatGPT yet
ChatGPT now suggests Plugins on its own when they match a user's request, but not every Plugin is being surfaced yet.We haven’t seen Finta suggested yet. Sign up and we’ll track it, and your Discoverability Score will appear here once ChatGPT starts surfacing it.
What discovery looks like

Get alerts for Finta
Get updates when Finta’s Discoverability Score or category rank changes.
Competing in ChatGPT Accounting & Bookkeeping
View Category80 tools agents can invoke
Purpose: Apply one change to transactions selected by txn_ IDs or filters. IDs cap at 50,000; filters have no row cap. Not for: Different changes for different transactions; call update_transaction for each. Changing future transactions; a rule does that. Returns: Job id, status (queued, processing, success or failed), matched_count (null before selection; includes skips), updated_count (changed rows), and paginated errors (transaction_id, code, param, message). Success may include skipped later edits or rows not attempted after a stop (permission_denied, transaction_update_failed or update_failed); saved chunks remain. Failed means no edits saved. When to use: "Recategorize Gusto as Payroll". Workflow: Preview with search_transactions using the same filters, then confirm the change and count with the user. For one account, search its transactions and pass transaction_ids. Send exactly one of transaction_ids or filters, plus updates. This waits about 20 seconds; if still queued/processing, wait 30+ seconds, then call with only job_id. Page errors with job_id and starting_after=errors.next_cursor when errors.has_more. Identical requests replay within an hour, then run anew; accounting_shift replays for 30 days after completion, so tell the user if an intended new shift replayed instead. Retry with the same body after an uncertain response. Rules: Filters all must match, and select transactions by their values before the update. Split transactions are never selected by filters, and naming one in transaction_ids fails the job. In updates, tag_id takes a tag_ ID or null and must be the only update. Empty removal writes manual protection but counts zero. Eligible plain tag-only jobs may preview within the documented bounds; other targets remain stored until save. null clears tag_id, department_id or spread, or restores the original accounting date; merchant and category_id can't be null; accounting_date and accounting_shift can't be used together.
bulk_update_transactions
Purpose: Get the link the user opens to connect a bank or card provider to Finta, or to reconnect one whose status is requires_reconnect. Not for: Methods whose connect_via isn't api: provider_app ones end with grant_integration_access; the user connects web_app ones in Finta under Settings -> Integrations. Checking if a connection finished; use get_integration_connection. Returns: A connect_request with status pending and url, the provider's single-use authorization page, valid until expires_at (Unix seconds). intent is reconnect for an existing connection. For Plaid banks (chase, svb, arc, citi, boa, american_express), url is a Plaid page, valid for 30 minutes, where the user picks and signs in to their bank; it needs no Finta sign-in, so anyone with it can connect a bank to this company. When to use: "Connect our Mercury account", "Our Ramp connection needs reconnecting". Workflow: While onboarding, connect banks only once get_onboarding's next_step is connect_banks; before Finta approves the company this returns onboarding_incomplete. Check list_integrations first for the key and a connection_methods entry with connect_via api. If you can open links in the user's browser and they allow it, open url; otherwise show it only to them. It only works in a browser where they are signed in to Finta as themselves, except for Plaid banks, which end on a Finta page telling the user to come back to you. Never fill in or click through the provider's or bank's page: the approval has to come from the user. Ask them to tell you once they've approved, then call get_integration_connection. Calling this again returns the same open link; after a request fails or expires, it starts a new one. An already-connected Plaid bank, even one that requires_reconnect, is reconnected only in the Finta web app.
connect_integration
Purpose: Create a manual bank or credit card account to upload transactions to. Not for: Accounts that sync from an integration such as Mercury, Brex or Plaid; those already exist, and this would make a duplicate manual account. Returns: The account (id, account_name, vendor, type) and created, false when a matching manual account already existed. When to use: "Set up our Chase checking account" before uploading its transactions. Workflow: Call list_accounts first and use a matching account. Confirm the bank, name and type with the user when unclear. Retrying with the same vendor, account_name and type returns the same account.
create_account
Purpose: Add one of Finta's standard categories to the chart of accounts, as under Settings > Categories. Not for: Inventing categories, names or parents. Only options from list_available_categories with access add can be added. Returns: created (false when they already existed) and the option's categories with cat_ IDs. When to use: The user confirmed an option from list_available_categories, e.g. "Yes, add Grant Income". Workflow: Call list_available_categories first, check that the option's descriptions fit what the user wants to track, and confirm with the user. Pass its key as template.
create_category
Purpose: Get a one-time URL to upload a PDF, and the file_id it becomes: a tax return or Delaware franchise tax report the company already filed, or a bank or card statement to attach when reconciling. Not for: Anything but PDFs, or sending the PDF itself; this tool only prepares the upload. Returns: file_id, url, method (PUT), headers to send with the PUT, and expires_at; the url works for 10 minutes. When to use: Before upload_income_tax_return or upload_delaware_franchise_tax_report (purpose tax_document), or before reconcile_account with a statement (purpose bank_statement), when the user has the PDF on this computer. Workflow: Get an upload URL with this tool, PUT the PDF, then call the upload or reconcile tool with the file ID. Compute size with `wc -c < FILE` and checksum with `openssl md5 -binary FILE | base64`. PUT from a terminal with every returned header, such as curl --fail -X PUT --upload-file FILE -H "Content-Type: application/pdf" -H "Content-MD5: <checksum>" -H "Content-Disposition: <Content-Disposition from headers>" "<url>". For a company with no records for that year, upload the return first, then the Delaware report. Rules: One URL per PDF. The file must be attached within 24 hours and attaches once, only to what its purpose names; a PUT can't change it, since storage only accepts bytes matching size and checksum. A bank statement can be at most 10 MB.
create_file_upload
Not available to this company yet (early access: invoices). Contact Finta to request access. Purpose: Record an invoice the company already sent a customer, which books its revenue: Accounts Receivable for the total, and revenue for each line item. Not for: Sending an invoice; Finta doesn't send anything to customers. Recording a payment; once the money arrives, use match_invoice_payment. Returns: The recorded invoice, status open, with its inv_ ID. Amounts in it are integer cents, so divide by 100 for dollars. When to use: "Record this invoice" from a PDF or billing system, "We invoiced Globex $12,000 for an annual contract". Workflow: Use the invoice's own date, customer name and amounts. Set spread_months, such as 12, for an annual contract billed up front; ask the user when the invoice doesn't say. On invoice_already_exists, it's already recorded under the ID in the message; tell the user, don't create it again. A date in a tax year the company finished with Finta is refused (closed_books). Rules: Amounts are in dollars, such as "12000.00". A line item's amount is negative for a refund, which can't be spread. Discounts and customer balance credits reduce the total and tax adds to it; give each as a positive amount, at most one of each kind. The total must be more than 0.
create_invoice
Not available to this company yet (early access: journal entry batches). Contact Finta to request access. Purpose: Post 2 or more journal entries as one batch, with a memo saying why. All save or none do. Not for: Changing transactions. Returns: The jmb_ batch and its je_ entries. When to use: Accruals and adjustments. JEs given together go in one batch, each line with its own memo. Workflow: Get IDs from list_categories and list_departments. Debits must equal credits each date. Confirm with the user first.
create_journal_entry_batch
Purpose: Generate a downloadable PDF, CSV or XLSX of an income statement, balance sheet or cash flow. For GAAP P&L, use income_statement with group_by.rows=department. For the app's "CSV with breakdown" (merchant rows under each category), use income_statement, csv and breakdown=merchants. Not for: Reading report numbers directly; use get_income_statement, get_balance_sheet or get_cash_flow. Checking an existing export or refreshing its download link; use get_report_export. Returns: A report_export with an export_ ID, status (pending, processing, succeeded or failed), submitted parameters, timestamps, generation_duration_ms, and nullable file/error. It returns immediately; generation continues asynchronously. A succeeded replay can already include the file. Workflow: Choose the report, dates and format from the user's request. All reports, including balance sheets, need start_date and end_date. Generate a unique idempotency_key once for this export request and keep it for retries; reuse the same key and inputs if submission fails or times out. Save the returned export_ ID and call get_report_export to check it. Do not submit again to poll. Reusing the key returns the original export; use a new key only when the user wants a new file from the current books, including after a terminal failure. There is no automatic completion notification. Rules: format defaults to pdf. group_by.period defaults to month and also accepts quarter/year; group_by.rows defaults to category. Department rows require income_statement and the departments feature. breakdown defaults to none; merchants and merchants_except_revenue need income_statement, csv and category rows. merchants_except_revenue leaves customer names out of revenue, which is faster when there are many. Ranges cover at most 120 calendar months, counting both boundary months. PDFs also allow at most 13 displayed periods using company calendar/fiscal settings; shorten the range, use coarser grouping, or choose CSV/XLSX for more columns. Five unfinished exports per company are allowed; at capacity, check existing exports and retry later with the same key. Requires Reports: View and API access: Manage; read-only OAuth connections can export. Company and filename are inferred. No email field is supported.
create_report_export
Purpose: Create an automation rule that sets a merchant, category, department, tag, spread or accounting-date offset on matching transactions. Not for: A one-off change to transactions; update those directly. Creating categories (create_category adds them) or departments. Returns: The saved rule: id, conditions, actions and action_names (the names of its category, department and tag). When to use: "Always categorize AWS as Hosting", "From now on, put Gusto under Payroll" (future only, so apply_to_existing_transactions: false). Workflow: Get IDs from list_categories, list_departments, list_tags, list_accounts and list_cards, and check list_rules for a rule that already does this. Confirm the conditions and actions with the user, and ask whether it should also change transactions already in Finta (apply_to_existing_transactions). With true, the rule also runs in the background on matching transactions already in Finta: approved ones that are uncategorized, never pending ones; and only if the rule sets a department, also any matching transaction without a department, pending ones included. It never replaces a department already set, or the category or merchant of an approved transaction that's already categorized. A pending transaction it selects does take the rule's category and merchant, replacing any it has, so when the rule sets a department along with either, say so before the user decides. A tag action also fills missing tags on all matching past transactions, categorized or uncategorized, approved or pending, excluding draft, trashed and split-part rows. This never widens the scope of the other actions. It needs Transactions: Manage. A saved rule doesn't mean that run has finished. On rule_already_exists, use the existing rule its message names. Rules: merchant matches the merchant name Finta assigned, and description matches the bank's description, both ignoring case.
create_rule
Purpose: Create a spreadsheet document with named worksheet tabs, using a blank sheet, a supported template, or custom tables and embedded charts. Statements: Prefer the matching template_id for standard income statements, balance sheets and cash-flow statements. Templates use the UI's formula-backed cells; keep their formulas. Returns: Document ID, Finta link, revision and created worksheet/chart IDs. return_ranges additionally calculates selected cells and reports results/errors; saving and calculation are separate outcomes. Workflow: name alone creates one blank tab. Pass template_id with documented template_options OR custom worksheets, never both. Worksheets use local A1 ranges and 2D values. return_ranges must name the worksheet, e.g. 'Plan'!B6. revenue_by_customer and top_software_expenses use the last six completed months and accept no nonempty template_options. Nonempty statement template_options require starting_month and ending_month as YYYY-MM-DD dates, with up to 13 periods. Custom ranges/charts expand to at most 500 native operations per request. Grid: Uses the UI defaults: blank tabs start at 100 rows by 26 columns; templates keep their existing dimensions. Values, formatting and chart anchors automatically expand the grid within company limits. No grid size is required. Large sheets: The 500-operation budget covers all custom tabs, values, formats and charts combined, including tab setup, automatic expansion and any formula-preservation writes it needs; template seeding is outside this budget. For larger custom documents, create a smaller initial document, then populate the remainder with sequential update_sheet calls using each returned revision. Splitting content into more ranges or tabs in the same call does not reset the budget. Formulas: Default to live FINTA formulas for historical actuals, e.g. =FINTA("Net Revenue","Sep 2026"), using discovered category names and supported periods/filters. Do not paste financial report totals as static actuals or replace existing FINTA formulas with numbers unless the user explicitly requests a frozen snapshot. For forecasts, use ordinary spreadsheet formulas referencing actuals and editable assumption cells, e.g. =B2*(1+$B$1); FINTA retrieves accounting actuals, not future projections. If FINTA can't express the requested actuals, say so rather than substituting a snapshot or inventing a formula. Use only existing functions: SUM, AVERAGE, SUMPRODUCT, CATEGORY, DEPARTMENT, DATE, DATEVALUE, EDATE, EOMONTH and FINTA. Period-formatted cells retain Finta period semantics. Do not assume Google or Excel functions are supported.
create_sheet
Purpose: Create a transaction tag, as under Settings > Tags. Not for: Creating categories or tagging a transaction in the same call. Returns: The tag with id, object, name, transaction_count, vendor_count and top five vendor_names; counts and vendor_names are null without Transactions: View. When to use: The user asks to track transactions with a new tag. Workflow: Call list_tags first and reuse an existing tag. Names use letters, numbers, spaces and hyphens, up to 32 characters; Other is reserved. A duplicate returns tag_already_exists: reuse the existing tag. At the plan's tag limit it returns plan_upgrade_required: reuse an existing tag or ask the user to upgrade. Apply it with update_transaction, one transaction per call.
create_tag
Not available to this company yet (early access: journal entry batches). Contact Finta to request access. Purpose: Delete a journal entry batch or CSV journal entry import and every entry in it. Not for: Single entries. Returns: id and deleted: true. When to use: The user wants a batch undone. Workflow: Find it with list_journal_entry_batches and confirm with the user first.
delete_journal_entry_batch
Purpose: Delete an automation rule so it stops applying to new transactions. Not for: Undoing what the rule did. Its categorizations may reset to the default (matched transfers keep theirs); its other changes stay. Returns: deleted: true and the rule's id, also when it's gone or doesn't exist. When to use: "Delete the AWS rule". Workflow: Find it with list_rules, show the user its conditions and actions, and confirm before deleting. Needs Accounting setup: Manage and Transactions: Manage. On rule_busy, the rule is still running; wait and retry.
delete_rule
Purpose: Permanently delete a spreadsheet and its worksheets. Not for: Clearing cells or removing one tab; use update_sheet. Returns: Its ID and deleted: true. Workflow: Use a current read's ID and revision. On revision_conflict, reread and ask the user again.
delete_sheet
Purpose: Delete a tag. It comes off every transaction and rule; rules that only set this tag are deleted. Categories never change. Not for: Removing a tag from just one transaction; use update_transaction with tag_id: null. Returns: deleted: true and the tag's id. A repeat returns resource_missing. When to use: Removing a tag company-wide. Workflow: Find it with list_tags, tell the user what it removes, and confirm before deleting. On tag_busy, retry the same request.
delete_tag
Purpose: Delete one transaction that came from an upload, such as a row uploaded to the wrong account or uploaded twice. Not for: Synced transactions from a bank or card connection, which are refused. A whole upload; delete_transaction_upload does that. Returns: deleted: true and the transaction's id. Finta support can restore it. When to use: "Delete that transaction I uploaded". Workflow: Takes a txn_ ID from search_transactions. Synced transactions, and transactions that are matched, split, spread, in a reconciled period or in an upload still importing, are refused; the error says why. Needs Transactions: Manage.
delete_transaction
Purpose: Delete an upload and every transaction in it, as on the Uploads page. It can't be undone. Not for: Synced transactions. One transaction from an upload; delete_transaction does that. Returns: deleted: true and the upload's id. When to use: An upload imported wrong data. Re-upload the corrected rows afterwards. Workflow: Get the upl_ ID from list_transaction_uploads. Name the file and its transaction count, and confirm before deleting.
delete_transaction_upload
Purpose: Get the company's balance sheet as of one date: cash, assets, liabilities and equity. For a downloadable PDF, CSV or XLSX, use create_report_export and get_report_export; this tool returns report data, not a file. Not for: Activity over a period, such as revenue or spending (get_income_statement) or cash movement (get_cash_flow). One section on its own; the full statement always comes back. Returns: date is the exact inclusive cutoff used, with currency, refreshed_at, cash_cents, assets and liabilities (each with total_cents and categories), equity (total_cents, categories and retained_earnings), and liabilities_and_equity_cents, which equals assets.total_cents. Each category has category_id, name, balance_cents, position and parent_category_id. Amounts are integer cents, so divide by 100 for dollars. When to use: "How much cash do we have?", "What were our total liabilities at the end of June?", "Show me the balance sheet". Dates and source: Calendar dates use America/Los_Angeles (Pacific Time); balances include all activity through the exact date. Whole months use whole-month rollups. A cutoff of today uses fresh current-month month-to-date (MTD) rollups for month-start through today. Other non-month-end cutoffs use slower raw-entry reads for just the cutoff month. Stale or unfilled MTD safely falls back to raw entries; reported balances are unchanged. Freshness: refreshed_at covers the entire report through its exact cutoff. For rollup-only reads it is the maximum contributing rollup timestamp, including MTD. Any live raw portion is current as of the call, even when no raw entries match. It is null only when no contributing timestamp or live raw read is available. Workflow: Omit date for today in Pacific Time. A parent category's amount already includes its children, so to total a section, add only the categories whose parent_category_id is null, or use the section's total_cents.
get_balance_sheet
Purpose: Get the Finta plan this company is on and what it pays for it, laid out like an invoice. Not for: Other plans or their prices, usage against limits, invoices, payment methods or billing contacts. It can't change the plan. Returns: plan (formation, startup, growth or enterprise), status (the subscription's status, such as active, trialing or past_due; null without a card subscription, as on Formation or Enterprise), interval (month or year), renews_on (null when it won't renew, including when a cancellation is scheduled), plan_price_cents (this company's own price per interval, which can differ from the advertised price), discount_cents (negative, 0 without a discount) and total_cents (what it pays per interval). Amounts are integer cents, so divide by 100 for dollars. plan_price_cents and total_cents are null when the price isn't on file, such as an Enterprise contract without one. plans_url is the company's Plans page in Finta, null on Enterprise. When to use: "What plan are we on?", "How much do we pay Finta?", "Do we have a discount?", "When does our plan renew?" Workflow: Quote the amounts as returned and say total_cents is what they pay. When discount_cents isn't 0, this tool doesn't return how long the discount lasts, so don't say whether the total is temporary or permanent. Give plans_url only when the user asks how to change plan, saying someone with billing access changes it there. Don't suggest changing plans otherwise.
get_billing
Purpose: Get the company's cash flow statement for one date range: cash from operating, investing and financing activities, and cash at the start and end. For a downloadable PDF, CSV or XLSX, use create_report_export and get_report_export; this tool returns report data, not a file. Not for: Profit and loss (get_income_statement) or balances on a date (get_balance_sheet). One section on its own; the full statement always comes back. Returns: start_date and end_date are the exact inclusive dates used, with currency, refreshed_at, operating_activities, investing_activities and financing_activities (each with total_cents and categories), beginning_cash_cents, ending_cash_cents and change_in_cash_cents. Each category has category_id, name, amount_cents, position and parent_category_id. Amounts are signed integer cents, so divide by 100 for dollars. When to use: "How much cash did we burn last quarter?", "Where did our cash go this year?", "What was our operating cash flow in August?" Dates and source: Calendar dates use America/Los_Angeles (Pacific Time), and both boundaries are honored exactly, inclusive. Whole months use whole-month rollups. Current-month start through today uses fresh month-to-date (MTD) rollups, keeping month-aligned month-to-date and year-to-date requests fast. Other partial months, including a midmonth start, use slower raw-entry reads for just those months. Stale or unfilled MTD safely falls back to raw entries; the report's numerical semantics are unchanged. Freshness: refreshed_at covers the entire report, including partial months and opening and closing balances. For rollup-only reads it is the maximum contributing rollup timestamp, including MTD. Any live raw portion is current as of the call, even when no raw entries match. It is null only when no contributing timestamp or live raw read is available. Workflow: Omit both dates for the current quarter to date in Pacific Time. One call covers one period; for a month-by-month view, call once per month. Operating activities include the groups "Changes in Working Capital" and "Non-Cash Expenses", whose IDs start with grp_ rather than cat_. A parent's amount already includes its children, so to total a section, add only the entries whose parent_category_id is null, or use the section's total_cents.
get_cash_flow
Purpose: Get an exact total in one call: for a category and everything under it, or for one merchant, over an inclusive date range or as of an exact date. Or split that total in one call by merchant, ranked, or by month. Not for: The whole income statement or balance sheet; the report tools return those. Uncategorized totals: search_transactions with the same category_id and dates, include_totals: true, limit: 1 (categorized: false for both directions). Listing transactions or entries. Returns: Without group_by: total_cents, debit_cents, credit_cents, currency, point_in_time, the exact dates used and refreshed_at. With group_by: data, a list of rows, each with merchant (null for activity recorded without one) or month, and total_cents, debit_cents and credit_cents, plus the dates used, refreshed_at, has_more and next_cursor. Amounts are signed integer cents, so divide by 100 for dollars: assets are debits minus credits, and every other category is credits minus debits, so expenses come out negative. For a balance sheet category, each month row is cumulative through that month's closing date, with the last calendar month's cutoff at end_date, so never add month rows up for it. When to use: "How much did we spend on software this year?", "What's our total for OpenAI, all time?", "Which vendors do we spend the most on?", "Who are our top 10 customers?", "What did we pay AWS each month?", "Which month did we spend the most?", "What was our accounts receivable balance at the end of June?" Dates: All dates are calendar dates in America/Los_Angeles (Pacific Time). Periodic totals include exactly start_date through end_date, inclusive; point-in-time totals include all activity through the exact date. For group_by month, periodic first and last rows are clipped to the exact range; point-in-time start_date selects the first displayed month without excluding earlier cumulative activity, and the last calendar month's cutoff is end_date. Whole months use whole-month rollups. Current-month start through today uses fresh month-to-date (MTD) rollups, so month-aligned month-to-date and year-to-date requests stay fast. Other partial months, including a midmonth start, use slower raw-entry reads for just those months. Stale or unfilled MTD safely falls back to raw entries. Freshness: refreshed_at covers the whole total or returned page, including partial months, not only full months. For rollup-only reads it is the maximum contributing rollup timestamp, including MTD. Any live raw portion is current as of the call, even when no raw entries match. It is null only when no contributing timestamp or live raw read is available. Workflow: Get category_id and point_in_time from list_categories. When point_in_time is false (income statement categories), pass start_date and end_date; when it's true (balance sheet categories), pass date only, except with group_by month, which always takes start_date and end_date. For vendors use the top-level Expenses category (parent_id null), and for customers the top-level Income category. group_by merchant ranks merchants: order desc, the default, puts the biggest first in the category's own direction (most spent under Expenses, most received under Income), and asc the smallest first; limit takes that many rows from the top, so limit 10 is a top 10. group_by month gives one row per month, up to 120 months, oldest first unless you set order. If has_more is true and you need more rows, call again with the same arguments and starting_after set to next_cursor, unchanged. Merchant names are exact as recorded, so one vendor can appear under several spellings: combine obvious variants and say you did. For one merchant's total, pass merchant, matching the name exactly, including case, from list_merchants or a group_by merchant row. If you don't know the exact spelling, find it with one search_transactions call using merchant and a small limit, then pass the name exactly as it appears there; the total still comes from this tool. Expenses and Income cover every category under them, but not purchases recorded as assets, such as capitalized equipment or the part of a prepaid plan not yet expensed, so a vendor's total can be less than what was paid; say so when it matters. For all time, start at the company's incorporation date from get_company and end today in Pacific Time. Omit group_by for one total; use it only for rankings or monthly breakdowns.
get_category_total
Purpose: Get the details of the company this connection is signed in to: its display name, legal name, entity type, incorporation and legal address. Not for: Financial figures, accounts, the team or connected integrations. The full EIN is never returned, only its last four digits. Returns: id, name (the display name), legal_name, entity_type (c_corp, pbc, llc, s_corp or other), federal_ein_last4, delaware_file_number, incorporation (date and state), legal_address and created. When to use: "What's our legal name?", "When were we incorporated?", "What's our registered address?", or to confirm which company you're working in before making changes. Workflow: Use name when talking to the user and legal_name only where the legal name is asked for.
get_company
Purpose: Get the company's income statement (profit and loss) for one date range: revenue, expenses, operating income, non-operating income, taxes and net income. Use group_by=department for the GAAP P&L; group_by=category is the default. For a downloadable PDF, CSV or XLSX, use create_report_export and get_report_export; this tool returns report data, not a file. Not for: Balances on a date (get_balance_sheet) or cash movement (get_cash_flow). One category on its own; the full statement always comes back. Returns: start_date and end_date are the exact inclusive dates used, with currency, refreshed_at, operating_income_cents and net_income_cents, plus one top-level field per section: revenue, expenses and non_operating_income always, and uncategorized_income and taxes only when the company has those rows. With category grouping, uncategorized_expenses is also present when the company has that row. The response echoes group_by. With category grouping, each section has total_cents and categories. Each category has category_id, name, amount_cents, position and parent_category_id. Amounts are signed integer cents: income is positive and expenses are negative, so divide by 100 for dollars. Department grouping: Expenses have total_cents and rows instead of categories. Each row has row_id, parent_row_id, kind (department, category, or group), nullable department_id and category_id, name, amount_cents and position. Parent amounts include their children. No Department is an assignment group, not uncategorized expenses. Revenue, non-operating income, optional uncategorized income and taxes keep their category format. Department grouping has no top-level uncategorized_expenses field, requires the departments feature and returns refreshed_at=null. When to use: "What was our net income last quarter?", "How much revenue did we make in September?", "What are our biggest expenses this year?" Dates and source: Calendar dates use America/Los_Angeles (Pacific Time), and both boundaries are honored exactly, inclusive. With category grouping, whole months use whole-month rollups. Current-month start through today uses fresh month-to-date (MTD) rollups, keeping month-aligned month-to-date and year-to-date requests fast. Other partial months, including a midmonth start, use slower raw-entry reads for just those months. Stale or unfilled MTD safely falls back to raw entries; the report's numerical semantics are unchanged. Category freshness: refreshed_at covers the entire report, including partial months. For rollup-only reads it is the maximum contributing rollup timestamp, including MTD. Any live raw portion is current as of the call, even when no raw entries match. It is null only when no contributing timestamp or live raw read is available. Workflow: Omit both dates for the current quarter to date in Pacific Time. One call covers one period; for a month-by-month view, call once per month. A parent category's amount already includes its children, so to total a section, add only the categories whose parent_category_id is null, or use the section's total_cents. Writing to Sheets: For a standard income statement, prefer create_sheet with template_id: income_statement and template_options containing starting_month and ending_month (YYYY-MM-DD) for the requested reporting months, which generates live FINTA formulas like the UI. Statement templates cover complete months; do not imply they preserve a partial-month report window. For a custom sheet, use supported FINTA formulas for actuals and ordinary spreadsheet formulas for forecasts. Copy this report's numbers as static actuals only when the user explicitly requests a snapshot.
get_income_statement
Purpose: Check how a connection started with connect_integration is going. Not for: Starting a connection; use connect_integration. The status of integrations in general; list_integrations returns that. Returns: The latest connect_request you started for this integration. status is pending until the user approves at the provider (for Plaid banks, until Plaid reports they've finished, usually within seconds), authorizing while Finta finishes the connection, then complete or failed, or expired when nobody finished the link before expires_at. failure_code says why a failed request failed: access_denied (the user declined, or left Plaid without connecting a bank), provider_admin_required (the approving account isn't a provider admin), provider_error or connection_failed (for a Plaid bank, often a different bank picked in Plaid than the one requested). When to use: After the user says they've approved access at the provider, or that they're back from connecting their bank. "Did the Mercury connection go through?", "Is Chase connected now?" Workflow: While the company is still onboarding, it works only once Finta has approved the company (onboarding_incomplete before then), like connect_integration. Call it once the user says they've approved, not in a loop while they're still at the provider. If it's pending, the user hasn't finished approving; ask them to finish before checking again. If it's authorizing, Finta needs a few more seconds; check once more. If it failed, tell the user why; if they want to retry, call connect_integration for a new link. If a Plaid bank's request expired, check list_integrations first: a late report from Plaid can still connect it. A request that failed or expired stays here until a new one starts.
get_integration_connection
Not available to this company yet (early access: invoices). Contact Finta to request access. Purpose: Get one invoice by its inv_ ID, with the bank deposit that paid it. Not for: Finding invoices by customer, status or amount; list_invoices does that. Returns: invoice, the same object list_invoices returns, and paid_transaction: for a paid invoice, the matched deposit as get_transaction returns it (null while the invoice is open or voided, or when the deposit can't be read, such as one deleted after it was matched). Amounts are integer cents, so divide by 100 for dollars. When to use: "Did Acme pay invoice inv_…?", "When was this invoice paid?", or to check an invoice after create_invoice, void_invoice or match_invoice_payment.
get_invoice
Purpose: Get the company's key metrics month by month: cash, runway, revenue, revenue growth (MoM and YoY), expenses, gross margin and net income. Net income is the company's burn when negative. Not for: A full statement with categories (get_income_statement, get_balance_sheet) or one category's total (get_category_total). Returns: start_date and end_date are the whole months used, with group_by, currency, metrics (the keys returned) and data, one row per month. Each row has label (YYYY-MM), point_in_time and period. point_in_time has as_of plus metrics read on that date, such as cash_cents and runway_months. period has start_date and end_date (inclusive) plus metrics over those dates, such as revenue_cents and net_income_cents. A row holds only the requested metrics; null means the metric doesn't apply to that month, as defined by list_metrics. Amounts are signed integer cents, so divide by 100 for dollars; expenses are negative. Combining months: Revenue, expenses and net income can be added across months. Never add point_in_time values, percentages or runway across months: year-end cash is the last row's cash, and a quarter's growth or margin comes from its summed amounts. Current month: Runs through today. Its MoM and YoY growth compare its revenue so far with the whole earlier month, and its runway uses last month's net income until the 5th, then its net income so far. Long runway: runway_months of 120 or more is normal when the company burns little next to its cash, not an error to investigate. Say "10+ years" rather than the exact number. When to use: Ask only for what the question names, and add metrics or months only when the user asks for them. "What's our runway?" is metrics: [runway_months] with no dates. "What's our burn?" is [net_income_cents]. "How fast is revenue growing?" is [revenue_growth_mom_percent]. Runway is already worked out from cash and burn, so don't fetch those to explain it unless asked. Workflow: Call list_metrics for the keys and their definitions. Omit both dates for the current month to date; pass them only when the user asks about other months. Dates are Pacific Time; a date anywhere in a month selects the whole month, and one call covers up to 36 months.
get_metric_values
Purpose: Get setup progress. Returns: status, answers, remaining questions and next_step. When to use: For setup or after onboarding_incomplete. Don't poll it or call it once setup is complete. Workflow: Follow next_step.message.
get_onboarding
Purpose: Check a report export created with create_report_export, or get a fresh download link for its completed file. Not for: Creating a new export or regenerating a report from updated books; use create_report_export with a new idempotency_key. Returns: The report_export unchanged: id, submitted parameters, status (pending, processing, succeeded or failed), created, started_at, completed_at, generation_duration_ms, file and error. file is null while pending/processing or failed, and once 30 days have passed since completed_at even if status is succeeded. Before that cutoff, a succeeded file contains filename, content_type, size, download_url and expires_at. A failed export returns its error code and message; HTTP success does not mean generation succeeded. Workflow: Call with the export_ ID from creation. If pending or processing, wait between checks, for example 2, 5, 10 then 30 seconds, and use bounded polling; every call consumes MCP allowance. This tool checks once and does not wait or send completion notifications. Stop polling on succeeded or failed. When succeeded with file=null, the 30-day link-regeneration window has ended: tell the user; use create_report_export with a new key only if they want a newly generated report from the current books. When succeeded with a file, fetch file.download_url with your host's download/file tools and use file.filename when saving; if your host cannot download, give the user the link. Report success only after the host confirms the file was saved. Never assume this tool saved a file to the user's computer. Links: Until completed_at plus 30 days (2,592,000 seconds), a succeeded call requests a fresh seven-day URL starting at retrieval; credentials/storage policies can invalidate it sooner. Call this tool again before that cutoff if the link expires. Already-issued URLs keep their original expiry beyond the cutoff; the cutoff also applies to creation replays. Refreshing a link does not regenerate the file or update its financial data. The retained file and export do not automatically expire in the application.
get_report_export
Purpose: Inspect a spreadsheet document and its worksheets, or read selected A1 ranges. Returns: Document metadata and worksheet IDs/names, row_count and column_count (grid bounds); selected values/formulas and optional formats/charts. Calculation errors and warnings are separate from saved inputs. Workflow: Omit ranges to inspect metadata first. Use view: both to see formulas alongside results. Formula reads return stored formulas; values are calculated. Chart metadata identifies embedded charts; no image is returned.
get_sheet
Purpose: Load the steps of one of Finta's skills: playbooks for tasks you carry out for the user with Finta's tools, their browser, or steps you give them. Returns: The skill's name, description and instructions, in Markdown. When to use: When the user asks for a task one of these skills covers, or agrees after you offer it. Don't load a skill just to see what it says; the list below has what each one is for. Workflow: Follow the instructions as written, including asking the user before you start. Skills: grant-access-carta: Help the user manually add Finta to their Carta account as a finance firm grant-access-gusto: Help the user manually add Finta to their Gusto account as their accountant grant-access-mercury: Help the user manually add Finta to their Mercury bank account with the Accountant role grant-access-ramp: Help the user manually add Finta to their Ramp account as an accounting firm grant-access-rippling: Help the user manually add Finta to their Rippling account as a read-only accountant
get_skill
Purpose: List the company's team: active and inactive members, and pending invitations, with each person's access. Not for: Changing anyone's access. Members are managed in the Finta web app; pending invitations with create_team_invitation, update_team_invitation, resend_team_invitation and revoke_team_invitation. Returns: members (id, email, name, state active or inactive, access_template, permissions, created) and invitations (id, email, name, access_template, permissions, invited_by, created, expires), in Settings team page order. access_template is admin, read_only or custom; permissions gives every area's level (none, view or manage); finta_agent controls Finta Agent access. Times are Unix seconds; invitations past expires are expired but pending. Unavailable IDs are null. When to use: "Who's on our Finta team?", "Who has admin access?", "Did Sam accept the invite?", or to find the invite_ ID of an invitation to change, resend or revoke.
get_team
Purpose: Get one transaction by its txn_ ID. Not for: Finding transactions by merchant, date or amount; search_transactions does that. The journal entries a transaction created. Returns: id, date, accounting_date (reports), signed amount_cents (positive in, negative out), currency, merchant, description, memo, category/department/tag/card IDs and names, categorized, transaction_type, source, status, spread, transfer_id, created and updated. Empty fields and standard/approved defaults are omitted. Pass include_source_details for source_notes (bank notes/memos) and category_assigned_from (how the category was set), such as while categorizing. When to use: To check a transaction's current state, such as after updating it, or when the user gives a txn_ ID.
get_transaction
Purpose: Get how much of each Finta limit this company has used: automatic categorizations, stored transactions, AI credits, API calls and MCP tool calls. Not for: What the company pays or which plan it's on, or what other plans allow. It can't raise a limit. Returns: categorizations, transactions, ai_credits, api_calls and mcp_calls, each with used, limit and stopped (true when Finta has stopped because of the limit, as its banners say), plus resets_on, the date monthly counts start over. categorizations and transactions also have held: how many transactions are waiting because of the limit. ai_credits has remaining, the credits left including purchased packs; api_calls and mcp_calls have custom_limit, true when Finta set this company's limit by hand. A null limit means there is none. transactions is the total stored, not a monthly count, so its resets_on is null. plans_url is the company's Plans page in Finta, null on Enterprise. When to use: "How many categorizations do we have left?", "Why did auto-categorization stop?", "Why aren't new transactions showing up?", "Are we close to our limits?", "How many AI credits are left?" Workflow: Calls to this tool don't count toward the monthly MCP limit, and it works after that limit is reached. Quote counts as returned; they can lag by a few minutes. Advice depends on the limit. categorizations stopped: new transactions are auto-categorized again after resets_on, but the held ones are only categorized on a plan with a higher limit, or by hand; waiting doesn't release them. transactions stopped: the held transactions are only synced on a plan with a higher limit; stored transactions never reset, so don't suggest waiting. ai_credits stopped: Ask Finta resumes when monthly credits reset on resets_on. api_calls or mcp_calls stopped: calls resume on resets_on. A limit can be over the plan's usual one when custom_limit is true or Finta has raised it, so don't assume the plan's numbers. Share plans_url only when a limit is stopped and custom_limit isn't true, or when the user asks how to raise a limit: say what the current plan doesn't include, give the link, and say someone with billing access changes the plan there. Don't suggest changing plans otherwise.
get_usage
Purpose: Record that the user invited Finta in a provider's app, closing the inbox item that asked. Not for: Methods whose connect_via isn't provider_app; use connect_integration for api. Returns: The integration as list_integrations shows it. When to use: At the end of a grant-access skill. Workflow: Call only once the user says the invite is sent. Carta and Pulley need url.
grant_integration_access
Purpose: Invite someone to the company's Finta team with the access they should have. Finta emails them a link to join. Access: Only company Admins can invite teammates. Team & access Manage alone is not enough (insufficient_permission); upgrading the plan does not grant this permission. Not for: Changing a pending invitation's access (update_team_invitation) or sending its email again (resend_team_invitation). People who already joined; they're managed in the Finta web app. Returns: invitation, the same object get_team lists, with its invite_ ID; created, true for a new invitation and false when the same invitation was already pending; and changed, true when a repeat renewed an expired invitation or retried its email. When to use: "Invite sam@example.com as an admin", "Give our accountant read-only access to Finta". Workflow: Confirm the person's name, email and access with the user before inviting. Inviting with the same details again is safe and returns the pending invitation; a different pending invitation or an existing teammate with that email is refused (invitation_invalid). You can't grant more access than the signed-in user has (insufficient_permission). read_only and custom need the Growth plan (plan_upgrade_required) and custom roles to be on for the company (feature_disabled); otherwise only admin is available, so tell the user rather than reporting it.
create_team_invitation
Purpose: List the company's bank, credit card and other transaction-source accounts in Finta, with their stable acct_ IDs. Not for: Chart-of-accounts categories, balances or transactions. An account being listed does not mean its bank connection is currently working. Returns: One page of accounts, each with id, account_name, vendor, type (such as bank or credit) and reconciled_through (the date it's reconciled up to, or null), plus has_more and next_cursor. When to use: "Which accounts do we have in Finta?", or to find the acct_ ID of an account the user names. Workflow: If has_more is true, call again with starting_after set to next_cursor, unchanged. Names can repeat or change, so refer to accounts by id.
list_accounts
Purpose: List the company's individual corporate cards from Brex, Ramp, Mercury, Slash and Rho, with their stable card_ IDs. Not for: Bank accounts or card accounts, which list_accounts returns. Plaid credit cards appear there as accounts, not here. A card being listed does not mean its integration is currently working. Returns: One page of cards, each with id, account_id, name, last_four, type (physical or virtual) and status (active or inactive), plus has_more and next_cursor. Inactive and deleted cards are included. Every field but id can be null when it isn't known; Rho cards always have a null account_id, last_four, type and status. Rho cards are known only from their past transactions, so a Rho card that has never been used is missing: when the company uses Rho, don't present the list as every card it has. When to use: "Which cards do we have?", "Which card ends in 4821?", or to find the card_ ID of a card the user names. Workflow: Pass account_id from list_accounts to list only the cards linked to that account. Ramp and Rho cards are never linked to an account, so they appear only without account_id, and an empty filtered list doesn't mean the account has no cards. If has_more is true, call again with starting_after set to next_cursor, unchanged, and the same account_id. Names can repeat or be missing, so match on last_four when the user gives it, and refer to cards by id.
list_cards
Purpose: List the company's whole chart of accounts in Finta, with stable cat_ IDs. Not for: Amounts or transactions; categories carry no totals. Departments are a separate list. Returns: Every category by tier, position and name, including Finta-managed ones like bank accounts and A/R: id, name, description (when to use it), account_type, tier (1 is top level), parent_id, point_in_time (true on the balance sheet), categorization_status and accounting_treatment (what Finta automatically books there; can't be turned off). Empty fields are left out. categorization_status is allowed when you can categorize into it; never for parents, account types and bank accounts; or requires_support_approval when Finta blocks it on purpose but support can enable it. When to use: "Where does Slack go?", or to find a category's cat_ ID. Workflow: Categorize only into allowed categories, after reading descriptions. For never, use a subcategory or another category. For requires_support_approval, tell the user it's blocked, and only if they confirm they need it, ask support to enable it with submit_feedback. An accounting_treatment (today only Equipment) applies at once. Names can repeat, so refer to categories by id.
list_categories
Purpose: List the company's departments in Finta, such as Engineering or Sales, with their stable dept_ IDs. Not for: Categories or the chart of accounts, which are a separate list. Departments carry no amounts. Returns: Every department in one response, in display order. Each has id, name, tier (1 is top level), parent_id, and assignable. When to use: "Which departments do we track?", or to find the dept_ ID of a department the user names. Workflow: Only departments with assignable: true can be assigned to a transaction; the others are groups. Use parent_id to place a department under its group, and refer to departments by id.
list_departments
Purpose: List what Finta needs from the company right now, from its Finta inbox: integrations to connect or reconnect, access to grant, transactions to categorize, and tax steps. Not for: Integration status in general; list_integrations has every integration. Snoozed items, which stay out until their reminder date. Returns: Every open item, oldest first, each with id, type, title, instructions, url and created. instructions say what to do: a skill to run, or that the user does it in the Finta web app at url. When to use: "What does Finta need from me?", "Anything in my Finta inbox?", "Is anything blocking my books?" Workflow: Tell the user what each item asks for. When instructions name a skill, offer to run it and load it with get_skill only if they agree. When the user has to do it, share url. Items close on their own once the work is done.
list_inbox
Purpose: List the banks, cards, payroll and cap table providers Finta offers this company, and whether each is connected. Not for: The accounts or cards an integration brings in; use list_accounts or list_cards. Connecting one; use connect_integration. Returns: Each integration's key, name, type, status, connection_methods and quality. status is connected, not_connected, connecting, or requires_reconnect when the user must sign in again. Each method has its own status (also requested when Finta asked for it in the inbox, granted once the user invited Finta) and connect_via: api (connect_integration), provider_app (the user invites Finta in the provider's app, then grant_integration_access) or web_app. quality is great (real-time), good or third_party (connected through Plaid). When to use: "Is our Brex connected?", "Which banks feed Finta?", "Why did our Mercury transactions stop coming in?" Workflow: If a method has a skill, call get_skill and follow it instead of writing your own steps. Reconnect with connect_integration when connect_via is api, except Plaid banks (chase, svb, arc, citi, boa, american_express), which reconnect only in Finta; otherwise the user does it in Finta. For what Finta needs from the user, look for requested or requires_reconnect methods.
list_integrations
Not available to this company yet (early access: invoices). Contact Finta to request access. Purpose: Find the company's invoices: ones it sent its customers and recorded in Finta so their revenue is booked, with their inv_ IDs. Not for: Sending invoices or reminders; Finta doesn't send anything to customers. Returns: One page of invoices, newest invoice date first, plus has_more and next_cursor. Each has id, status (open, paid or voided), customer_name, invoice_date, amount_cents (the total due), currency, line_items, adjustments, paid_transaction_id and paid_date (set once a bank deposit is matched as its payment), source (manual or stripe) and stripe_url. Amounts are integer cents, so divide by 100 for dollars. When to use: "What invoices are still open?", "What does Acme owe us?", "Which invoice did this deposit pay?" (pass paid_transaction_id), "Which open invoice is this $4,500 deposit for?" (status open and amount "4500.00"), or to check an invoice isn't already recorded before create_invoice. Workflow: Filters combine; all must match. If has_more is true, call again with the same filters and starting_after set to next_cursor, unchanged.
list_invoices
Not available to this company yet (early access: journal entry batches). Contact Finta to request access. Purpose: List journal entry batches, newest first: manual batches (jmb_ IDs) and CSV journal entry imports (jeu_ IDs). Not for: The entries themselves; use search_journal_entries. Returns: id, memo (a CSV import's file name), source (ui, api, mcp or csv_import), entry_count, total debits and credits in dollars, start_date, end_date, plus has_more and next_cursor. When to use: Find a batch to delete. Workflow: Pass next_cursor as starting_after for the next page.
list_journal_entry_batches
Purpose: List the company's merchants and counterparties: the distinct names recorded in one category and every category under it, across all time. Not for: Amounts or rankings; get_category_total gives a merchant's total, or with group_by merchant ranks merchants by amount a page at a time, so a top 10 of vendors or customers is one call and the full ranking continues while has_more is true. Never call get_category_total once per merchant. Names have no IDs. Returns: One page of names, sorted alphabetically ignoring case, each exactly as recorded, plus has_more and next_cursor. Newly imported names can take a little while to appear. When to use: "List my merchants", "Who are our vendors?", "Which vendors do we pay for software?", "Who pays us?", or to find the exact spelling of a merchant name before filtering by it. Workflow: Get category_id from list_categories. For the vendors the company has expensed, use the top-level Expenses category (parent_id null); for everyone the company has income from, the top-level Income category; for a narrower list, a category under them, such as Software. A vendor paid only for purchases recorded as assets, such as capitalized equipment, appears under that asset category instead. Use names exactly as returned, case included, as the merchant in get_category_total or search_journal_entries. If has_more is true, call again with the same category_id and starting_after set to next_cursor, unchanged.
list_merchants
Purpose: List the key metrics get_metric_values can return, such as cash, runway, revenue, revenue growth, gross margin and net income (burn). Returns: data, one entry per metric: key (pass it to get_metric_values), group and definition. group is point_in_time for values read on the row's as_of date, such as cash, or period for values over its start_date to end_date, such as revenue. When to use: Before get_metric_values, when you need a metric's exact meaning or want to know which metrics exist.
list_metrics
Purpose: List the company's automation rules, with rule_ IDs. A rule matches transactions by its conditions and sets a merchant, category, department, tag, spread or accounting date. Not for: Running rules or editing transactions. Rules Finta manages, or that a category or department owns, aren't listed. Returns: Rules newest first, has_more and next_cursor. Each has conditions (all must match), actions, and action_names with the category, department and tag names. amount_cents is signed, negative for money out. When to use: "Change my AWS rule", "Which rules set Software?", or to get a rule_ ID for update_rule or delete_rule. Workflow: Filter by a category, department, tag, account or card ID; filters combine. No merchant search: page with starting_after = next_cursor. account and card_name text conditions are legacy.
list_rules
Purpose: List or find the company's spreadsheet documents by name. A sheet is a document; worksheets are its tabs. Returns: A page of document IDs, names, Finta links and revisions. Follow next_cursor using starting_after when has_more is true. Workflow: Find a document here, then use get_sheet to inspect its worksheets before editing.
list_sheets
Purpose: List approved spreads, including eligible pending shortenings. App Spreads pages stay stored until save. Includes split-line spreads, which search_transactions can't show. Not for: The monthly amounts a spread books, which are journal entries (search_journal_entries with source_type spread). Spreads still awaiting approval, which aren't listed. Totals of any kind, which get_category_total returns. Returns: One page of spreads, newest date first, plus has_more and next_cursor. Each has transaction_id, split, months, date, accounting_date, amount_cents, currency, merchant, category_id and category_name, department_id and department_name. When split is true, the spread is on one line of the split transaction named by transaction_id, and the amount, category and dates are that line's. Spreads have no ID of their own. amount_cents is signed integer cents: negative for money out, so divide by 100 for dollars. When to use: "Which transactions are spread?", "List our spreads", "Is this charge spread, and over how many months?". Workflow: Pass a txn_ ID as transaction_id for the spreads on that transaction or on its split lines. All filters must match. If has_more is true, call again with the same filters and starting_after set to next_cursor, unchanged.
list_spreads
Purpose: List the company’s transaction tags, with their stable tag_ IDs. Not for: Categories, departments or totals by tag. Returns: Every tag in one response, with id, object, name, transaction_count, vendor_count and the top five vendor_names. Counts and vendor_names are null without Transactions: View. When to use: Find a tag the user names, or see which tags the company tracks. Workflow: Use the tag_ ID with search_transactions or update_transaction.
list_tags
Purpose: List the lines of the company's split transactions: the parts one bank or card transaction was divided into, each with its own amount, category, department and spread. Not for: Splitting a transaction; split_transaction does that. The split transactions themselves, which search_transactions returns with transaction_type split at their full amount. Department splits and payroll bulk splits, which aren't listed. Totals of any kind, which get_category_total returns. Returns: One page of lines, newest date first, plus has_more and next_cursor. Each has transaction_id (the split transaction it belongs to), date, accounting_date, amount_cents, currency, merchant, category_id and category_name, department_id and department_name, and spread (months, or null). Lines have no ID of their own. amount_cents is signed integer cents: negative for money out, so divide by 100 for dollars. A split's lines add up to its amount. When to use: "What was this charge split into?", "Show me all our split transactions with their breakdown", "Which split lines are spread?". Workflow: To break down one split, pass its txn_ ID as transaction_id. To see every split's lines, omit it and page through: that's one list, not one call per split. All filters must match. If has_more is true, call again with the same filters and starting_after set to next_cursor, unchanged.
list_transaction_splits
Finta ChatGPT Plugin FAQ
How the directory, categories and Discoverability Score work.
Read the methodologyHow do I improve Finta's ChatGPT Plugin discoverability?
The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.
What are Finta alternatives on ChatGPT?
As of 2026-11-20, Finta competes with Accountable, Agenix Invoice, AgentCollect, Aikount, Akaunting, ALL-FOOD Import Calculator, AltiBooks, Ambrook and 103 more in ChatGPT Accounting & Bookkeeping, ranked by public Discoverability Score.
Where is this profile measured?
This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.