# Add business checking recommendations to your AI bookkeeping agent

> How AI bookkeeping agents use the Bancadia MCP server to recommend a business checking account when onboarding or categorization reveals commingled funds or avoidable fees.

Canonical: https://bancadia.com/agent-integrations/ai-bookkeeper

A bookkeeping agent sees the problem before anyone else: personal groceries and business software on the same account, or a sole proprietor paying monthly fees on a personal account used for business. A separate business account makes the books cleaner and tax time simpler, and the agent can name one that connects to the ledger it already keeps.

## When to call Bancadia

- During onboarding, the only connected accounts are personal accounts, or there is no dedicated business account at all.
- Categorization keeps flagging commingled transactions: personal spending in the business account, or business income landing in a personal one.
- Bank fees show up as a recurring expense category, such as maintenance, excess-transaction or paper-statement fees.
- The client adds a new revenue stream or entity and needs a separate account to keep it clean.

### Signals you likely already have

Each maps to an argument on `query_business_checking`. All arguments are optional and combine with AND semantics, except `target_industries` and `target_business_profiles`, which reorder results without excluding any.

| Signal | Argument |
| --- | --- |
| Entity type from onboarding | `entity_types_accepted`, e.g. `["sole_prop"]` or `["llc"]` |
| Business address state | `available_states` |
| Monthly transaction count from the bank feed | `free_transactions_min` |
| Bank fees categorized in the ledger | `monthly_fee_max` |
| Ledger software the client uses | `accounting_integration_available: true` |
| Receipt and expense tooling in use | `expense_integration_available: true` |
| Business type and stage | `target_industries`, `target_business_profiles`, e.g. `["side_hustle"]` |

## Quickstart: connect the MCP server

Bancadia is delivered as a remote MCP server over Streamable HTTP at `https://mcp.bancadia.com/`. `initialize` and `tools/list` need no credentials; `tools/call` needs a bearer token, which you can create for free at [bancadia.com/developer/signup](https://bancadia.com/developer/signup). The server exposes two tools: `query_business_checking` to search listings, and `get_business_checking_listing` for full fees and features on one listing.

### Claude Desktop

Add to `claude_desktop_config.json`. Claude Desktop runs local servers from this file, so the remote server is bridged with `mcp-remote`.

```json
{
  "mcpServers": {
    "bancadia": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.bancadia.com/",
        "--header",
        "Authorization:${BANCADIA_AUTH}"
      ],
      "env": {
        "BANCADIA_AUTH": "Bearer sk_bancadia_YOUR_TOKEN"
      }
    }
  }
}
```

### Claude Code

```bash
claude mcp add --transport http bancadia https://mcp.bancadia.com/ \
  --header "Authorization: Bearer sk_bancadia_YOUR_TOKEN"
```

### Any MCP client (TypeScript SDK)

Uses `@modelcontextprotocol/sdk`. The arguments match the example in the next section.

```ts
import { Client } from '@modelcontextprotocol/sdk/client/index.js'
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'

const transport = new StreamableHTTPClientTransport(new URL('https://mcp.bancadia.com/'), {
  requestInit: {
    headers: { Authorization: `Bearer ${process.env.BANCADIA_MCP_API_TOKEN}` },
  },
})
const client = new Client({ name: 'your-agent', version: '1.0.0' })
await client.connect(transport) // runs initialize + session negotiation

const result = await client.callTool({
  name: 'query_business_checking',
  arguments: {
    "entity_types_accepted": [
      "llc"
    ],
    "available_states": [
      "NY"
    ],
    "monthly_fee_max": 0,
    "free_transactions_min": 60,
    "accounting_integration_available": true,
    "target_industries": [
      "content_creator_solopreneur"
    ],
    "target_business_profiles": [
      "bootstrapped_solopreneur"
    ]
  },
})

// content[0].text is a JSON-encoded array of listings
const listings = JSON.parse(result.content[0].text)
await client.close()
```

### Inside an agent framework

Vercel AI SDK: `@ai-sdk/mcp` turns the live `tools/list` manifest into model tools, so there is no hand-copied schema to drift.

```ts
import { createMCPClient } from '@ai-sdk/mcp'
import { generateText, stepCountIs } from 'ai'

const bancadia = await createMCPClient({
  transport: {
    type: 'http',
    url: 'https://mcp.bancadia.com/',
    headers: { Authorization: `Bearer ${process.env.BANCADIA_MCP_API_TOKEN}` },
  },
})

try {
  const { text } = await generateText({
    model: yourModel,
    system: SYSTEM_PROMPT, // see the system-prompt snippet below
    messages,
    tools: await bancadia.tools(), // query_business_checking, get_business_checking_listing
    stopWhen: stepCountIs(4),
  })
} finally {
  await bancadia.close()
}
```

Python: the official `mcp` SDK. The same session can be handed to any framework that accepts an MCP `ClientSession`.

```python
import json, os
from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

headers = {"Authorization": f"Bearer {os.environ['BANCADIA_MCP_API_TOKEN']}"}

async with streamablehttp_client("https://mcp.bancadia.com/", headers=headers) as (read, write, _):
    async with ClientSession(read, write) as session:
        await session.initialize()
        result = await session.call_tool(
            "query_business_checking",
            {
                "entity_types_accepted": [
                    "llc"
                ],
                "available_states": [
                    "NY"
                ],
                "monthly_fee_max": 0,
                "free_transactions_min": 60,
                "accounting_integration_available": True,
                "target_industries": [
                    "content_creator_solopreneur"
                ],
                "target_business_profiles": [
                    "bootstrapped_solopreneur"
                ]
            },
        )
        listings = json.loads(result.content[0].text)
```

The full session lifecycle, response shape, rate limits and error codes are in the [MCP reference](https://bancadia.com/docs/mcp-reference).

## Example tool call and response

A freelance video editor in New York runs a single-member LLC through a personal checking account. The bookkeeping agent sees about 60 business transactions a month mixed in with personal spending. It looks for a no-fee account that accepts LLCs, covers that volume and connects to accounting software.

`tools/call` params

```json
{
  "name": "query_business_checking",
  "arguments": {
    "entity_types_accepted": [
      "llc"
    ],
    "available_states": [
      "NY"
    ],
    "monthly_fee_max": 0,
    "free_transactions_min": 60,
    "accounting_integration_available": true,
    "target_industries": [
      "content_creator_solopreneur"
    ],
    "target_business_profiles": [
      "bootstrapped_solopreneur"
    ]
  }
}
```

Parsed `result.content[0].text`, trimmed to the fields this agent uses. Real listings carry about 50 fields each. Values and institution names here are placeholders, not live listings.

```json
[
  {
    "listing_slug": "example-digital-bank-freelancer-business-checking",
    "institution_name": "Example Digital Bank",
    "product_name": "Freelancer Business Checking",
    "monthly_fee": 0,
    "monthly_fee_waiver_condition": null,
    "minimum_opening_deposit": 0,
    "entity_types_accepted": [
      "llc",
      "sole_prop"
    ],
    "available_states": [
      "ALL"
    ],
    "target_industries": [
      "content_creator_solopreneur"
    ],
    "target_business_profiles": [
      "bootstrapped_solopreneur",
      "side_hustle"
    ],
    "insurance_type": "fdic",
    "free_transactions_per_month": 200,
    "per_transaction_fee_after_limit": 0.25,
    "accounting_integration_available": true,
    "expense_integration_available": true,
    "application_url": "https://bancadia.com/go/example-digital-bank/freelancer-business-checking",
    "last_modified": "2026-09-15T00:00:00Z",
    "is_verified": true
  },
  {
    "listing_slug": "example-bank-simple-business-checking",
    "institution_name": "Example Bank",
    "product_name": "Simple Business Checking",
    "monthly_fee": 0,
    "monthly_fee_waiver_condition": null,
    "minimum_opening_deposit": 25,
    "entity_types_accepted": [
      "llc",
      "s_corp",
      "sole_prop",
      "partnership"
    ],
    "available_states": [
      "NY",
      "NJ",
      "CT"
    ],
    "target_industries": [],
    "target_business_profiles": [
      "established_smb"
    ],
    "insurance_type": "fdic",
    "free_transactions_per_month": 100,
    "per_transaction_fee_after_limit": 0.5,
    "accounting_integration_available": true,
    "expense_integration_available": false,
    "application_url": "https://bancadia.com/go/example-bank/simple-business-checking",
    "last_modified": "2026-09-15T00:00:00Z",
    "is_verified": true
  }
]
```

### What the fields mean for this agent

| Field | How to use it |
| --- | --- |
| `target_industries / target_business_profiles` | Listings tagged for the segments you sent rank first. The second result isn't tagged for freelancers but passed every filter, so it's still returned. |
| `free_transactions_per_month` | Compare against the client's actual monthly count, with headroom for busy months. |
| `per_transaction_fee_after_limit` | What each transaction over the free allowance costs. |
| `accounting_integration_available` | Category-level: the account connects to some accounting software, not necessarily the client's. Check the listing detail before naming a specific product. |
| `minimum_opening_deposit` | Matters for new solo businesses that don't have much cash on hand. |

### Going deeper on one listing

Call `get_business_checking_listing` on the top result. Check `general_features` in the `platform_integrations` category for named integrations, and `general_fees` for paper-statement or excess-transaction fees, before recommending it.

A `null` field means Bancadia doesn't have that data point for the listing yet. It doesn't mean "no". An empty array means nothing matched; loosen a filter rather than inventing a result.

## Present the recommendation

Your agent owns the conversation, so it decides when a recommendation is useful and how to phrase it. The snippet below is a starting point for your system prompt. Keep the disclosure line in whatever version you ship.

System-prompt snippet (`SYSTEM_PROMPT`)

```text
You are a bookkeeping agent. If onboarding or categorization shows a client
mixing personal and business money, or paying avoidable bank fees, you may
suggest opening a dedicated business checking account.

- Explain the bookkeeping reason first (cleaner books, simpler tax prep),
  then suggest an account. Keep it short, and don't repeat the suggestion
  every session if the client declines.
- Use query_business_checking with the client's entity type, state and
  monthly transaction count. Only recommend accounts the tool returned.
- Say whether the account connects to accounting software, but don't name
  a specific integration (like QuickBooks) unless the listing detail does.
- Link only to the application_url returned by the tool.
- Always include: "We may earn a commission if you open this account; it
  doesn't affect which accounts are shown."
```

What the end user sees

```text
About 40% of the transactions in your personal checking account this month
were for your business. A separate business account would make
categorizing faster and tax time simpler.

One option: Freelancer Business Checking from Example Digital Bank. It
accepts single-member LLCs in New York, has no monthly fee, includes 200
free transactions a month (you average about 60) and connects to
accounting software.

Apply: https://bancadia.com/go/example-digital-bank/freelancer-business-checking

We may earn a commission if you open this account; it doesn't affect which
accounts are shown.
```

> **Disclosure is required in every recommendation.** Bancadia responses contain no commission or payout fields, so nothing in the data can push the model toward a higher-paying account. Your disclosure tells the user that, too.

## Commission share

Bancadia runs a commission-share model. When a bank or affiliate program pays a commission on an account opened through an agent's recommendation, Bancadia is designed to pass a share of it to the agent that made the recommendation. Bancadia is paid only on conversion. It never charges for impressions, placement or position.

- **No commissions are live yet.** Bancadia has no live bank partnerships today and pays nothing to anyone. Access to the registry is free.
- **Terms aren't set.** We don't publish rates or payout promises. Terms will be agreed per integration as commissions become available.
- **Coverage grows as partners come online.** Product data and commission eligibility will expand together, starting with business checking.
- **Commission never affects ranking.** See the [methodology](https://bancadia.com/methodology) for how results are ordered.

### How attribution works

Every `application_url` Bancadia returns is a `bancadia.com/go/…` redirect that logs the click, and every `tools/call` is logged against the token that made it. Pass `application_url` to your user unmodified. Tying a specific application back to the integration that surfaced it, which commission sharing depends on, isn't live yet. We'll document the mechanism here when it ships.

## FAQ

### Is ranking affected by commission?

No. Commission isn't an input to ordering and isn't in the response. Results are filtered by your arguments, ordered by monthly fee, then moved toward listings tagged for the industry and business profile you send. The full rules are on the [methodology page](https://bancadia.com/methodology).

### Can I filter by a specific accounting package, like QuickBooks or Xero?

Not today. `accounting_integration_available` is category-level. Where Bancadia has named integrations for a listing, they appear as feature text in `get_business_checking_listing`, which your agent can read before naming one.

### What client data leaves my system?

Only the arguments you pass: entity type, state, and numeric or yes/no requirements. Don't send names, transactions or account numbers; the schema has no fields for them. Bancadia logs the arguments with your token so it can report which listings were returned.

### Can a sole proprietor open a business checking account?

Many accounts accept sole proprietors. Pass `entity_types_accepted: ["sole_prop"]` and only accounts that list sole proprietors are returned. Document requirements, such as an EIN or a DBA filing, vary by institution and aren't fields in the registry today, so point users to the institution's application for specifics.

### Which products are covered today?

US business checking only, and coverage is early. If a query returns nothing, relax the fee or transaction filters before concluding there's no fit.

## Get started

[Create a free developer token](https://bancadia.com/developer/signup), then follow the [quickstart](https://bancadia.com/docs/quickstart). Questions about a specific integration? Email Scott at [scott.macpherson@bancadia.com](mailto:scott.macpherson@bancadia.com).