Why does the modified set matter so much for bookkeeping?

Because pending transactions change. A card authorisation settles at a different amount, a descriptor gets corrected, and occasionally a bank withdraws a line entirely. A feed that only tells you about new rows leaves your users reconciling by hand or, worse, double-posting. This sync returns added, modified and removed explicitly, and each maps cleanly to create, amend and void in a ledger that has to keep an audit trail.

Can I code transactions from a client's CSV export?

Yes, two ways. Manual CSV, OFX and QFX import is a first-class connector that runs for real in live mode with no provider agreement, so the file becomes a normal connection with normal sync behaviour. Alternatively, categorize and merchant resolution accept a raw payload directly, so you can code lines that live entirely in your own database.

How do I map categories to a chart of accounts?

The taxonomy is static reference data served by /v1/categories/get, with primary categories and detailed subcategories. Fetch it once, store your mapping against it, and treat the AI category as a suggestion your user can override. The response also carries a clean merchant name, which is usually a better key for a rules engine than the raw bank descriptor.

How do I know when there is something to reconcile?

Webhooks. transactions.sync_updates_available fires when a sync would return something, so you are not polling every account on a timer. Deliveries are HMAC-signed with a timestamp, retried 5 times (immediately, then 1m, 5m, 30m, 2h), and every attempt is recorded so you can see what we sent and what your endpoint said.

What happens when a connection breaks?

An item can enter an error state — a changed password, a revoked consent, an expired provider token — and you receive an item.error webhook. Re-authentication reopens Link in update mode against the existing item, and the access token you already stored keeps working, so there is no re-linking and no orphaned ledger. Exchanging a token in update mode is optional and rotates it, with rotated: true in the response so every stored copy gets replaced.

Does this cover business accounts, not just personal ones?

The catalogue includes commerce, payroll and accounting platforms alongside banks and credit unions — anything that holds a balance or a transaction ledger. As with every institution, whether a specific one is connectable in live mode depends on which provider credentials are configured for it.

Accounting

A feed that admits when something changed.

Bookkeeping software fails on corrections, not on new rows. This sync returns added, modified and removed as separate sets with a cursor, so create, amend and void each have an unambiguous trigger — and the enrichment that codes the line comes on the same key.

Create a sandbox key Read the docs

who this is for

Reconciliation is where bank feeds break.

Bookkeeping tools that need clean ledgers, not raw descriptors

Every accounting product hits the same wall. The feed delivers a pending card authorisation; three days later it settles two dollars higher. If the API only ever hands you new rows, you have a duplicate, a manual fix, and a user who no longer trusts the feed.

The other wall is coding. Raw bank descriptors are hostile — prefixes, store numbers, processor noise — and a bookkeeper who has to rename every line is not saving any time. What you want is a clean merchant name and a category suggestion good enough to accept by default.

Both are in the same integration here, on the same key, with the enrichment metered separately so it does not eat your sync budget.

what you'd call

The endpoints this actually uses.

Two loops: a sync that keeps the ledger true, and enrichment that codes what the sync brought in.

Endpoints used by accounting and bookkeeping integrations
POST	/v1/transactions/sync	added, modified and removed with a cursor
POST	/v1/transactions/get	Date-range backfill when onboarding a client
POST	/v1/accounts/get	Accounts, types, masks and balances to map to ledgers
POST	/v1/accounts/balance/get	Closing balance to reconcile a period against
POST	/v1/categories/get	The taxonomy to map to a chart of accounts once
POST	/v1/ai/categorize	Bulk coding, on a connection or a raw payload
POST	/v1/ai/merchant	Descriptor → merchant profile, for rules engines
POST	/v1/items/refresh	Force a pull before closing a period
POST	/v1/items/get	Connection health, so a stale feed is visible

in code

What the integration looks like.

The reconciliation loop written the way a ledger needs it, then the coding pass that turns a descriptor into an entry.

tsreconcile.ts

import { FeelConnect } from "@feelconnect/node"; const fc = new FeelConnect({  apiKey: process.env.FEELCONNECT_SECRET_KEY!,  baseUrl: "https://connect.feels.money/v1",}); // A ledger cannot tolerate "we think this changed". The sync returns// three explicit sets, so each one maps to a different ledger action.export async function reconcile(itemId: string, accessToken: string) {  let cursor = await loadCursor(itemId);   for (;;) {    const page = await fc.transactions.sync({      access_token: accessToken,      cursor,      count: 500,    });     // New bank lines → draft entries awaiting a match.    for (const txn of page.added) await createDraftEntry(txn);     // A pending charge settled at a different amount, or the bank    // corrected a descriptor. Update in place; never double-post.    for (const txn of page.modified) await amendEntry(txn.transaction_id, txn);     // The bank withdrew the line. Void rather than delete, so the    // audit trail survives the correction.    for (const gone of page.removed) await voidEntry(gone.transaction_id);     cursor = page.next_cursor;    await saveCursor(itemId, cursor); // persist AFTER applying the page    if (!page.has_more) break;  }}

tscoding.ts

// Coding a line: resolve the descriptor, then categorize in bulk.const { merchant } = await fc.ai.merchant({  query: "SQ *BLUE BOTTLE COFFEE OAK",}); // Bulk coding accepts a raw payload — no connection required, so this// also works on transactions imported from a client's CSV export.const { categorized, engine } = await fc.ai.categorize({  transactions: uncoded.map((line) => ({    id: line.id,    description: line.description,    amount: line.amount,  })),}); // The taxonomy is static reference data, so your chart-of-accounts// mapping can be built once and stored rather than discovered per call.const { categories } = await fc.categories.get(); console.log(merchant, engine, categorized.length, categories.length);

what you get

Mechanisms, in the order you would meet them.

Three sets, three ledger actions
added creates, modified amends, removed voids. No diffing, no guessing, no double-posting when a pending charge settles.
Cursors that survive a crash
Persist next_cursor after applying a page and an interrupted run replays that page rather than skipping it — the failure mode a ledger can actually tolerate.
Merchant resolution as a first-class endpoint
A descriptor goes in, a merchant profile comes out — a far better key for your rules engine than the raw bank string.
A taxonomy you map once
Primary categories with detailed subcategories, served as static reference data, so your chart-of-accounts mapping is stored rather than rediscovered on every call.
Push instead of polling
transactions.sync_updates_available, item.error and transactions.initial_update — signed, timestamped, retried, and recorded per delivery.
Client files as connections
CSV, OFX and QFX import runs for real with no provider agreement, so an unsupported institution becomes an upload rather than a lost client.

questions

Straight answers.

Other use cases

Ship a feed your users stop checking.

Run the reconciliation loop against the sandbox, force a modification, and watch it land as an amendment instead of a duplicate. That takes about ten minutes and no agreement with anyone.

Create a sandbox key Contact sales

The sandbox needs no approval and no card. You can have the shapes in front of you in a few minutes and decide from there.