# How to use Mercury with Replicas

Use cloud agents with Mercury in Replicas to review cash, analyze spend, reconcile invoices, assemble statements, and automate finance reports.

- Author: Connor Loi
- Published: 2026-09-20
- Category: Best practices
- Canonical: https://replicas.dev/blog/how-to-use-mercury-with-replicas

Replicas cloud agents can use Mercury to analyze account balances, transactions, card spend, invoices, statements, and treasury data. Connect the Mercury plugin, give an agent a specific finance task, and ask it to return the source records and assumptions behind its answer.

You can also connect Google Sheets or Google Docs to create finance reports, or add a repository when the work leads back to billing, invoicing, or financial operations code. Mercury's official MCP is currently in beta and read-only, so agents can inspect financial data but cannot move money or change your Mercury account.

This guide explains how to connect Mercury to Replicas and covers five workflows: cash reporting, spend analysis, invoice reconciliation, statement review, and weekly finance reporting. Replace the bracketed details with your accounts, dates, definitions, and document links.

## 1. Connect Mercury

1. Open the Replicas **environment** you want to use and select its **Plugins** tab.
2. Install **Mercury** and complete the Mercury OAuth flow.
3. Review the access request and approve the connection.
4. Start a workspace using that environment. Add Google Sheets or Google Docs if the agent should create a report outside the workspace.

Mercury data includes balances, transactions, recipients, and statements. Install it only on an environment whose members should have access to that financial information. A Global installation reaches every workspace in the organization; a team or personal environment limits the connection to that environment's workspaces.

See the [plugin setup documentation](https://docs.replicas.dev/features/plugins) for the full connection flow and [Mercury's MCP security guidance](https://docs.mercury.com/docs/security-best-practices) for the data the connection exposes.

Start with a small read-only task:

```text
Check that you can read our Mercury organization, accounts, and recent
transactions. List the accounts you can access with their current balances,
then summarize five recent transactions with dates, amounts, and categories.
Include the source IDs needed to verify each result in Mercury. Do not infer
missing fields or use any other connected system.
```

Once the account scope looks right, move to a specific financial question.

## 2. Build a current cash position

A useful cash report needs a timestamp and a definition. Decide which accounts count as operating cash, whether treasury balances belong in the total, and which pending transactions should be shown separately.

```text
Using Mercury, calculate our cash position as of [date and time].

Show each checking, savings, and treasury account separately with its balance
and currency. Total operating cash using [account list or inclusion rule].
List pending transactions separately and do not subtract them from the total
unless Mercury already includes them in the reported balance.

Return the source account IDs, the timestamp for each balance, and any accounts
you excluded. Leave Mercury unchanged.
```

If you want runway, provide the planning assumptions instead of asking the agent to invent them. Mercury can supply the current cash and historical transactions, but a runway model also needs your definition of burn and any expected cash flows outside the available history.

```text
Use the cash position above and the approved monthly forecast in
[Google Sheet link]. Calculate runway under the base, conservative, and hiring
plan scenarios already defined in that sheet. Do not create new assumptions.
Show the formula, starting cash, monthly net burn, and resulting runway for
each scenario. Flag stale inputs or differences between the sheet's opening
balance and Mercury's current balances.
```

## 3. Review spend

Mercury transaction data includes details such as categories, merchants, users, and cards. Give the agent a period and a comparison so it can separate a large but expected payment from an actual change.

```text
Review outgoing Mercury transactions for [current period] and compare them
with [baseline period]. Group spend by category and merchant, then show the
largest absolute and percentage changes.

Separately list duplicate-looking charges, first-time merchants, charges above
[$ threshold], and card transactions outside [approved rule]. For every flagged
item, include the transaction ID, date, amount, merchant, category, account,
and card or user when available.

Treat each flag as something to review, not proof of an error or fraud. Leave
Mercury unchanged and return the analysis in [workspace / Google Sheet].
```

Review the category and merchant mappings before using the totals in a forecast. A transaction can be real and correctly recorded while still being grouped differently from your accounting chart.

## 4. Check invoices and incoming payments

The Mercury connection can read customers, invoices, and transactions. That makes it useful for preparing a reconciliation worklist, especially when a payment and invoice do not match cleanly.

```text
Review Mercury invoices for [date range] and group them by paid, open, overdue,
and unknown status. For paid invoices, identify the matching incoming
transaction when Mercury exposes one.

List invoices with no matching payment, incoming payments with no clear
invoice, partial payments, and amount or customer mismatches. Include invoice,
customer, and transaction IDs with source links where available.

Create a reconciliation worklist in [Google Sheet link]. Do not mark invoices
paid, contact customers, or change Mercury records. Leave ambiguous matches
unmatched and explain what a reviewer should check.
```

The output is a review queue, not an accounting entry. Confirm ambiguous matches in Mercury and your accounting system before closing an invoice or changing the books.

## 5. Assemble a statement package

For a board meeting, audit request, or monthly close, ask the agent to inventory statements and produce an index. Define the accounts and period so missing documents are obvious.

```text
For [start month] through [end month], inventory the Mercury statements for
[account list]. Include treasury statements separately.

Create a Google Doc index with the account name, last four digits or safe
identifier, statement period, and source document link for every statement.
List missing months, duplicate periods, and accounts with no available
statement. Do not copy account or routing numbers into the index.

Return the document link and a short completeness summary. Leave Mercury and
the source statements unchanged.
```

Keep the index in a location with the same or stricter access than the underlying financial documents. Before sharing it, open a sample of the linked statements and verify the account and period.

## 6. Schedule a weekly finance report

Once a report format works, save the prompt as a [Replicas automation](https://docs.replicas.dev/features/automations). Choose the environment with Mercury and the document plugin, then schedule it after the reporting period closes.

```text
Every Monday, create a finance report for the previous complete
Monday-to-Sunday week using Mercury.

Include ending balances by account, total operating cash using [definition],
cash inflows and outflows, the ten largest outgoing transactions, spend by
category, new merchants, and invoices that became overdue during the week.
Compare each section with the preceding complete week.

Create a dated Google Doc and add its link to [tracking document]. Include
source IDs and the exact date range. If data is unavailable or incomplete,
report the gap instead of treating it as zero. Do not change Mercury records.
```

Check the first run against Mercury before relying on the schedule. Financial reports are much easier to trust when every total has a definition, every period has exact boundaries, and every exception links back to the source record.

[Start a Replicas workspace](https://replicas.dev/auth?mode=signup), [configure the Mercury plugin](https://docs.replicas.dev/features/plugins), or read [Mercury's MCP documentation](https://docs.mercury.com/docs/what-is-mercury-mcp).

