@jbctechsolutions/mcp-mercury
Click on "Install Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@@jbctechsolutions/mcp-mercurylist my accounts with balances"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
@jbctechsolutions/mcp-mercury
Read-only MCP server for Mercury business banking — accounts, transactions, and statements.
A Model Context Protocol (MCP) server that exposes 6 read-only tools against the Mercury API. No payment, recipient, or any other write endpoint is implemented, by design.
Tools
Tool | Description |
| All accounts with balances, account/routing numbers, status |
| One account by ID |
| Transactions for an account (date range, status, search, pagination) |
| One transaction by ID |
| Monthly statements (period, ending balance, PDF download URL) |
| Save a statement PDF to a local path (mercury.com URLs only) |
Related MCP server: Mercury MCP
Token handling
The Mercury API token is resolved at runtime, in this order:
MERCURY_API_TOKENenvironment variable — intended for tests/CI only1Password CLI:
op item get "Mercury API - read only" --account jbctechsolutions.1password.com --fields label=credential --reveal
The token is cached in memory only. It is never written to disk, never logged, and never included in error messages. Statement downloads refuse non-mercury.com URLs so the bearer token cannot be sent elsewhere.
Create the token in Mercury with read-only scope (Settings → API Tokens), store it in the 1Password item's credential field, and you're done — no config files.
Environment overrides
Variable | Default | Purpose |
| — | Bypass 1Password (tests/CI) |
|
| 1Password account |
|
| 1Password item name |
|
| API base (tests only) |
Quick start
npm install
npm run buildClaude Code / Claude Desktop configuration
{
"mcpServers": {
"mercury": {
"command": "node",
"args": ["/path/to/mcp-mercury/dist/index.js"]
}
}
}(Once published: npx -y @jbctechsolutions/mcp-mercury.)
The 1Password CLI must be installed and signed in to the jbctechsolutions account for token resolution to work.
Development
npm test # vitest unit tests
npm run typecheck # tsc --noEmit
npm run build # compile to dist/License
MIT © JBC Tech Solutions, LLC
Available Tools
6 toolsdownload_statement_pdfA
Download a statement PDF (from a list_statements downloadUrl) to a local file. Only mercury.com URLs are accepted.
| Name | Required | Description | Default |
|---|---|---|---|
| output_path | Yes | Absolute path to write the PDF to | |
| download_url | Yes | The downloadUrl of a statement from list_statements |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It mentions the URL validation but lacks details on file overwriting behavior, error handling (e.g., invalid URL), or authorization requirements. The behavioral disclosure is adequate but minimal.
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 sentences, no unnecessary words. The most critical information (purpose and URL restriction) is front-loaded. Every sentence serves a purpose.
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 simple download tool with two parameters, the description covers the essential: source constraint and destination. It could mention what happens if the output file exists or if the URL fails, but overall it is sufficiently complete given the tool's simplicity.
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% with clear descriptions for both parameters. The description adds extra value by specifying that only mercury.com URLs are accepted, which is not in the schema. This enhances semantic clarity.
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 clearly states the action (download), the resource (statement PDF), the source (from list_statements downloadUrl), and the destination (local file). It also adds a URL restriction, making the purpose unambiguous and distinguishing it from siblings like list_statements or list_transactions.
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 provides a clear constraint (only mercury.com URLs are accepted) and implies the tool is used after list_statements. However, it does not explicitly state when to use this tool versus alternatives or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_accountA
Get a single Mercury account by ID, including current and available balances.
| Name | Required | Description | Default |
|---|---|---|---|
| account_id | Yes | Mercury account ID (UUID) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description must carry full burden. Only mentions inclusion of balances, but fails to disclose read-only nature, idempotency, rate limits, or error conditions. Minimal behavioral insight beyond basic output.
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?
Single sentence conveying purpose and output concisely. No redundant words; 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?
With one required parameter and no output schema, description adequately states purpose and key output (balances). Could be more complete by hinting at other returned fields (e.g., account name, currency), but sufficient for a simple read 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?
Schema description coverage is 100%, with account_id adequately described as 'Mercury account ID (UUID)'. The tool description does not add further meaning beyond the schema, so a baseline score of 3 is appropriate.
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?
Clearly specifies the action 'Get', the resource 'single Mercury account', and includes distinct output details 'current and available balances'. Distinguishes from sibling tools like list_accounts (plural) and get_transaction (different resource).
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?
Implies usage when needing a specific account by ID, but provides no guidance on when not to use it (e.g., for listing all accounts) or alternatives. Lacks explicit context of prerequisites or exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_transactionB
Get a single transaction by ID for a Mercury account.
| Name | Required | Description | Default |
|---|---|---|---|
| account_id | Yes | Mercury account ID (UUID) | |
| transaction_id | Yes | Transaction ID (UUID) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It only states the tool 'gets' a transaction, with no disclosure of error states (e.g., what happens if ID not found), rate limits, or idempotency. The behavioral insight is very limited.
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 a single, well-structured sentence with no redundant or extraneous information. It is appropriately concise for a simple getter tool.
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 is a simple single-resource fetch with no output schema, the description provides the core purpose but lacks context about error handling, return format, or usage scenarios. It is minimally adequate but not rich.
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% for the two parameters, and the description does not add new meaning beyond the schema's own descriptions. It states the tool is for a Mercury account, which aligns with account_id, but that is already implied by the parameter name.
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 clearly states the tool retrieves a single transaction by ID for a Mercury account, using a specific verb and resource. It effectively distinguishes from siblings like list_transactions (multiple) and get_account (different resource).
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?
No guidance on when to use this tool versus alternatives such as list_transactions. The description does not specify prerequisites, nor does it mention when not to use it (e.g., for batch retrieval).
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_accountsA
List all Mercury bank accounts with balances, account/routing numbers, and status. Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description includes a 'Read-only' label, which is a behavioral trait. However, with no annotations, it does not disclose authentication needs, response format, or whether the list is paginated. The description is adequate but lacks depth.
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 a single sentence that is direct and concise with no unnecessary words. It front-loads the key action and information.
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 lack of output schema and annotations, the description covers the core functionality but leaves out details like response structure or potential limits. For a simple list tool, this is minimally complete.
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 0 parameters, and the schema coverage is 100%. The description adds no parameter information, which is acceptable as there are none. Baseline score of 4 applies.
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 clearly states the verb 'list' and the resource 'Mercury bank accounts,' specifying the data returned (balances, account/routing numbers, status). This distinguishes it from sibling tools like 'get_account' (single account) and 'list_transactions' (transactions).
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 provides no guidance on when to use this tool versus alternatives such as 'get_account' for a single account. There is no mention of prerequisites, limitations, or context where it is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_statementsA
List monthly statements for a Mercury account (period, ending balance, PDF download URL). Date range filters are limited to 3 months per request.
| Name | Required | Description | Default |
|---|---|---|---|
| end | No | Latest statement date. Date in YYYY-MM-DD format | |
| limit | No | Maximum results (1-1000, default 100) | |
| order | No | Sort order (default desc) | |
| start | No | Earliest statement date. Date in YYYY-MM-DD format (max 3-month range with end) | |
| account_id | Yes | Mercury account ID (UUID) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries full burden. It discloses the 3-month limit, but lacks details on pagination, error conditions, or authorization needs. The return format is hinted but not fully specified.
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 sentences, front-loaded with purpose and key constraint. Every word 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?
No output schema exists, so description should compensate. It mentions response fields but not pagination or error details. For a 5-parameter tool, it is moderately complete but has 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?
Schema description coverage is 100%, so baseline is 3. The description does not add meaning beyond schema; it mentions response fields but not parameter details.
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 'List monthly statements for a Mercury account' with specifics about returned fields (period, ending balance, PDF download URL). It distinguishes from siblings like download_statement_pdf, which downloads instead of lists.
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 provides a clear usage constraint: 'Date range filters are limited to 3 months per request.' While it doesn't explicitly compare to alternatives, the sibling context makes it obvious that list_statements is for listing and download_statement_pdf for downloading.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_transactionsA
List transactions for a Mercury account, filterable by date range, status, and search term. Defaults to the last 30 days if no start date is given. Read-only.
| Name | Required | Description | Default |
|---|---|---|---|
| end | No | Latest transaction date. Date in YYYY-MM-DD format | |
| limit | No | Maximum results (1-1000, default 500) | |
| order | No | Sort order (default desc) | |
| start | No | Earliest transaction date. Date in YYYY-MM-DD format | |
| offset | No | Results to skip, for pagination | |
| search | No | Filter by description or counterparty name | |
| status | No | Filter by transaction status | |
| account_id | Yes | Mercury account ID (UUID) |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It explicitly states 'Read-only', which is good, and notes the default date range. However, it does not disclose potential side effects, error handling, or performance characteristics.
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 sentences, no wasted words. Clear and front-loaded with the core purpose. Every sentence adds useful information.
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 description covers the basic function but lacks details about output format, pagination behavior (though offset parameter exists), and error scenarios. For a list tool without output schema, more context on what is returned would be helpful.
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 all parameters. The description adds minimal value by mentioning filtering by date range, status, and search term, which correspond to parameters start/end, status, and search. No new semantics 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?
The description clearly states the tool lists transactions for a Mercury account, with filtering options like date range, status, and search term. It distinguishes itself from siblings like 'get_transaction' (single) and 'download_statement_pdf' (file download).
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 mentions default behavior (last 30 days) and filtering, but does not explicitly state when to use this tool vs alternatives like 'get_transaction' or 'list_accounts'. No exclusion criteria or prerequisites are given.
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.
6 tool updates
v0.1.0- First observed
download_statement_pdf - First observed
get_account - First observed
get_transaction - First observed
list_accounts - First observed
list_statements - First observed
list_transactions
TDQS
Scored across 6 tools
Each tool targets a distinct resource: accounts, transactions, or statements, with no overlap in functionality.
All tools follow a consistent verb_noun pattern (e.g., list_accounts, get_transaction), making them predictable and easy to differentiate.
Six tools cover the core banking operations (accounts, transactions, statements) without being too many or too few, fitting the server's read-only purpose.
The tool set covers listing and retrieving accounts, transactions, and statements, but lacks any write operations; however, the read-only design is intentional and well-scoped.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
MCP server for Modern Treasury — payment orders, transactions, counterparties and ledgers.
An MCP server that provides read access to your cloud storage providers, bank accounts and more.
MCP server for Codat — companies, connections, invoices, bills and financial statements.
Read-only MCP server for turva.dev, an agent-readiness audit and advisory service.
Related MCP Servers
- AlicenseAqualityAmaintenanceMercury Banking MCP server with full Invoicing API support. Read accounts/transactions and create/manage recurring invoices via Model Context Protocol.361011MIT
- AlicenseNot gradedqualityDmaintenanceSimple MCP server that interfaces with the Mercury API, allowing you to talk to your Mercury banking data from any MCP client like Cursor or Claude Desktop.4MIT
- AlicenseAqualityDmaintenanceRead-only MCP server for reconciling SimpleFIN bank data against Firefly III ledger, enabling audit and review workflows without mutation.1951MIT
- AlicenseAqualityDmaintenanceRead-only MCP and HTTP proxy server for accessing Monarch Money financial data, enabling transaction analysis, budget tracking, and cashflow insights through natural language.6MIT