Skip to content
Agentic Control Plane

The Stripe MCP server control model, explained

The Stripe MCP server is where this series stops being hypothetical: its tools move money. It is first-party, remote at https://mcp.stripe.com (OAuth) and local via npx -y @stripe/mcp (part of the agent-toolkit family). There is an official Claude Code plugin (stripe@claude-plugins-official) and one-click installs for Cursor, VS Code, and Codex.

It has the best native control among the sixteen servers in this series, and the docs hand the hard part back to you. Sources: the official MCP docs and the restricted-key docs.

This page covers the server’s own controls. For the cross-server picture, see the MCP server controls comparison. For what a control layer adds on top, see the coverage matrix.

What’s at stake

Every other server in this series can lose you data or code. This one can lose you money, and some of it for good. create_refund is a named tool, and a completed refund is not clawed back.

The stripe_api_write meta-tool reaches subscription cancellation, invoice finalization and voiding, coupon deletion, payment-link creation, and webhook-endpoint creation. That last one changes where your payment events go.

The read side covers customers, charges, payouts, issuing cards, and balance history. That is customer PII and financial records, which is exactly what a prompt injection wants to pull out.

Auth: OAuth remote, key local

The remote server uses OAuth per the MCP spec. You get a consent form on connect, then a session that shows up in your Dashboard user settings and can be revoked per client.

Admins can view and revoke any team member’s MCP sessions (“Revoke all” included). They can also turn MCP access on or off for the account, separately for sandbox and live mode. No other server here gives you a named, listable, revocable grant per client at the vendor.

Clients without OAuth, and autonomous agents in particular, send a bearer key in the Authorization header. Stripe’s docs are direct about it: “We strongly recommend using restricted API keys to limit your agent’s access to exactly the functionality it requires.” The local server takes the same key as --api-key. Which key you mint is the whole control model.

Restricted keys: scoping the agent can’t edit past

Most servers on the comparison table enforce their scoping in or before the server process. That means flags and env vars in a client config that lives in the workspace, where the agent can usually read and often write it. GitHub’s read-only mode is a filter the server applies to itself. Supabase’s read-only role is set by a launch flag.

Stripe’s restricted API keys work differently. You set per-resource read/write permissions in the Dashboard, and Stripe’s API servers check them on every call. A key with Refunds set to none cannot create a refund. The tool isn’t hidden. Stripe refuses the request. No prompt injection, config edit, or odd argument changes that, because the key is held at Stripe.

GitHub’s fine-grained PATs come close. Supabase’s account-wide PATs don’t try. Stripe is the one server here where the vendor enforces the credential’s scope and the agent can’t widen it.

Now the grain. Permissions are binary per resource: Refunds read or write, Subscriptions read or write. Write means all writes at any size. No key can refund up to $50, refund at most three times an hour, or cancel subscriptions only below a given MRR. The strongest enforcement in the series has the coarsest vocabulary, on the surface where fine grain matters most.

Tool selection: two meta-tools carry the write surface

The remote server’s tool list is short. It has named tools like create_refund, get_stripe_account_info, and search_stripe_documentation. It also has four API meta-tools: stripe_api_search, stripe_api_details, stripe_api_read, and stripe_api_write. Through those, a hundred-plus supported API methods pass without filling the context window.

That keeps context small, but it breaks filtering by tool name. Allow stripe_api_write and you’ve allowed subscription cancellation, invoice voiding, coupon deletion, and webhook creation under one name. Deny it and you’ve also denied harmless writes. Any control keyed on tool names sees one tool, while the risk sits in the arguments.

The local server’s --tools flag (documented as --tools=all, with the key carrying the real permissions) narrows the older per-action surface. On the remote server, the grain that matters is the key.

Sandboxes: rehearsal with real walls

Stripe’s test environments are the best rehearsal setup in the series. Keys are per-environment, so a sandbox key cannot touch live money, and MCP access is managed separately for sandbox and live mode. Supabase’s branching puts the sandbox and the merge tools on the same surface. Here the wall is at the credential, and Stripe enforces it.

The limit is the usual one. Rehearsal is not a runtime boundary. Once the agent has the live key, having rehearsed doesn’t constrain what it does with it.

The missing pieces: amounts, velocity, approvals

Three policies matter more here than anywhere else, and none can be expressed natively.

  • Amounts. “Never refund more than $X” doesn’t exist. A key that can refund can refund any amount on any charge.
  • Velocity. The docs mention no MCP-level rate or amount limits. The fiftieth refund in an hour is processed like the first, and runaway loops get expensive fastest on money surfaces.
  • Approvals. The server can’t hold a call for a human. Stripe’s docs say: “We recommend enabling human confirmation of tools and exercising caution when using the Stripe MCP with other servers to avoid prompt injection attacks.”

The first half of that sentence leaves approval to your MCP client. That is a client-side courtesy, and it’s the first thing gone in yolo mode. The second half names the read-untrusted-then-act pattern and gives you caution, not a control.

Stripe’s Dashboard request logs are a useful record. Every API call the server makes lands there, which is more than most servers leave you (the general MCP audit gap). But it’s forensics, not control. The log doesn’t say which agent made the call, it isn’t MCP-aware (a stripe_api_write call logs as the underlying API request), and you read it after the refund has cleared.

Where the native model ends

Stripe gives you key scoping enforced by the vendor, revocable named sessions, admin kill switches, and a wall between sandbox and live at the credential. It’s the one boundary in this series that survives anything the agent does to its own config. The gaps sit where the money does:

  • The key’s vocabulary is binary. Read or write, per resource. No amounts, no rates, no conditions.
  • Nothing is per-call. The key decides once, when you mint it. One create_refund looks like any other to every native mechanism.
  • The approval has no home. Stripe recommends human confirmation and ships no mechanism for it. It lives wherever your client puts it, at whatever autonomy setting the client is in.
  • The record is downstream. Request logs say which calls happened, not which agent made them or under what setting.

Here is what to do. Mint a restricted key with only the writes the task needs. Rehearse in a sandbox. Prune OAuth sessions. Leave client confirmation on.

Then add a layer in the agent’s tool-call path, outside the Stripe config. ACP is one: a hook in the agent’s harness that can hold create_refund and stripe_api_write for approval, set a per-minute limit, and record each call against the agent that made it. It decides per tool call, so it can’t enforce a dollar cap. Because it runs on the same machine as the agent, it can be disabled there, which is why the restricted key stays as the backstop.

Running coding agents? ACP records each tool call its hook sees and makes the dangerous shell commands (a force-push, destructive SQL, curl | sh) wait for you. One command, free up to 5 agents:

macOS · Linux · WSL
curl -fsSL https://agenticcontrolplane.com/install.sh | bash
Windows · PowerShell
irm https://agenticcontrolplane.com/install.ps1 | iex

What the installer writes  ·  Getting started