How AI agents get live FX quotes and pay out through MCP and Agent Skills

An AI agent gets a live FX quote by calling a payments API as a tool. With BlindPay's MCP server, an agent in Claude Code, Cursor, Codex, or another MCP host can create a payout quote, show the rate, fees, and expiry, wait for a person to confirm, and execute the payout before the 5-minute window closes.

Key takeaways

• Three surfaces: an MCP server for agent hosts, Agent Skills for domain knowledge, and the REST API for code-generating builders.
• The quote is the same binding quote a backend gets: rate, fees, amounts, and expires_at, locked for 5 minutes by default.
• Confirmation is the agent's job. Build an explicit "confirm" step into the prompt or the app before any money moves.
• Start on a free development instance, where the token is USDB and nothing real moves.
• Agents are also useful after the payout: status checks and quality reports run on the same tools.

What does an AI agent need to quote and pay out?

It needs tools to call, knowledge of how payments work, and credentials it cannot leak. BlindPay ships one surface for each, described in the Build with AI docs.

The Model Context Protocol is an open-source standard for connecting AI applications to external tools and data. An MCP server turns an API into a list of tools the agent can discover and call. Skills are a separate layer: reusable instructions an agent loads to do a task well, installed through the open skills ecosystem with npx skills add.

For how agent payments fit with card and protocol initiatives, see agent payment protocols compared.

How do you connect an agent to BlindPay's MCP server?

Two environment variables and one command. In Claude Code:

claude mcp add blindpay \
  --env BLINDPAY_API_KEY=YOUR_API_KEY \
  --env BLINDPAY_INSTANCE_ID=in_000000000000 \
  -- npx -y @blindpay/mcp

Codex uses codex mcp add with the same arguments, and Cursor reads the same server block from .cursor/mcp.json. Then add the knowledge layer:

npx skills add blindpaylabs/skills

Use a development instance first. Development instances are free, run on testnets with USDB as the only token, and auto-complete payins, so an agent can rehearse the full flow without touching real money. Sandbox vs production covers what changes when you switch the key. Claude Code's own MCP documentation explains project-scoped .mcp.json files if you want the server checked into a repo.

What does a quote-to-payout run look like in an agent?

Six steps, each a tool call or a message to the human:

1. Find the rail. GetV1AvailableRails lists every payout rail, then GetV1AvailableBankDetails returns the fields a bank account needs for the chosen rail.
2. Create the quote. The agent calls the payout quote tool with the bank account, amount, currency_type, cover_fees, network, and token.
3. Show the numbers. Market rate, applied rate, each fee, what leaves, what arrives, and the expiry time.
4. Wait for confirmation. Nothing executes until the human replies.
5. Execute against the quote_id. Before expires_at. The funding step depends on where the stablecoins sit; see the payouts docs.
6. Report status. GetV1InstancesPayoutsById returns the payout and its status.

A prompt that encodes those rules:

Use the BlindPay tools to create a payout quote that delivers exactly
25,000 BRL to bank account ba_000000000000, with cover_fees true.
Show me the market rate, the applied rate, every fee, the USDC I send,
and when the quote expires. Do not execute until I reply "confirm".
If the quote expires first, request a new one and show me the new numbers.

Illustrative example. The agent requests a receiver-side quote: currency_type: "receiver", request_amount: 2500000 (R$25,000.00 in minor units), cover_fees: true. Suppose the quote returns a market rate (commercial_quotation) of 5.40, an applied rate (blindpay_quotation) of 5.373, and a 5.00 USDC flat fee added on top because the sender covers fees.

• USDC needed at the applied rate: 25,000 / 5.373 = 4,652.89
• Plus the flat fee: 4,652.89 + 5.00 = 4,657.89 USDC sent
• Delivered value at the market rate: 25,000 / 5.40 = $4,629.63
• All-in cost: (4,657.89 - 4,629.63) / 4,657.89 = 0.61%

The agent can show that last line too. Cost per delivered dollar explains the formula, and every number here is illustrative, not a BlindPay price.

How should an agent handle quote expiry?

Treat expiry as a normal path. A BlindPay quote expires 5 minutes after creation by default, and expires_at is epoch milliseconds. If the human replies after that, the agent requests a new quote, shows what changed, and asks again.

Three rules to put in the prompt:

• Never reuse an expired quote_id. A quote backs one payout, and an expired one is rejected rather than executed at a new rate.
• Quote late. Ask for the quote when the human is ready to decide, not at the start of a long conversation.
• Say what moved. If the new receiver_amount or sender_amount differs, show the old and new numbers side by side.

For the same logic in application code, with retries and idempotency keys, see how to handle expired quotes in TypeScript and Python. The quote fields themselves are covered in stablecoin API quotes explained.

Which guardrails should wrap money-moving tools?

A human confirmation, a scoped key, and a log. The MCP specification says there should always be a human in the loop with the ability to deny tool invocations, and that applications should show confirmation prompts for operations. BlindPay's docs apply that to payments: build the confirmation step into the agent prompt or app flow before any payout, payin, or transfer executes.

Autonomous agents that chain many calls, such as OpenClaw, need the confirmation rule most. The connect an AI agent prompt packages these guardrails into a setup prompt you can paste.

Can an agent show a price before creating a quote?

Yes, on the payin side. POST /payin-quotes/fx returns an indicative rate and amount without creating a quote, so an agent can answer "roughly how much USDC will 10,000 BRL buy?" before committing to a binding, time-limited payin quote. Indicative rate vs binding quote explains when each one belongs in a flow, and the payin quotes docs list the fields.

How do agents help after the payout?

They answer status and quality questions in plain language. "Where is payout po_...?" maps to GetV1InstancesPayoutsById, which returns the same payout object your backend sees. Since October 2, 2026, the MCP server lists the authenticated status tools instead of the public tracking-page endpoints, which only answer BlindPay's shareable tracking pages.

Agents also make reporting cheaper. Ask for last week's payouts by corridor, then compute expiry rate and delivery success with the formulas in payout quality metrics. The vocabulary throughout follows the on/off-ramp liquidity glossary.

What about AI app builders without an MCP host?

They call the REST API from a backend route. Lovable, v0, Bolt, and Replit generate application code, so you paste a prompt describing a server function that creates a payout quote with POST /v1/instances/{instance_id}/quotes, shows the live quote, and executes the payout before it expires. The API key lives in the builder's secrets, never in client code. The Claude Code integration guide and its sibling pages cover each builder, and how to integrate a stablecoin API walks the same flow by hand.

What to do next

Add the BlindPay MCP server to your agent host with a development instance key, load Agent Skills, and paste the prompt above with a test bank account. Watch the agent quote, wait, and execute. Setup for every host is in the Build with AI docs.

Using agents to build the app itself? Build a neobank with AI agents covers the CLI, MCP setup, Agent Skills, and guardrails for payments.

This article is general information, not legal, tax, or financial advice.