Synci
Server Details
Read-only access to your bank, investment, and crypto accounts: balances, transactions, holdings.
- Status
- Healthy
- Uptime
- 65.6% over 48 days
- OAuth
- Works in Glama
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
TDQS
Scored across 5 tools
Each tool targets a distinct resource: accounts, connections, holdings, transactions, and balance snapshots. The overlap between list_accounts (which includes a balance block) and get_account_balance is manageable because the former returns a summary while the latter returns detailed snapshots, so an agent can clearly choose based on need.
Tool names follow a consistent list_* pattern for collections (list_accounts, list_connections, list_holdings, list_transactions) with a single get_account_balance for a specific resource. The get/list split aligns with singular vs. plural resources, making the pattern predictable and clean.
Five tools is well-scoped for a read-only financial data server. Every tool covers a core data category without redundancy or bloat, and none feel like filler.
For a read-only financial aggregation domain, the surface is complete: accounts, their balances, transactions, holdings, and connection health are all covered. The verbose options and clear date/cursor handling avoid dead ends, and there is no implied requirement for write operations.
Available Tools
5 toolsget_account_balanceGet account balanceARead-onlyIdempotentInspect
Get balance snapshots for one account (e.g. INTERIM_AVAILABLE, EXPECTED, CLOSING_BOOKED). as_of is when balances last synced — they can lag transactions, so caveat stale figures. For a credit account a negative CLOSING_BOOKED is the amount owed (not overdrawn). Investment/crypto accounts usually have no balance snapshots: read total_balance for the broker-reported portfolio value and cash_balance for uninvested cash, and call list_holdings for the positions behind them.
| Name | Required | Description | Default |
|---|---|---|---|
| account_id | Yes | The id of the financial account to fetch balances for, as returned by list_accounts. |
Output Schema
| Name | Required | Description |
|---|---|---|
| note | No | Present when the account has no snapshots; points at list_holdings for investment/crypto value. |
| as_of | No | When balances last synced (ISO 8601); balances can lag transactions. |
| balances | Yes | Newest first, at most 20 snapshots. Empty for accounts without balance snapshots. |
| account_id | Yes | |
| cash_balance | No | |
| total_balance | No | Broker-reported total account value (positions plus cash); investment accounts only. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the call as read-only, idempotent, and non-destructive. The description adds valuable behavioral detail beyond that: balance snapshots may lag transactions, negative CLOSING_BOOKED on credit accounts means amount owed, and investment/crypto accounts typically lack snapshots. This is exactly the kind of context annotations cannot express.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three dense sentences, front-loaded with the core action, followed by caveats and alternatives. No filler or repetition of schema content.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The output schema exists, so return-value documentation is not the description's job. It covers staleness, credit semantics, and the investment/crypto exception, making it complete for a one-parameter read-only tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema fully documents account_id at 100% coverage, so the baseline is 3. The description adds meaning by clarifying that exactly one account is targeted and by describing account-type-dependent balance semantics, which goes beyond the schema's 'id of the financial account' definition.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: 'Get balance snapshots for one account', and lists concrete snapshot types. It also distinguishes itself from sibling tools by explicitly steering investment/crypto account cases to list_holdings and balance fields.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides clear context for when the tool is appropriate versus alternatives, especially for investment/crypto accounts where snapshots usually don't exist. The credit-account interpretation guidance and stale-data caveat further tell the agent how to use the result correctly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_accountsList accountsARead-onlyIdempotentInspect
List the user's connected financial accounts (bank, investment, crypto). Each is a lean summary: name, institution, category, currency, a balance block, account health, and earliest_available_date. IMPORTANT: balances can lag transactions — check balance.as_of (the last time balances synced) and caveat stale figures. IMPORTANT: earliest_available_date is the start of the account's synced history — a query for a period before it returns nothing because the data was never synced, NOT because there was no activity, so never report a total for a window that starts before it without caveating the coverage. Investment/crypto accounts have an empty balance block: read total_balance for the broker-reported portfolio value and cash_balance for uninvested cash, and call list_holdings for the positions behind them. verbose:true returns the full record. Sensitive identifiers are omitted.
| Name | Required | Description | Default |
|---|---|---|---|
| verbose | No | When true, return the full account record instead of the lean summary. | |
| account_category | No | Optional. Restrict results to a single account category. |
Output Schema
| Name | Required | Description |
|---|---|---|
| accounts | Yes | Lean account summaries; with verbose:true each item is the full account record instead. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds substantial behavioral context beyond annotations: balances can lag transactions and should be caveated, earliest_available_date defines synced history coverage, investment/crypto accounts have empty balance blocks requiring different field interpretation, and sensitive identifiers are omitted. This is rich, non-obvious behavior that an agent needs to know.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is dense but well-organized: it front-loads the core purpose, then provides structured caveats with clear markers (IMPORTANT). Every sentence adds information, though the length is substantial. The structure is logical: purpose, output shape, caveats, special-case behavior, parameter note, and security note.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (special balance semantics, date coverage caveats, category-specific behavior) and the presence of an output schema, the description is remarkably complete. It covers return value interpretation, edge cases (investment/crypto empty balance blocks), data freshness caveats, and routing to sibling tools. An agent has everything needed to call this correctly and interpret results.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents both parameters (verbose and account_category). The description adds value by explaining the default lean summary and the verbose:true behavior ('returns the full record'), which clarifies the parameter's effect beyond the schema's phrasing. It doesn't add detail on account_category beyond the schema's enum, but the schema already covers that.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('List') and resource ('the user's connected financial accounts'), enumerates the account types (bank, investment, crypto), and distinguishes the output as a lean summary. It clearly differentiates from siblings like list_holdings and get_account_balance by describing the account-level summary scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly tells the agent when to use this tool (to list connected accounts and get lean summaries) and when to use alternatives: 'call list_holdings for the positions behind them' for investment/crypto accounts. It also provides critical usage caveats about balance lag and earliest_available_date, which guide correct interpretation of results.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_connectionsList connectionsARead-onlyIdempotentInspect
List the authenticated user's bank/provider connections and their health status (HEALTHY, FAILING, DEAD), including the institution and consent expiry.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| connections | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description adds valuable detail about the response contents (health status, institution, consent expiry), which goes beyond the annotations. This is useful context for agents deciding whether to call it.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, front-loaded sentence that conveys the entire purpose and key output fields without any filler. Every element earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a parameterless read-only tool with an output schema (though not shown) and rich annotations, the description fully covers what the agent needs to know: what is listed and the specific fields returned. No significant gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters and schema coverage is trivially 100%, so the baseline is 4. The description does not need to add parameter details; it correctly focuses on output semantics.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('List') and resource ('bank/provider connections') and adds distinct details (health status, institution, consent expiry) that clearly differentiate it from sibling tools like list_accounts or list_transactions. It is unambiguous about scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly defines what it returns, making it obvious when to use it for connection health monitoring. It does not explicitly state when not to use it, but sibling tool names provide enough context to infer the distinction. A clear exclusion would earn a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_holdingsList holdingsARead-onlyIdempotentInspect
List the investment and crypto positions held in the user's brokerage and crypto-exchange accounts: symbol, asset class, quantity, latest price, market value and currency. Bank accounts have no holdings. Optionally restrict to one account.
| Name | Required | Description | Default |
|---|---|---|---|
| account_id | No | Optional. Restrict to a single account (id from list_accounts). Omit to span all of the user's investment/crypto accounts. |
Output Schema
| Name | Required | Description |
|---|---|---|
| holdings | Yes | Current position snapshot per holding; empty when the user has no investment/crypto positions. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already cover read-only/idempotent behaviorags. The description adds meaningful scope details: it covers brokerage and crypto-exchange accounts, excludes bank accounts, and enumerates returned fields, which clarifies what the call does beyond the schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences convey scope, exclusions, and optional filtering. Every clause earns its place and the most important verb-resource pairing is front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With a 100%-covered optional parameter sna an output schema plus annotations, the description provides enough scope detail (investment/crypto accounts, no bank holdings) for safe selection and invocation. Slightly more on when to prefer siblings would close the gap, but nothing essential is missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The only parameter, account_id, has a complete schema description, and schema coverage is 100%. The description merely restates 'Optionally restrict to one account', adding little beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Description opens with a specific verb ('List') and a precise resource: positions held in brokerage and crypto-exchange accounts, not just generic 'holdings'. It lists the returned fields and explicitly notes 'Bank accounts have no holdings', which helps distinguish it from siblings like list_accounts and get_account_balance.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description tells the agent when this tool applies (investment/crypto positions) and rules out bank accounts alerting, and the schema points to account_id from list_accounts. It does not explicitly name alternatives or exclusions, but the context is clear enough to select this over list_accounts or get_account_balance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_transactionsList transactionsARead-onlyIdempotentInspect
List the user's financial transactions in a date window, newest first, across all account types (bank, deposit, line of credit, investment). Each row is lean by default: id, date, amount (negative = money out), currency, booked, payee, description (omitted when it duplicates payee), an account {id, name, institution} ref, and — when available — mcc, category, and bank_details (raw provider metadata: transaction/purpose codes, currency-exchange info, and the MCC category text that banks put in additional_information — useful for categorising spend when enrichment is off). Pass "verbose": true for the full, raw transaction record.
Investment rows also carry: type (raw activity, e.g. BUY / SELL / DIVIDEND / CRYPTO_SEND), is_cash_flow, units, and price_per_unit (the effective per-unit price in this row's currency, = |amount| / units). IMPORTANT for "what did I spend": rows with is_cash_flow=false are asset transfers or income-in-kind (crypto send/receive, staking, stock splits) — NOT money spent; exclude them from spending totals. Use amount, units and price_per_unit for trade figures; ignore any price written into the description string (it is the provider's own and can be in a different currency).
Dates: "date" is Synci's per-account authoritative date by default (what the user sees; "spending in June" means this). Override with date_field "booking" or "value" to filter/sort/show a specific date instead. Both booked and pending transactions are returned by default; filter with status ("all" | "booked" | "pending", default "all"). Pending amounts can still change.
Coverage: meta.earliest_available_date is the date the queried accounts are synced from. If it is later than your "from", the window is only PARTIALLY covered — data before it was never synced (not absent), so any total would silently under-report. Caveat the coverage, or narrow "from" to it.
Pagination: results are bounded by the date window and "limit" (default 50, max 100). Check meta.has_more: if true, request the next page by passing meta.next_cursor as "cursor" (keyset paging, no gaps or overlap). A page may hold fewer rows than "limit" (the user can exclude transactions from outbound channels), so never read a short page as the end of the data; only has_more=false is. Sensitive identifiers (IBAN, account numbers, etc.) are always omitted.
| Name | Required | Description | Default |
|---|---|---|---|
| to | No | Optional end date (YYYY-MM-DD), inclusive. Defaults to today. | |
| from | No | Optional start date (YYYY-MM-DD), inclusive. Defaults to 30 days before "to". | |
| limit | No | Optional max rows to return (1-100). Defaults to 50. Check meta.has_more and page with meta.next_cursor. | |
| cursor | No | Optional. Pass meta.next_cursor from a previous call to fetch the next page (keyset paging). | |
| status | No | Filter by settlement status. Defaults to "all" (booked + pending). | |
| verbose | No | When true, return the full raw transaction record instead of the lean shape. | |
| account_id | No | Optional. Restrict to a single financial account (id from list_accounts). Omit to span all accounts. | |
| date_field | No | Which date to filter/sort/show on. "mapped" (default) is Synci's authoritative per-account date; "booking" or "value" force a specific field. |
Output Schema
| Name | Required | Description |
|---|---|---|
| data | Yes | Newest first. Lean rows omit null/empty keys; with verbose:true each item is the full raw transaction record instead. |
| meta | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Goes far beyond annotations. Annotations only declare readOnly, idempotent, and non-destructive. The description adds critical behaviors: investment rows semantics (type, is_cash_flow, units, price_per_unit), the caveat that pending amounts can change, coverage limitation via meta.earliest_available_date, pagination with keyset cursor and meta.has_more, and the guarantee that sensitive identifiers are omitted. No contradiction with annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is long (~400 words) but well-structured into clear sections. Every sentence adds necessary detail for a complex tool with 8 parameters and nuanced behaviors. It front-loads the core purpose and then layers details logically. While it could be trimmed slightly, the thoroughness is justified given the complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's complexity (investment rows, coverage caveats, pagination, sensitive data, multiple date fields), the description covers all critical aspects an agent needs to call it correctly. The output schema exists, and the description adds context on interpretation (e.g., is_cash_flow) that is essential. Nothing important appears missing.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so baseline is 3, but the description substantially enriches parameter meaning. It explains date_field ('mapped' vs 'booking' vs 'value'), clarifies limit behavior (page may hold fewer rows), describes cursor usage, and details verbose vs lean shape. It also clarifies that 'date' defaults to Synci's authoritative date, adding nuance not in the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource: 'List the user's financial transactions in a date window, newest first, across all account types.' It enumerates account types and distinguishes itself from sibling tools (list_accounts, list_holdings, get_account_balance, list_connections) by clearly focusing on transactions. No ambiguity about what it does.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides extensive usage context: how to interpret investment rows for spending, when to use verbose, how to handle coverage gaps, and pagination instructions. It does not explicitly name alternative tools, but the purpose is so distinct that routing is obvious. The 'IMPORTANT' note on is_cash_flow is an explicit when-to-use-this-tool guideline for spending analysis.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
2 tool updates
- Changed
get_account_balance1 field changed- added
Output schema / properties / total_balanceAdded value: +{ + "description": "Broker-reported total account value (positions plus cash); investment accounts only.", + "properties": { + "amount": { + "type": [ + "string", + "number" + ] + }, + "currency": { + "type": [ + "string", + "null" + ] + } + }, + "type": "object" +}
- Changed
list_accounts1 field changed- added
Output schema / properties / accounts / items / properties / total_balanceAdded value: +{ + "description": "Broker-reported total account value (positions + cash); investment accounts only.", + "properties": { + "amount": { + "type": [ + "string", + "number" + ] + }, + "currency": { + "type": [ + "string", + "null" + ] + } + }, + "type": [ + "object", + "null" + ] +}
5 tool updates
- First observed
get_account_balance - First observed
list_accounts - First observed
list_connections - First observed
list_holdings - First observed
list_transactions
Related MCP Connectors
Read-only bank & investment accounts via Plaid: balances, holdings, transactions, SQL analytics.
Read bank accounts, balances and transactions from 10,000+ European banks.
Read-only access to your net worth, wealth percentile, projections, splits and budget.
Read-only crypto and traditional portfolio: holdings, PNL, FIFO tax figures and market data.
Related MCP Servers
- FlicenseBqualityDmaintenanceProvides read-only access to personal financial data via Pluggy, including accounts, transactions, investments, credit cards, and aggregations like total balance, monthly expenses, and net worth.18-

Fillfolio MCPofficial
AlicenseNot gradedqualityBmaintenanceEnables read-only access to a Fillfolio account's normalized portfolio data, including net worth, holdings with cost basis, cash and liabilities, activity, and exact asset details, plus optional bank spending summaries, transactions, and budgets for eligible accounts. Clients can query stored data only — they cannot trade, move money, modify holdings, or access credentials.12 npmMIT
Truthifi MCP serverofficial
AlicenseNot gradedqualityAmaintenanceEnables AI assistants to read a verified household financial record across linked accounts, including holdings, transactions, fees, performance, cash flow, advisors, diagnostics, and score findings. It can also refresh connections and manage manually tracked assets or liabilities inside the service, but cannot move money or place trades at financial institutions.MIT- AlicenseNot gradedqualityCmaintenanceConnect AI agents to real bank accounts across 15,000+ financial institutions for transactions, balances, investments, and loans.2MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.