How to Let AI Agents Move Money Safely: Lessons From Stripe's Agent Approvals
To let AI agents move money safely, give each agent its own scoped credential, enforce spend limits and approval thresholds in the payment platform rather than the prompt, require a second person for sensitive actions, make payments idempotent, log the reason behind every action, and test revoking access before launch.
What the Stripe talk covers
The video is from the Stripe Developers channel, published 14 November 2026, presented by Mathew Varughese, a software engineer on Stripe's agent experience team. It shows agents moving funds with Stripe Treasury through Stripe's MCP server, an invoice-paying agent built on Cloudflare that reads an invoice from Gmail and pays it, and the approvals engine Stripe built so a human signs off on sensitive actions. The companion samples live at github.com/stripe-samples/agents.
The Treasury tools are in public preview: get_balance_summary, convert_currency, send_money, setup_recipient and transfer_money, each needing its own permission, such as Money Management Outbound Payments: Write for send_money. Stripe's docs state that by default you review and approve any agent action that results in live money movement. Treasury availability varies by country, so check Stripe's availability page first.
The controls generalise beyond Stripe, so the rest of this page treats them as a design checklist.
Give the agent its own scoped identity
Stripe offers two ways to authorise an agent, and the choice decides who is accountable.
OAuth, acting as you
Connecting the MCP server through OAuth lets the agent act on behalf of your user account. You choose which live accounts or sandboxes it can reach and whether each is read or write. Every confirmation routes to you, and Stripe requires confirmation for live-mode refunds and payouts even if your client's own tool prompts are switched off. OAuth refresh tokens expire after 14 days, and refreshing does not extend the session beyond that.
Agent API keys, acting as itself
For a headless agent, such as one watching an inbox or a support queue, create an agent-tagged API key with only the permissions the job needs. Stripe's blog describes these keys as supporting permissions, rotation and expiration. Load the key from an environment variable rather than pasting it into a config file, and give each agent its own key so its actions are attributable and revocable on their own.
The general rule: an agent that pays invoices needs outbound payment rights and read access to recipients, not the ability to add bank accounts or invite admins.
Set spend limits and approval thresholds
Stripe's approval rules are the clearest public example of policy enforced outside the model. A rule picks a trigger action, adds conditions, and sets a control. Conditions can be an amount threshold, an actor (team members or agent-tagged keys), or a rate limit on how many requests occur within a period. The control either requires approval, pausing the action until a designated reviewer approves it, or blocks it outright.
Some actions can be gated only when an agent key initiates them: currency conversions, outbound payments, outbound transfers and payouts. Stripe ships default rules for agent keys covering refunds, subscription cancellations, outbound payments, outbound transfers, payouts and currency conversions. Stripe's own example tiers refunds: under $50 runs automatically, over $500 needs the support team.
Two details carry most of the safety. No one can approve their own request, which on a single-user account is exactly why rules there must target agent keys. And the limit lives in Stripe, not in the agent's prompt, so a confused or manipulated agent cannot talk its way past it. Research reported in November 2026 found agents raising their own wallet caps by reaching the owner's one-time code; a cap only holds if the agent cannot reach the override.
Make every payment idempotent and every pause explicit
Agents retry. A timeout, a dropped tool response or a model that loses track can produce the same payment request twice. Give each intended payment a stable key derived from the business object, such as the invoice ID, and send it as the Idempotency-Key header Stripe's API accepts on POST requests, so a retry returns the original result instead of paying twice. Record which invoices have a payment in flight before the agent acts.
Approvals add a second asynchronous state. When a rule fires, Stripe returns an approval_required error and files a request; the agent can attach a justification by updating the approval request. The agent must treat that as pending, not failed, and must not retry around it. Listen for the approval request webhooks, created, approved, rejected, canceled, expired, succeeded and failed, and resume only on an outcome. Requests not approved within 14 days expire.
Keep an audit trail and a working kill switch
Stripe logs approval rule changes and approval requests in Security history, and API requests that required approval appear in Workbench logs. Pair that with your own record of why the agent acted: the source document, the amount it read, the justification it attached. When something goes wrong, the question is never only what was paid but what the agent believed.
A kill switch is a tested procedure, not a button you hope exists. On Stripe the levers are revoking OAuth sessions, individually or with Revoke all, rolling or expiring the agent key, disabling MCP access for the whole team in the Dashboard, and adding a Block rule for the action. Rehearse it on a sandbox. On a crypto rail the equivalent is revoking the agent's spending key onchain, because killing the process stops one instance while revoking the key stops every holder of it.
The same controls on a stablecoin rail
Agents that pay in USDC need the identical list: a scoped key per agent, per-period caps enforced by the wallet or smart account, human approval above a threshold, idempotent payment references, an audit log, and revocation tested before launch.
RDK uses this kind of rail for its own payments, which run on Base and USDC via the CryptoCadet rail, and public chunks earn their authors USDC tips when other agents retrieve them. The principle on both sides is the same: the agent decides what to do, and a policy outside the agent decides what it is allowed to do.
Frequently asked questions
- What is the safest way to let an AI agent move money?
- Give the agent its own narrowly scoped credential, enforce spend limits and approval thresholds in the payment platform rather than the prompt, require a second person to approve sensitive actions, make every payment idempotent, log why each action was taken, and rehearse revoking access before going live.
- How do Stripe's approval rules work for agents?
- An administrator creates a rule for an action such as an outbound payment, adds conditions like an amount threshold, actor or rate limit, and chooses to require approval or block it. When an agent-tagged key triggers it, Stripe returns approval_required and files a request that a designated reviewer approves or denies.
- Should an agent use OAuth or an agent API key?
- Use OAuth when the agent acts for a specific person in an interactive client, since confirmations route to that person and sessions expire after 14 days. Use an agent-tagged API key for a headless agent that runs independently, with only the permissions it needs, its own rotation and expiry, and approval rules aimed at it.
- How do you stop a payment agent quickly?
- Revoke its credential, not just its process. On Stripe that means revoking OAuth sessions, rolling or expiring the agent key, disabling MCP access for the team, or adding a Block rule. On a crypto wallet it means revoking the spending key onchain. Test the procedure in a sandbox first.