DEV Community: eliaskress

How to give Claude real-time access to your business finances with MCP

eliaskress — Fri, 06 Mar 2026 22:59:28 +0000

What is MCP?

MCP (Model Context Protocol) is an open standard that lets AI assistants call external tools. Instead of pasting data into a prompt, you give the model direct access to an API. It decides when to call which tool based on your question. FlowCheck ships an MCP server that exposes your financial data as tools Claude can call in real time.

What you need

A FlowCheck API key (get one here, free trial included)
At least one data source connected (Stripe, Shopify, or a bank account)
Claude Code (CLI) or Claude Desktop, depending on which setup you prefer

Option 1: Claude Code (stdio transport)

This is the fastest setup. One command adds FlowCheck as an MCP server that runs locally via stdio:

claude mcp add flowcheck \
  --transport stdio \
  --env FLOWCHECK_API_KEY=fc_live_your_key \
  -- npx -y @flowcheck/mcp-server

That is it. Claude Code now has access to your FlowCheck data. Start a conversation and ask a question:

> How much revenue did we make this month?

Claude will call the FlowCheck cashflow tool and respond:

"Based on your FlowCheck data, your total inflow for March 2026
is $12,847.00 across 23 Stripe payouts and 8 Shopify payouts.
After $4,230.00 in outflows, your net cash flow is $8,617.00."

Option 2: Claude Desktop (JSON config)

If you use Claude Desktop, add the server to your MCP configuration file. On macOS this is ~/Library/Application Support/Claude/claude_desktop_config.json. On Windows, it is in %APPDATA%\Claude\claude_desktop_config.json:

{
  "mcpServers": {
    "flowcheck": {
      "command": "npx",
      "args": ["-y", "@flowcheck/mcp-server"],
      "env": {
        "FLOWCHECK_API_KEY": "fc_live_your_key"
      }
    }
  }
}

Restart Claude Desktop. You will see FlowCheck listed in the MCP tools panel.

Option 3: Remote MCP endpoint

For clients that support remote MCP servers (Glama, Smithery, custom agents), point to the hosted endpoint:

https://developer.usepopup.com/api/mcp

Pass your API key as a Bearer token. The remote server exposes the same tools as the stdio version but runs on FlowCheck infrastructure instead of your local machine.

Available tools

The MCP server exposes these tools to the AI model. Claude picks the right one based on your question:

Tool	What it does
`get_balance`	Stripe available/pending + bank balances
`get_cashflow`	Daily inflow/outflow over 7, 30, or 90 days
`list_payouts`	Stripe + Shopify payouts with reconciliation status
`get_reconciliation`	30-day match rate and discrepancy count
`list_discrepancies`	Missing deposits, amount mismatches, timing alerts
`get_position`	7-day financial summary (balances + recent payouts + cash flow)
`get_alerts`	Active issues in agent-friendly format

Example prompts

Once connected, you can ask Claude natural questions about your finances. Here are some that work well:

"What is our current cash position?"
Claude calls get_balance and returns Stripe available, Stripe pending, and bank balance with a total.
"Are there any unmatched payouts this month?"
Claude calls get_reconciliation and lists any payouts that have not been matched to a bank deposit, with amounts and dates.
"Compare last week's revenue to the week before."
Claude calls get_cashflow with a 30-day window and computes the week-over-week change from the daily breakdown.
"Summarize our financial health for the board meeting."
Claude calls get_position and formats the response as a brief executive summary with revenue, expenses, net, and any open issues.

Sandbox mode

If you want to test without touching production data, use a sandbox key (prefixed fc_test_). Sandbox calls return realistic test data and do not consume credits. This is useful for building agents or testing prompts before going live.

claude mcp add flowcheck-sandbox \
  --transport stdio \
  --env FLOWCHECK_API_KEY=fc_test_your_key \
  -- npx -y @flowcheck/mcp-server

Get started

Get an API key, connect at least one data source from the dashboard, and run the claude mcp add command above. The whole setup takes under five minutes. Once connected, ask Claude anything about your business finances and it will pull the answer from your live data.

Building a financial dashboard with Stripe, Shopify, and Plaid without writing a reconciliation engine

eliaskress — Fri, 06 Mar 2026 22:54:18 +0000

Your data lives in three places

If you run a business that sells through Shopify and processes payments with Stripe, your financial data is split across three systems. Stripe knows your payment volume and fees. Shopify knows your orders, refunds, and its own payouts. Your bank knows what actually landed in your account and what you spent.

Building a dashboard that combines all three means writing OAuth flows, managing API keys, syncing data on a schedule, normalizing amounts (Stripe uses cents, Plaid uses dollars with negative signs for deposits), and building matching logic to figure out which bank deposit corresponds to which payout. That is months of work before you display a single number.

FlowCheck handles all of that. You connect your accounts, and every endpoint returns unified data. Here is how to set it up from scratch.

Step 1: Get an API key

curl -X POST https://developer.usepopup.com/api/v0/auth/register \
  -H "Content-Type: application/json" \
  -d '{"email": "you@example.com"}'

Complete the checkout flow, then check your registration status to get your API key:

curl https://developer.usepopup.com/api/v0/auth/register/status?token=YOUR_TOKEN

Save the key. It starts with fc_live_ for production or fc_test_ for sandbox. You will not see it again.

Step 2: Connect Stripe

Create a restricted key in your Stripe dashboard with read access to Payouts and Balance. Then pass it to FlowCheck:

curl -X POST https://developer.usepopup.com/api/v0/connect/stripe \
  -H "Authorization: Bearer fc_live_your_key" \
  -H "Content-Type: application/json" \
  -d '{"restricted_key": "rk_live_your_stripe_key"}'

Or with the SDK:

import { FlowCheck } from "@flowcheck/sdk"

const fc = new FlowCheck("fc_live_your_key")
await fc.connectStripe({ restrictedKey: "rk_live_your_stripe_key" })

FlowCheck encrypts your Stripe key with AES-256-GCM before storing it. Once connected, payout data syncs automatically.

Step 3: Connect Shopify

Create a custom app in your Shopify admin with read access to Orders and Payouts. Pass the shop domain and access token:

await fc.connectShopify({
  shop: "my-store.myshopify.com",
  accessToken: "shpat_your_token"
})

Shopify orders and payouts now show up alongside Stripe data in every FlowCheck endpoint.

Step 4: Connect your bank account

Bank connections use Plaid Link, a two-step flow. First, get a Link token from FlowCheck:

const { data } = await fc.createPlaidLinkToken()
// data.link_token = "link-sandbox-abc123..."

// Use the Plaid Link SDK in your frontend to open the bank selector
// When the user finishes, Plaid gives you a public_token

await fc.exchangePlaidToken({ publicToken: "public-sandbox-xyz..." })

After the exchange, bank transactions sync automatically. Deposits show as negative amounts in Plaid (yes, really), and FlowCheck normalizes everything so you do not have to think about it.

Step 5: Query everything from one endpoint

With all three sources connected, a single call gives you your complete financial picture:

const cashflow = await fc.cashflow("30d")

console.log(`Total inflow: $${cashflow.data.total_inflow / 100}`)
console.log(`Total outflow: $${cashflow.data.total_outflow / 100}`)
console.log(`Net: $${cashflow.data.net / 100}`)

// Daily breakdown
for (const day of cashflow.data.daily) {
  console.log(`${day.date}: +$${day.inflow / 100} / -$${day.outflow / 100}`)
}

The balance endpoint gives you a snapshot across all connected accounts:

curl https://developer.usepopup.com/api/v0/balance \
  -H "Authorization: Bearer fc_live_your_key"

{
  "data": {
    "stripe": { "available": 234100, "pending": 89200 },
    "bank": { "current": 1247800, "available": 1245300 },
    "total_available": 1479400
  }
}

Step 6: Set up webhooks for real-time updates

Instead of polling the API, register a webhook to get notified when payouts match, when discrepancies are detected, or when a refund affects your reconciliation:

await fc.createWebhook({
  url: "https://your-app.com/webhooks/flowcheck",
  events: [
    "payout.matched",
    "payout.discrepancy",
    "payout.missing",
    "refund.detected",
    "balance.threshold"
  ]
})

Every webhook delivery is signed with HMAC-SHA256. Verify the FlowCheck-Signature header before processing.

What you did not have to build

At this point you have a working financial data layer. Here is what FlowCheck handled so you did not have to:

Stripe payout sync with automatic backfill and ongoing polling
Shopify order and payout sync with the same pattern
Plaid bank transaction sync with soft-delete for removed transactions
Amount normalization across cents (Stripe), dollars-negative-for-income (Plaid), and Shopify order amounts
Reconciliation matching using a 100-point scoring model across amount, date, description, and bank account
Discrepancy detection for missing deposits, amount mismatches, and timing anomalies
Webhook infrastructure with HMAC signing, retry logic, and automatic endpoint disabling after repeated failures

All of that is code you would have written yourself, debugged across edge cases, and maintained as APIs change. Instead, you made six API calls and you are done.

Get started

Get an API key and connect your first data source. The sandbox is free and comes with test data so you can see real responses without connecting production accounts. The full API reference has examples for every endpoint.

How I stopped reconciling Stripe payouts in spreadsheets

eliaskress — Fri, 06 Mar 2026 22:54:16 +0000

The problem

Every two days, Stripe sends a payout to your bank account. The amount is some combination of charges, refunds, fees, and adjustments, bundled together in ways that rarely match what you expected. The number that shows up in your bank account is almost never a number you can find anywhere in Stripe.

If you have a handful of transactions per week, you can probably eyeball it. But once you are processing 50+ charges a day across multiple products, the payout amounts start looking random. $4,271.88 lands in your bank account. Where did that number come from?

What I tried first: CSVs and VLOOKUP

The obvious approach. Export payouts from Stripe, export transactions from your bank, paste both into a spreadsheet, VLOOKUP on the amount. It works for about a week.

Then you hit the edge cases:

Stripe batches multiple charges into a single payout, so the bank deposit amount does not match any individual charge.
Stripe deducts fees before sending the payout. A $100 charge becomes a $97.10 deposit (minus the 2.9% + $0.30 fee).
Refunds issued between payout cycles get netted against future payouts, so a $500 payout might actually represent $600 in charges minus a $100 refund from last week.
Timing is unpredictable. Stripe says "2 business days," but weekends, holidays, and bank processing delays mean a payout initiated on Friday might not arrive until Wednesday.

VLOOKUP needs an exact match on at least one column. When the amount does not match and the date does not match, you are left manually scanning rows. At 50 payouts a month, this takes a full afternoon. At 200, it is a part-time job.

The matching problem

Reconciliation is fundamentally a matching problem. You have a payout record from Stripe (amount, date, destination bank) and you need to find the corresponding deposit in your bank transactions. The difficulty is that almost nothing lines up exactly.

Consider a real example:

Stripe payout: $4,271.88, initiated Feb 25, bank account ending in 4829
Bank deposit: $4,271.88, posted Feb 27, description "STRIPE TRANSFER"

This one is easy. The amounts match exactly and the description contains "STRIPE." Now consider:

Stripe payout: $2,847.33, initiated Mar 1, bank account ending in 4829
Bank deposit: $2,847.33, posted Mar 4, description "ACH CREDIT STRIPE PAYOUT"
Another bank deposit: $2,847.33, posted Mar 4, description "ACH CREDIT SHOPIFY"

Same amount, same date, two candidates. Which one is the Stripe payout? You need more signals: the bank account ID, description keywords, date proximity. This is where spreadsheets fall apart and scoring algorithms start making sense.

What FlowCheck does

FlowCheck connects to both Stripe and your bank (via Plaid), then runs a scoring model against every payout to find its matching bank deposit. The model uses four signals:

Amount match (40 points): exact match gets full score, with tolerance for rounding within $0.01 plus 1% variance
Date proximity (30 points): full score if the deposit arrives within the expected window (arrival date minus 2 days to plus 7 days), decaying as the gap grows
Description match (20 points): looks for "STRIPE," "TRANSFER," payout ID fragments, or bank-specific identifiers in the transaction description
Bank account match (10 points): confirms the deposit landed in the same bank account the payout was sent to

A score of 80+ with a 10-point gap to the second-best candidate triggers an automatic match. Everything else gets flagged for review.

You can see your overall reconciliation health with a single API call:

curl https://developer.usepopup.com/api/v0/reconcile/summary \
  -H "Authorization: Bearer fc_live_your_key"

{
  "data": {
    "window_days": 30,
    "total_payouts": 47,
    "matched": 44,
    "unmatched": 2,
    "pending": 1,
    "match_rate": 93.6,
    "total_expected": 2847133,
    "total_confirmed": 2654200,
    "discrepancies": 2
  }
}

The same call with the TypeScript SDK:

import { FlowCheck } from "@flowcheck/sdk"

const fc = new FlowCheck("fc_live_your_key")
const { data } = await fc.reconciliationSummary()

console.log(`Match rate: ${data.match_rate}%`)
console.log(`Unmatched: ${data.unmatched}`)
console.log(`Discrepancies: ${data.discrepancies}`)

Digging into individual payouts

When you need to see why a specific payout did or did not match, query the payout directly:

const payouts = await fc.payouts({ source: "stripe" })

for (const payout of payouts.data) {
  if (payout.reconciliation_status === "unmatched") {
    console.log(`Missing: ${payout.id} - $${payout.amount / 100}`)
  }
}

Webhooks for ongoing monitoring

Instead of polling, you can register a webhook to get notified when payouts match or when something looks wrong:

curl -X POST https://developer.usepopup.com/api/v0/webhooks \
  -H "Authorization: Bearer fc_live_your_key" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://your-app.com/webhooks/flowcheck",
    "events": ["payout.matched", "payout.discrepancy", "payout.missing"]
  }'

FlowCheck signs every webhook delivery with HMAC-SHA256, so you can verify it actually came from FlowCheck and not someone replaying requests.

The result

What used to take a full afternoon now happens automatically. The API checks every Stripe payout against your bank deposits, flags anything it cannot match, and sends a webhook when something needs attention. No more CSV exports. No more VLOOKUP. No more staring at two spreadsheets wondering where $47.33 went.

If you are tired of reconciling Stripe payouts by hand, grab an API key and try it. The sandbox is free and does not touch your production data.