> **Building with AI coding agents?** Install the authstack plugin with one command. This equips your agent with accurate Scalekit implementation patterns. > > **Recommended** (the `-y` flags skip prompts, so the command runs without an interactive terminal): > ```bash > npx -y @scalekit-inc/cli setup -y > ``` > > Global: > ```bash > npm install -g @scalekit-inc/cli > scalekit setup -y > ``` > > Supports Claude Code, Cursor, GitHub Copilot, Codex + skills for other Agent Skills-compatible agents in `~/.agents/skills`. > Skills: integrate-agentkit, implement-saaskit, add-mcp-oauth, implement-sso, implement-scim. > [Full setup guide](https://docs.scalekit.com/dev-kit/build-with-ai/) --- # Connect AI agents to Plaid The Plaid connector lets your AI agent act in each user's Plaid account. Each user connects their own Plaid API key once, and Scalekit sends it with every call, so your agent never handles credentials. It comes with 27 tools. **Authentication:** API Key **Categories:** Accounting & Finance **Tools:** 27: 17 read, 7 write, 3 destructive **Users sign in with:** API key **Built by:** Scalekit connector **Try it:** [Playground in the Scalekit dashboard](https://app.scalekit.com/ws/signup?sk_intent=playground&provider=PLAID) ## Setup 1. ### Install the SDK **Node.js** ```bash npm install @scalekit-sdk/node dotenv ``` **Python** ```bash pip install scalekit-sdk-python python-dotenv ``` 2. ### Set your credentials Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. ```sh title=".env" SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Create the Plaid connection In **AgentKit > Connections**, create a Plaid connection. The name you give it is the `connection_name` your code passes. See [Configure connections](/agentkit/connections/). **Console steps with screenshots:** Plaid connections use your Plaid client ID and **Production** secret, and call Plaid's Production environment (`production.plaid.com`) with real bank data. Your Plaid team must be approved by Plaid for Production access. To build and test with test banks first, use the [Plaid Sandbox connector](/agentkit/connectors/plaidsandbox/). 1. ### Copy your Plaid keys In the Plaid Dashboard, open **Developers** > [**Keys**](https://dashboard.plaid.com/developers/keys) and copy your **client ID** and your **Production** secret. The client ID is the same in every Plaid environment; the secret is not. 2. ### Create the connection In the [Scalekit dashboard](https://app.scalekit.com), go to **AgentKit** > **Connections** > **Create Connection**, find **Plaid** and click **Create**. The connection name is the `connection_name` your code passes. 3. ### Add a connected account To test, open the connection, click the **Connected Accounts** tab > **Add Account**, enter the user's identifier, such as `user_123`, and fill in **Client ID** and **Production Secret**. In production, each user opens the authorization link and enters the same fields there. 4. ### Pass an Item's access token to each tool The tools read and manage Items your app has already linked. An Item is one end user's login at a bank. Your app links Items the usual Plaid way: 1. Create a Link token (`plaid_link_token_create` can do this) and open Plaid Link with it in your app. 2. When Link succeeds, exchange the `public_token` it returns for the Item's `access_token` and `item_id`. `plaid_item_public_token_exchange` does the exchange. A `public_token` expires after 30 minutes and can be exchanged once. 3. Store the `access_token` on your server, and pass it as the `access_token` input on each tool call for that Item, such as `plaid_accounts_get`. > caution: Treat access tokens as secrets > > An Item's `access_token` gives access to that end user's bank data. Keep it on your server, never in client code or logs. 4. ### Authorize a user and make your first call **Node.js** (`quickstart.mts`) ```typescript import { ScalekitClient } from '@scalekit-sdk/node' import 'dotenv/config' import { createInterface } from 'node:readline/promises' const scalekit = new ScalekitClient( process.env.SCALEKIT_ENVIRONMENT_URL, process.env.SCALEKIT_CLIENT_ID, process.env.SCALEKIT_CLIENT_SECRET, ) const actions = scalekit.actions const connector = 'plaid' const identifier = 'user_123' // Generate an authorization link for the user const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) console.log('Authorize Plaid:', link) const rl = createInterface({ input: process.stdin, output: process.stdout }) await rl.question('Press Enter after authorizing...') rl.close() // Make your first call const result = await actions.executeTool({ connector, identifier, toolName: 'plaid_accounts_balance_get', toolInput: { access_token: 'YOUR_ACCESS_TOKEN' }, }) console.log(result) ``` ```bash npx tsx quickstart.mts ``` **Python** (`quickstart.py`) ```python import os from scalekit import ScalekitClient from dotenv import load_dotenv load_dotenv() scalekit_client = ScalekitClient( env_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"), client_id=os.getenv("SCALEKIT_CLIENT_ID"), client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), ) actions = scalekit_client.actions connection_name = "plaid" identifier = "user_123" # Generate an authorization link for the user link_response = actions.get_authorization_link( connection_name=connection_name, identifier=identifier, ) print("Authorize Plaid:", link_response.link) input("Press Enter after authorizing...") # Make your first call result = actions.execute_tool( tool_input={"access_token":"YOUR_ACCESS_TOKEN"}, tool_name="plaid_accounts_balance_get", connection_name=connection_name, identifier=identifier, ) print(result) ``` ```bash python quickstart.py ``` Each user opens the link once and enters their Plaid credentials there. If your app already has a user's credentials, add the account from your backend instead, as the console steps above show. See [Authorize a user](/agentkit/tools/authorize/) for the full flow and statuses. ## Tools Pass the exact name to `execute_tool`, with an input like each tool's example. To ask for a tool that's missing, use the [request form](https://scalekitsupport.portal.usepylon.com/forms/request-a-connector-tool). **Node.js** ```typescript const result = await actions.executeTool({ toolName: 'plaid_accounts_balance_get', toolInput: { access_token: '', }, connector: 'plaid', identifier: 'user_123', }) ``` **Python** ```python result = actions.execute_tool( tool_name="plaid_accounts_balance_get", tool_input={ "access_token": "", }, connection_name="plaid", identifier="user_123", ) ``` `result.data` is the app's response as JSON, and `result.execution_id` (`executionId` in Node.js) is the ID of the call. ### `plaid_accounts_balance_get` Get Real-Time Balances · Read-only Get real-time balances for an Item's accounts by fetching fresh data from the institution. Returns accounts with balances (available, current, limit, iso_currency_code, last_updated_datetime) and item. Use plaid_accounts_balance_get before moving money or whenever balances must be current. Each call is billed and usually takes under 10 seconds, sometimes 30 or more. Use plaid_accounts_get for free cached balances. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `access_token` (`string`, required): The Item's access_token, returned by plaid_item_public_token_exchange after the end user links an account with Plaid Link. It starts with access-production-. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. - `account_ids` (`array`, optional): Limit the accounts returned to these account_ids, from plaid_accounts_get. Leave empty for all of the Item's accounts. Plaid returns an error if an id does not belong to the Item. Example: ["BxBXxLj1m4HMXBm9WZZmCWVbPjX16EHwv99vp"]. - `min_last_updated_datetime` (`string`, optional): Oldest acceptable balance time, ISO 8601 (YYYY-MM-DDTHH:mm:ssZ). Only needed for institutions that do not return real-time balances (for example Capital One); Plaid returns an error if its balance is older. Example: 2026-10-20T00:00:00Z. Example input: `{"access_token":""}` ### `plaid_accounts_get` Get Accounts · Read-only List the active accounts on an Item, with balances cached from Plaid's last update. Returns accounts (account_id, name, official_name, mask, type, subtype, and balances with available, current, limit and iso_currency_code) and item. Use plaid_accounts_get for account ids, names and types; it is free. Use plaid_accounts_balance_get when balances must be real-time. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `access_token` (`string`, required): The Item's access_token, returned by plaid_item_public_token_exchange after the end user links an account with Plaid Link. It starts with access-production-. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. - `account_ids` (`array`, optional): Limit the accounts returned to these account_ids, from plaid_accounts_get. Leave empty for all of the Item's accounts. Plaid returns an error if an id does not belong to the Item. Example: ["BxBXxLj1m4HMXBm9WZZmCWVbPjX16EHwv99vp"]. Example input: `{"access_token":""}` ### `plaid_auth_get` Get Auth (Account and Routing Numbers) · Read-only Get the account and routing numbers of an Item's checking, savings and cash management accounts. Returns numbers (ach with account and routing numbers for US accounts, eft for Canada, international with IBAN and BIC, bacs for the UK), accounts with balances, and item. Use plaid_auth_get to set up ACH or other bank transfers. The Item must have the auth product. Use plaid_accounts_get when you only need account names and masks. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `access_token` (`string`, required): The Item's access_token, returned by plaid_item_public_token_exchange after the end user links an account with Plaid Link. It starts with access-production-. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. - `account_ids` (`array`, optional): Limit results to these account_ids, from plaid_accounts_get. Leave empty for all of the Item's accounts. Plaid returns an error if an id does not belong to the Item. Example: ["BxBXxLj1m4HMXBm9WZZmCWVbPjX16EHwv99vp"]. Example input: `{"access_token":""}` ### `plaid_identity_get` Get Identity · Read-only Get the account holder information that the institution has on file for an Item's accounts. Returns accounts, each with owners holding names, emails, phone_numbers and addresses (only names are always present), and item. Use plaid_identity_get to read who owns an account. Use plaid_identity_match to score data you already have against the bank's records without reading it. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `access_token` (`string`, required): The Item's access_token, returned by plaid_item_public_token_exchange after the end user links an account with Plaid Link. It starts with access-production-. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. - `account_ids` (`array`, optional): Limit results to these account_ids, from plaid_accounts_get. Leave empty for all of the Item's accounts. Plaid returns an error if an id does not belong to the Item. Example: ["BxBXxLj1m4HMXBm9WZZmCWVbPjX16EHwv99vp"]. Example input: `{"access_token":""}` ### `plaid_identity_match` Match Identity · Read-only Score how well a name, phone number, email address and postal address match the account holder data at the institution. Returns accounts, each with legal_name, phone_number, email_address and address match scores from 0 to 100 (plus flags such as is_nickname_match and is_postal_code_match), and item. Use plaid_identity_match to verify that a user owns an account. Provide at least one of the identity fields. Use plaid_identity_get to read the bank-held data itself. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `access_token` (`string`, required): The Item's access_token, returned by plaid_item_public_token_exchange after the end user links an account with Plaid Link. It starts with access-production-. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. - `account_ids` (`array`, optional): Limit matching to these account_ids, from plaid_accounts_get. Leave empty for all of the Item's accounts. Plaid returns an error if an id does not belong to the Item. Example: ["BxBXxLj1m4HMXBm9WZZmCWVbPjX16EHwv99vp"]. - `address` (`object`, optional): The user's address with street, city, region, postal_code and country (ISO-3166-1 alpha-2). Example: {"street": "2992 Cameron Road", "city": "Malakoff", "region": "NY", "postal_code": "14236", "country": "US"}. - `email_address` (`string`, optional): The user's email address. Example: accountholder0@example.com. - `legal_name` (`string`, optional): The user's full legal name. Example: Alberta Bobbeth Charleson. - `phone_number` (`string`, optional): The user's phone number in E.164 format, +{country code}{number}. Example: +14157452130. Example input: `{"access_token":""}` ### `plaid_institutions_get` List Institutions · Read-only List the financial institutions Plaid supports in the given countries, page by page. Returns institutions (institution_id, name, products, country_codes, routing_numbers, oauth, and url, logo and primary_color when include_optional_metadata is true) and total. Use plaid_institutions_get to page through or filter all institutions by product, routing number or OAuth. Use plaid_institutions_search to find a bank by name and plaid_institutions_get_by_id when you have its id. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `country_codes` (`array`, required): Countries to include institutions from, as ISO-3166-1 alpha-2 codes. Plaid supports US, CA, GB and several EU countries. Example: ["US"]. - `count` (`integer`, optional): Institutions to return per page, 1 to 500. Defaults to 100 in this tool. Default: `100`. - `include_optional_metadata` (`boolean`, optional): Set to true to also return each institution's url, logo (base64 PNG) and primary_color. Defaults to false. - `oauth` (`boolean`, optional): Set to true for only institutions with an OAuth login flow, or false for only those without. Leave empty for both. - `offset` (`integer`, optional): Number of institutions to skip, for paging. Defaults to 0. Example: 100. Default: `0`. - `products` (`array`, optional): Only return institutions that support all of these products. Example: ["transactions", "auth"]. - `routing_numbers` (`array`, optional): Only return institutions that match all of these 9-digit routing numbers. Example: ["011000138"]. Example input: `{"country_codes":["US"]}` ### `plaid_institutions_get_by_id` Get Institution · Read-only Get one institution's details by its Plaid institution_id, including institutions no longer supported for new connections. Returns institution (institution_id, name, products, country_codes, routing_numbers, oauth, connection_availability, and with the options its url, logo, primary_color and per-product health status). Use plaid_institutions_get_by_id with the institution_id of an Item from plaid_item_get. Use plaid_institutions_search to find an id by name. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `country_codes` (`array`, required): Countries to include the institution from, as ISO-3166-1 alpha-2 codes. Plaid supports US, CA, GB and several EU countries. Example: ["US"]. - `institution_id` (`string`, required): The Plaid institution_id, case-sensitive. Find it in plaid_item_get or plaid_institutions_search. Example: ins_56. - `include_optional_metadata` (`boolean`, optional): Set to true to also return the institution's url, logo (base64 PNG) and primary_color. Defaults to false. - `include_status` (`boolean`, optional): Set to true to also return the institution's current health per product (status). Defaults to false. Example input: `{"country_codes":["US"],"institution_id":""}` ### `plaid_institutions_search` Search Institutions · Read-only Search the institutions Plaid supports for new connections by name, returning up to 10 matches. Returns institutions with institution_id, name, products, country_codes, routing_numbers and oauth (plus url, logo and primary_color when include_optional_metadata is true). Use plaid_institutions_search to find a bank's institution_id from its name. Use plaid_institutions_get to page through all institutions. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `country_codes` (`array`, required): Countries to include institutions from, as ISO-3166-1 alpha-2 codes. Plaid supports US, CA, GB and several EU countries. Example: ["US"]. - `query` (`string`, required): Text to match against institution names. Example: Chase. - `include_optional_metadata` (`boolean`, optional): Set to true to also return each institution's url, logo (base64 PNG) and primary_color. Defaults to false. - `oauth` (`boolean`, optional): Set to true for only institutions with an OAuth login flow, or false for only those without. Leave empty for both. - `products` (`array`, optional): Only return institutions that support all of these products. Leave empty for any product. Example: ["transactions"]. Example input: `{"country_codes":["US"],"query":""}` ### `plaid_investments_holdings_get` Get Investment Holdings · Read-only Get the positions held in an Item's investment accounts. Returns holdings (account_id, security_id, quantity, institution_price, institution_value, cost_basis), securities (security_id, name, ticker_symbol, type, close_price), accounts and item. Use plaid_investments_holdings_get for a current portfolio snapshot; join holdings to securities on security_id. Use plaid_investments_transactions_get for buys, sells and dividends over time. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `access_token` (`string`, required): The Item's access_token, returned by plaid_item_public_token_exchange after the end user links an account with Plaid Link. It starts with access-production-. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. - `account_ids` (`array`, optional): Limit holdings to these account_ids, from plaid_accounts_get. Leave empty for all of the Item's accounts. Plaid returns an error if an id does not belong to the Item. Example: ["BxBXxLj1m4HMXBm9WZZmCWVbPjX16EHwv99vp"]. Example input: `{"access_token":""}` ### `plaid_investments_transactions_get` Get Investment Transactions · Read-only Get the investment transactions (buys, sells, dividends, fees, transfers) of an Item between two dates, up to 24 months back. Returns investment_transactions (newest first, with type, subtype, quantity, price, amount, fees and security_id), securities, accounts, item and total_investment_transactions. Use plaid_investments_transactions_get for investment activity; raise offset by count until you have total_investment_transactions. Use plaid_transactions_sync for bank and credit card transactions. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `access_token` (`string`, required): The Item's access_token, returned by plaid_item_public_token_exchange after the end user links an account with Plaid Link. It starts with access-production-. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. - `end_date` (`string`, required): Latest transaction date to return, YYYY-MM-DD. Example: 2026-10-21. - `start_date` (`string`, required): Earliest transaction date to return, YYYY-MM-DD. Example: 2025-10-21. - `account_ids` (`array`, optional): Limit transactions to these account_ids, from plaid_accounts_get. Leave empty for all of the Item's accounts. Plaid returns an error if an id does not belong to the Item. Example: ["BxBXxLj1m4HMXBm9WZZmCWVbPjX16EHwv99vp"]. - `async_update` (`boolean`, optional): Only for Items that were not linked with investments. Set to true to return immediately and get a HISTORICAL_UPDATE webhook when data is ready, instead of waiting for the extraction. Defaults to false. - `count` (`integer`, optional): Transactions to return per page, 1 to 500. Defaults to 100. Default: `100`. - `offset` (`integer`, optional): Number of transactions to skip, for paging. Defaults to 0. Example: 100. Default: `0`. Example input: `{"access_token":"","end_date":"","start_date":""}` ### `plaid_item_get` Get Item · Read-only Get the status and metadata of one linked Item, which is a user's login at one financial institution. Returns item (item_id, institution_id, institution_name, webhook, products, billed_products, available_products, consented_products, consent_expiration_time and any error) and status with the last successful and failed update per product. Use plaid_item_get to check an Item's health, products or error state, for example ITEM_LOGIN_REQUIRED. Use plaid_accounts_get for the Item's accounts and plaid_institutions_get_by_id for its institution. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `access_token` (`string`, required): The Item's access_token, returned by plaid_item_public_token_exchange after the end user links an account with Plaid Link. It starts with access-production-. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. Example input: `{"access_token":""}` ### `plaid_liabilities_get` Get Liabilities · Read-only Get loan and credit card details for an Item's credit and loan accounts. Returns liabilities with credit (APRs, minimum payment, last statement balance, next payment due date), mortgage and student loan details, plus accounts and item. Use plaid_liabilities_get for debts, interest rates and payment due dates. The Item must have the liabilities product. Use plaid_accounts_balance_get for real-time balances only. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `access_token` (`string`, required): The Item's access_token, returned by plaid_item_public_token_exchange after the end user links an account with Plaid Link. It starts with access-production-. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. - `account_ids` (`array`, optional): Limit results to these account_ids, from plaid_accounts_get. Leave empty for all of the Item's accounts. Plaid returns an error if an id does not belong to the Item. Example: ["BxBXxLj1m4HMXBm9WZZmCWVbPjX16EHwv99vp"]. Example input: `{"access_token":""}` ### `plaid_link_token_get` Get Link Token · Read-only Get a Link session's configuration and results by its link_token. Returns link_token, created_at, expiration, metadata (products, country_codes, webhook, client_name) and link_sessions with each session's events and results, including any public_token. Use plaid_link_token_get with Hosted Link or Multi-Item Link, where your app gets no onSuccess callback, then pass the public_token to plaid_item_public_token_exchange. For other Link flows, Plaid must enable full session data on your account. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `link_token` (`string`, required): A link_token from plaid_link_token_create. Example: link-production-af1a0311-da53-4636-b754-dd15cc058176. Example input: `{"link_token":""}` ### `plaid_statements_list` List Statements · Read-only List the bank statements Plaid holds for an Item's accounts. Returns accounts (account_id, account_name, account_mask, account_type, account_subtype), each with statements (statement_id, date_posted, month, year), plus item_id, institution_id and institution_name. Use plaid_statements_list to see which monthly statements are available. Use plaid_statements_refresh to fetch statements for another date range. The Item must have the statements product; this connector does not download statement PDFs. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `access_token` (`string`, required): The Item's access_token, returned by plaid_item_public_token_exchange after the end user links an account with Plaid Link. It starts with access-production-. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. Example input: `{"access_token":""}` ### `plaid_transactions_get` Get Transactions · Read-only Get an Item's transactions between two dates, page by page. Returns transactions (newest first, with transaction_id, account_id, amount, date, name, merchant_name, pending and personal_finance_category), total_transactions, accounts and item. Use plaid_transactions_get for a one-off date-range lookup; raise offset by count until you have total_transactions. Use plaid_transactions_sync to keep a local copy up to date. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `access_token` (`string`, required): The Item's access_token, returned by plaid_item_public_token_exchange after the end user links an account with Plaid Link. It starts with access-production-. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. - `end_date` (`string`, required): Latest transaction date to return, YYYY-MM-DD. Example: 2026-10-21. - `start_date` (`string`, required): Earliest transaction date to return, YYYY-MM-DD. Example: 2026-01-01. - `account_ids` (`array`, optional): Limit transactions to these account_ids, from plaid_accounts_get. Leave empty for all of the Item's accounts. Plaid returns an error if an id does not belong to the Item. Example: ["BxBXxLj1m4HMXBm9WZZmCWVbPjX16EHwv99vp"]. - `count` (`integer`, optional): Transactions to return per page, 1 to 500. Defaults to 100. Default: `100`. - `days_requested` (`integer`, optional): Days of transaction history (1 to 730) to request when this call is what adds Transactions to the Item. Ignored if the Item already has Transactions. Plaid defaults to 90. - `include_original_description` (`boolean`, optional): Set to true to also return each transaction's raw, unparsed description from the institution (original_description). Defaults to false. - `offset` (`integer`, optional): Number of transactions to skip, for paging. Defaults to 0. Example: 100. Default: `0`. - `personal_finance_category_version` (`string`, optional): Version of Plaid's personal finance category taxonomy to return: v1 or v2. Leave empty for the version your Plaid account is set to. Example: v2. One of: `v1`, `v2`. Example input: `{"access_token":"","end_date":"","start_date":""}` ### `plaid_transactions_recurring_get` Get Recurring Transactions · Read-only Get the recurring deposits and payments, such as salary, subscriptions and bills, that Plaid detects on an Item's accounts. Returns inflow_streams and outflow_streams, each with stream_id, account_id, description, merchant_name, frequency, average_amount, last_amount, first_date, last_date, predicted_next_date, is_active, status and transaction_ids, plus updated_datetime. Use plaid_transactions_recurring_get for subscription, income or bill analysis. Use plaid_transactions_sync for individual transactions. Needs the Recurring Transactions add-on and an Item whose transaction history has finished loading; 180 or more days of history gives the best results. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `access_token` (`string`, required): The Item's access_token, returned by plaid_item_public_token_exchange after the end user links an account with Plaid Link. It starts with access-production-. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. - `account_ids` (`array`, optional): Limit streams to these account_ids, from plaid_accounts_get. Leave empty for all of the Item's accounts. Plaid returns an error if an id does not belong to the Item. Example: ["BxBXxLj1m4HMXBm9WZZmCWVbPjX16EHwv99vp"]. - `personal_finance_category_version` (`string`, optional): Version of Plaid's personal finance category taxonomy to return: v1 or v2. Leave empty for the version your Plaid account is set to. Example: v2. One of: `v1`, `v2`. Example input: `{"access_token":""}` ### `plaid_transactions_sync` Sync Transactions · Read-only Get an Item's transaction changes since a cursor: transactions added, modified and removed. Returns added and modified transactions (transaction_id, account_id, amount, iso_currency_code, date, name, merchant_name, pending, personal_finance_category), removed transaction ids, next_cursor, has_more and transactions_update_status. Use plaid_transactions_sync to load history and then stay up to date: leave cursor empty on the first call, pass next_cursor each time, and repeat while has_more is true. Use plaid_transactions_get for a fixed date range. Right after linking, results can be empty until transactions_update_status reaches INITIAL_UPDATE_COMPLETE or HISTORICAL_UPDATE_COMPLETE; call again later. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `access_token` (`string`, required): The Item's access_token, returned by plaid_item_public_token_exchange after the end user links an account with Plaid Link. It starts with access-production-. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. - `account_id` (`string`, optional): Only return changes for this one account_id, from plaid_accounts_get. The cursor then tracks only that account. Example: BxBXxLj1m4HMXBm9WZZmCWVbPjX16EHwv99vp. - `count` (`integer`, optional): Maximum transaction updates to return per call, 1 to 500. Defaults to 100. Default: `100`. - `cursor` (`string`, optional): next_cursor from the previous call. Leave empty on the first call to get the full history. Store the latest cursor to fetch only new changes next time. Example: eyJsYXN0X2FjY291bnRfdXBkYXRlIjoiMjAyNi0xMC0yMFQwMDowMDowMFoifQ. - `days_requested` (`integer`, optional): Days of transaction history (1 to 730) to request when this call is what adds Transactions to the Item. Ignored if the Item already has Transactions. Plaid defaults to 90. - `include_original_description` (`boolean`, optional): Set to true to also return each transaction's raw, unparsed description from the institution (original_description). Defaults to false. - `personal_finance_category_version` (`string`, optional): Version of Plaid's personal finance category taxonomy to return: v1 or v2. Leave empty for the version your Plaid account is set to. Example: v2. One of: `v1`, `v2`. Example input: `{"access_token":""}` ### `plaid_investments_refresh` Refresh Investments · Write Ask Plaid to fetch an Item's newest investment holdings and transactions from the institution now. Returns only request_id. If anything changed, Plaid fires HOLDINGS and INVESTMENTS_TRANSACTIONS DEFAULT_UPDATE webhooks. Use plaid_investments_refresh when a user expects a very recent trade, then read it with plaid_investments_holdings_get or plaid_investments_transactions_get. It is a separately billed add-on, not every institution supports it, and the Item must have investments. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `access_token` (`string`, required): The Item's access_token, returned by plaid_item_public_token_exchange after the end user links an account with Plaid Link. It starts with access-production-. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. Example input: `{"access_token":""}` ### `plaid_item_public_token_exchange` Exchange Public Token · Write Exchange a public_token from Plaid Link for the permanent access_token of the new Item. Returns access_token and item_id. Store both: every product tool needs the access_token, and webhooks name the Item by item_id. Use plaid_item_public_token_exchange once per Link success, right after Link returns a public_token. A public_token expires after 30 minutes and can be exchanged only once. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `public_token` (`string`, required): The public_token from Plaid Link's onSuccess callback or plaid_link_token_get. It starts with public-production- and expires 30 minutes after Link returns it. Example: public-production-b0e2c4ee-a763-4df5-bfe9-46a46bce993d. Example input: `{"public_token":""}` ### `plaid_item_webhook_update` Update Item Webhook · Write Set or remove the webhook URL that Plaid notifies about one Item. Returns the updated item, including its webhook. Plaid then sends a WEBHOOK_UPDATE_ACKNOWLEDGED webhook to the new URL. Use plaid_item_webhook_update to point an existing Item at a new endpoint, or leave webhook empty to remove it. For new Items, set the webhook in plaid_link_token_create instead. Read only: no. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `access_token` (`string`, required): The Item's access_token, returned by plaid_item_public_token_exchange after the end user links an account with Plaid Link. It starts with access-production-. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. - `webhook` (`string`, optional): The new HTTPS webhook URL for the Item. Leave empty to remove the Item's webhook. Example: https://example.com/plaid/webhook. Example input: `{"access_token":""}` ### `plaid_link_token_create` Create Link Token · Write Create a link_token that your app uses to open Plaid Link, either to connect a new Item or to open update mode for an existing one. Returns link_token and its expiration (4 hours for a new Item, 30 minutes for update mode), plus hosted_link_url when hosted_link is set. Use plaid_link_token_create before each Link session. Pass access_token, and no products, to open update mode, which repairs an Item in ITEM_LOGIN_REQUIRED or adds accounts. Use plaid_link_token_get to read the session's results afterwards. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `client_name` (`string`, required): Your application's name as Link should show it, up to 30 characters. Longer names show as "This Application". Example: Acme Budget. - `client_user_id` (`string`, required): Your own stable, unique id for the end user, up to 128 characters. Do not use personal data such as an email address or phone number. Sent as user.client_user_id. Example: user-8231. - `country_codes` (`array`, required): Countries to include institutions shown in Link from, as ISO-3166-1 alpha-2 codes. Plaid supports US, CA, GB and several EU countries. Example: ["US"]. - `access_token` (`string`, optional): An existing Item's access_token, to open Link in update mode for that Item, for example to fix ITEM_LOGIN_REQUIRED or add accounts. Leave products empty when you set this. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. - `account_filters` (`object`, optional): Limit which account types and subtypes the user can pick in Link. Keys are account types (depository, credit, loan, investment, other), each with an account_subtypes list. Example: {"depository": {"account_subtypes": ["checking", "savings"]}}. - `additional_consented_products` (`array`, optional): Products the user consents to now so you can add them later without sending the user through Link again. They are not billed until you use them. Example: ["liabilities"]. - `android_package_name` (`string`, optional): Your Android app's package name, required when Link runs on Android. Must be registered in the Plaid Dashboard. Example: com.example.budget. - `hosted_link` (`object`, optional): Set this to use Hosted Link, where Plaid hosts the Link page and returns hosted_link_url; an empty object {} is enough. Optional keys: completion_redirect_uri (where to send the user afterwards), url_lifetime_seconds (how long the URL stays valid) and is_mobile_app. Example: {"completion_redirect_uri": "https://example.com/plaid/done", "url_lifetime_seconds": 3600}. - `language` (`string`, optional): Language Link is shown in, as a two-letter code such as en, fr, es or de. Defaults to en. Example: en. One of: `da`, `nl`, `en`, `et`, `fr`, `de`, `ht`, `hi`, `it`, `lv`, `lt`, `nb`, `pl`, `pt`, `ro`, `es`, `sv`, `vi`. Default: `en`. - `link_customization_name` (`string`, optional): Name of a Link customization from the Plaid Dashboard to apply. Defaults to the default customization. Example: default. - `optional_products` (`array`, optional): Products to add if supported, billed only when you first call them. Example: ["auth"]. - `products` (`array`, optional): Products the new Item must support; Link only shows institutions that support all of them, and they are billed once the Item is created. Common values: transactions, auth, identity, investments, liabilities, statements. Leave empty in update mode (when access_token is set). Example: ["transactions"]. - `redirect_uri` (`string`, optional): Where Link sends the user back after an OAuth bank login. Must be registered in the Plaid Dashboard under Allowed redirect URIs. Required for OAuth institutions when Link runs in a browser or iOS app. Example: https://example.com/plaid/oauth-return. - `required_if_supported_products` (`array`, optional): Products to add when the institution supports them; Link still shows institutions that do not. Example: ["identity"]. - `statements` (`object`, optional): Required when statements is one of the products: the date range of statements to fetch, as start_date and end_date (YYYY-MM-DD, up to two years). Example: {"start_date": "2025-01-01", "end_date": "2025-12-31"}. - `transactions_days_requested` (`integer`, optional): Days of transaction history (1 to 730) to request when transactions is one of the products. Plaid defaults to 90. Request at least 180 for recurring transactions. Sent as transactions.days_requested. Example: 365. - `update` (`object`, optional): Update mode options. Set account_selection_enabled to true to let the user add or remove accounts on the Item. Example: {"account_selection_enabled": true}. - `user_id` (`string`, optional): A user_id from plaid_user_create. Required for Plaid Check, Income, Multi-Item Link and Plaid Protect; leave empty for other products. Example: usr_8c3ZbDBYjaqUXZ. - `webhook` (`string`, optional): HTTPS URL that Plaid sends this Item's webhooks to. Example: https://example.com/plaid/webhook. Example input: `{"client_name":"","client_user_id":"","country_codes":["US"]}` ### `plaid_statements_refresh` Refresh Statements · Write Ask Plaid to fetch an Item's statements for a date range from the institution. Returns only request_id. Plaid fires a STATEMENTS_REFRESH_COMPLETE webhook when it finishes. Use plaid_statements_refresh to load statements Plaid does not hold yet, up to two years back, then list them with plaid_statements_list. The Item must have the statements product. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `access_token` (`string`, required): The Item's access_token, returned by plaid_item_public_token_exchange after the end user links an account with Plaid Link. It starts with access-production-. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. - `end_date` (`string`, required): End of the statement date range, YYYY-MM-DD, at most two years after start_date. Example: 2026-09-30. - `start_date` (`string`, required): Start of the statement date range, YYYY-MM-DD. Example: 2025-10-01. Example input: `{"access_token":"","end_date":"","start_date":""}` ### `plaid_transactions_refresh` Refresh Transactions · Write Ask Plaid to fetch an Item's newest transactions from the institution now, on top of its regular daily updates. Returns only request_id. If anything changed, Plaid fires a SYNC_UPDATES_AVAILABLE webhook (DEFAULT_UPDATE or TRANSACTIONS_REMOVED for transactions/get users). Use plaid_transactions_refresh when a user expects a very recent transaction, then read it with plaid_transactions_sync. It is a separately billed add-on that Plaid must enable, and the Item must have transactions. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `access_token` (`string`, required): The Item's access_token, returned by plaid_item_public_token_exchange after the end user links an account with Plaid Link. It starts with access-production-. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. Example input: `{"access_token":""}` ### `plaid_user_create` Create User · Write Create a Plaid user for one of your end users, which Plaid Check, Income, Multi-Item Link and Plaid Protect need before Link. Returns user_id (and user_token for integrations that started before December 10, 2025). Use plaid_user_create once per end user, then pass user_id to plaid_link_token_create. Auth, Balance, Identity, Transactions and Investments do not need it. Use plaid_user_remove to delete the user. Read only: no. Destructive: no. Idempotent (safe to retry): no. Inputs: - `client_user_id` (`string`, required): Your own stable, unique id for the end user, up to 128 characters. Do not use personal data such as an email address or phone number. Example: user-8231. - `end_customer` (`string`, optional): For Plaid Check resellers only: your end customer's id, up to 128 characters. Example: customer-42. - `identity` (`object`, optional): The user's identity: name (given_name, family_name), date_of_birth (YYYY-MM-DD), emails, phone_numbers (E.164), addresses and optional id_numbers. Plaid Check consumer reports need every field except id_numbers. Example: {"name": {"given_name": "Carmen", "family_name": "Berzatto"}, "date_of_birth": "1987-01-31", "emails": [{"data": "carmen@example.com", "primary": true}], "phone_numbers": [{"data": "+13125551212", "primary": true}], "addresses": [{"street_1": "3200 W Armitage Ave", "city": "Chicago", "region": "IL", "postal_code": "60657", "country": "US", "primary": true}]}. - `with_upgraded_user` (`boolean`, optional): Only for integrations that used /user/create before December 10, 2025: set to true to opt in to the new User APIs and get a user_id. Leave empty otherwise. Example input: `{"client_user_id":""}` ### `plaid_item_access_token_invalidate` Rotate Access Token · Destructive Rotate an Item's access_token: Plaid issues a new token and invalidates the old one immediately. Returns new_access_token. Use plaid_item_access_token_invalidate when a token may be exposed. Store new_access_token right away, because the old token stops working at once. Use plaid_item_remove to disconnect the Item entirely. Read only: no. Destructive: yes. Idempotent (safe to retry): no. Inputs: - `access_token` (`string`, required): The Item's access_token, returned by plaid_item_public_token_exchange after the end user links an account with Plaid Link. It starts with access-production-. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. Example input: `{"access_token":""}` ### `plaid_item_remove` Remove Item · Destructive Remove an Item and permanently invalidate its access_token and any processor tokens made from it. Returns only request_id. Use plaid_item_remove when a user disconnects a bank or is offboarded. It also ends subscription billing for Transactions, Liabilities and Investments on the Item. Use plaid_item_access_token_invalidate to rotate the token but keep the Item. Read only: no. Destructive: yes. Idempotent (safe to retry): yes. Inputs: - `access_token` (`string`, required): The Item's access_token, returned by plaid_item_public_token_exchange after the end user links an account with Plaid Link. It starts with access-production-. Example: access-production-de3ce8ef-33f8-452c-a685-8671031fc0f6. - `reason_code` (`string`, optional): Why the Item is being removed: FRAUD_FIRST_PARTY (the account owner committed fraud), FRAUD_FALSE_IDENTITY (the connection used a false or stolen identity), FRAUD_ABUSE, FRAUD_OTHER, CONNECTION_IS_NON_FUNCTIONAL or OTHER. Optional. Example: OTHER. One of: `FRAUD_FIRST_PARTY`, `FRAUD_FALSE_IDENTITY`, `FRAUD_ABUSE`, `FRAUD_OTHER`, `CONNECTION_IS_NON_FUNCTIONAL`, `OTHER`. - `reason_note` (`string`, optional): Free-text detail about the removal reason. Do not include personal data such as an email address or phone number. Example: User closed their account in our app. Example input: `{"access_token":""}` ### `plaid_user_remove` Remove User · Destructive Delete a Plaid user and every Item linked to it. Returns only request_id. Use plaid_user_remove to offboard a user made with plaid_user_create. Pass user_id, or user_token for older integrations. Use plaid_item_remove to remove a single Item. Read only: no. Destructive: yes. Idempotent (safe to retry): yes. Inputs: - `user_id` (`string`, optional): The user_id from plaid_user_create. Provide this or user_token. Example: usr_8c3ZbDBYjaqUXZ. - `user_token` (`string`, optional): The user_token from plaid_user_create, for integrations that started before December 10, 2025. Provide this or user_id. Example: user-production-b0e2c4ee-a763-4df5-bfe9-46a46bce993d. Example input: `{}` ## Related Other Accounting & Finance connectors ([all 45](/agentkit/connectors/?category=accounting-finance)): - [QuickBooks](/agentkit/connectors/quickbooks/): Scalekit connector, OAuth, 117 tools - [Xero](/agentkit/connectors/xero/): Scalekit connector, OAuth, 94 tools - [Stripe](/agentkit/connectors/stripe/): Scalekit connector, Access token, 178 tools --- ## More Scalekit documentation | Resource | What it contains | When to use it | |----------|-----------------|----------------| | [/llms.txt](/llms.txt) | Structured index with routing hints per product area | Start here — find which documentation set covers your topic before loading full content | | [/llms-full.txt](/llms-full.txt) | Complete documentation for all Scalekit products in one file | Use when you need exhaustive context across multiple products or when the topic spans several areas | | [sitemap-0.xml](https://docs.scalekit.com/sitemap-0.xml) | Full URL list of every documentation page | Use to discover specific page URLs you can fetch for targeted, page-level answers |