Payment MCP Servers for AI Coding Agents (2026)

The Short Answer

A payment MCP server exposes payment operations — charging a card, sending a stablecoin, creating an invoice, issuing a refund — as tools an AI agent can call over the Model Context Protocol. You point your agent at the server and it can move money through those tools instead of custom API glue. Because MCP is a shared standard, the same server works across Claude Code, Codex, Cursor, and Gemini CLI.

The real ones, as of 2026: Stripe's MCP server and Agent Toolkit, Coinbase's x402, Stripe and Tempo's Machine Payments Protocol, Nevermined, Amazon Bedrock AgentCore Payments, and PayPal's forthcoming ACP server. The rest of this post is what each does, how you use it, and how to pick. If you are assembling an agent's toolset more broadly, the payment tools sit alongside the general ones in the best MCP servers roundup.

How an Agent Actually Pays

Four steps, every time, whichever tool you use:

1. Intent. The agent decides a payment is needed — a paid API returned a 402, a subscription is due, an invoice needs clearing.
2. Tool call. It calls a payment tool the MCP server exposes (create a charge, issue a refund) with the amount and payee as arguments.
3. Rail. The server routes that call to the real payment rail — a card network, a stablecoin on-chain, a bank transfer — and the money moves.
4. Audit. A receipt comes back, and if you wired it correctly, a record is written: which agent paid whom, how much, and why.

MCP is only the connective tissue between the agent and the rail; it does not move money itself. For the protocol layer underneath — AP2, ACP, x402, MPP, and how they relate — start with the agentic payments explainer.

The Options

Here are the payment MCP servers and toolkits worth knowing, side by side, then a short note on each.

Stripe MCP / Agent Toolkit

Stripe runs a remote MCP server at https://mcp.stripe.com, OAuth-authenticated, exposing around 25 payment operations as of 2026 — refunds, subscriptions, invoices, and more. You point your agent's MCP config at that URL and scope access with a Stripe restricted API key limited to the operations you actually need. If you would rather run tools in-process, the Stripe Agent Toolkit (Python and TypeScript, on github.com/stripe/ai) wraps the Stripe API as LLM-callable tools for the OpenAI Agents SDK, LangChain, CrewAI, and the Vercel AI SDK. Caveat: these tools act on your live Stripe account, so a broad key is a broad blast radius — scope it. We walk through setup in adding Stripe to an AI agent.

// Illustrative — connecting an MCP-capable agent to a remote payment MCP server.
// The config schema differs per client (Claude Code, Codex, Cursor, Gemini CLI).
{
  "mcpServers": {
    "stripe": {
      "url": "https://mcp.stripe.com",
      "auth": "oauth"
    }
  }
}

// Or run the tools in-process with the Stripe Agent Toolkit (Python / TypeScript),
// authenticating with a RESTRICTED API key scoped to only the operations you need.

Coinbase x402

x402 revives the long-dormant HTTP 402 “Payment Required” status code so a server can charge for a request inline. The agent hits an endpoint, gets a 402 with payment details, pays in stablecoin, and retries — no signup, no API-key dance. Rails: stablecoins over HTTP. It is built for machine-to-machine payments and API monetization. Caveat: it is a crypto rail, so you need a funded wallet and are settling on-chain, a different operational and compliance profile than cards.

Stripe + Tempo MPP

The Machine Payments Protocol, from Stripe with the Tempo chain, is an open protocol for agents to pay for things. It uses Stripe primitives — PaymentIntents and Shared Payment Tokens — settles on Tempo, and like x402 it leans on HTTP 402 for inline payment. Rails: stablecoin or fiat depending on setup. You use it through Stripe's tooling as it rolls out. Caveat: it is newer than the card path and the spec is still moving as of 2026, so treat integrations as early. See how it lines up against x402 in the protocols compared.

Nevermined

Nevermined is agent-payments infrastructure aimed at whole agent economies: spending, earning, identity, and usage metering, with TypeScript and Python SDKs. If your agent needs to both pay for services and get paid — charging per query, metering usage — it covers more of that loop than a single checkout tool. Caveat: it is a heavier framework than a drop-in MCP server, and it is oriented toward agent-to-agent commerce rather than simple card checkout.

Amazon Bedrock AgentCore Payments

For teams already on AWS, Bedrock AgentCore offers agent payments built with Coinbase and Stripe under the hood, so you get card and stablecoin rails inside the Bedrock agent stack. You use it through AgentCore if your agents already live there. Caveat: it is tied to the Bedrock stack, so it fits when you are on AWS and less so otherwise.

PayPal (ACP)

PayPal is building an Agentic Commerce Protocol (ACP) server and is a partner on the AP2 and A2A agent-payment standards. The pitch is PayPal-native checkout an agent can drive, against PayPal balances and cards. Caveat: as of 2026 this is being built, so plan around availability rather than assuming it is production-ready today.

The Layer That Decides Whether Money Moves

None of the servers above answer the question that matters for real money: should this specific payment happen? That is a separate layer, and it is worth being precise about where it fits. Ralio is one company building it — and it is not a payment processor. It does not compete with Stripe or Coinbase. It sits over whichever rail you choose as a trust and governance layer: it verifies the agent's identity, enforces per-workflow spend limits, restricts payments to an allowlist of approved payees, and records a full transaction audit trail that ties each payment back to the agent, the prompt, and the policy.

The rail moves the money; this layer decides whether it should. You can also build a slim version yourself — a policy gate the agent must call before any paid action — which is exactly what giving your agent a budget walks through. Either way, the MCP server is the how; the trust layer is the whether. For where Ralio sits among the networks and giants, see the trust layer for agent payments.

How to Choose

Match the tool to what the agent is actually buying.

If it is a card checkout on a person's behalf, Stripe is the mature path. If it is small, frequent, programmatic payments for API access, x402's stablecoin-over-HTTP model or MPP fit better. If it is agents transacting with other agents, Nevermined and MPP are built for that shape. And regardless of rail: if this is company money, add the governance layer — do not let the choice of rail be your whole security model. If you are weighing Stripe specifically against the crypto-native options, the Stripe alternatives for agent payments comparison lines them up head to head.

The One Security Rule You Cannot Skip

An MCP server runs with the permissions of the credential you give it, and your agent can be steered by a hostile instruction hidden in a web page or a tool result. So three things, non-negotiable. Use restricted, scoped API keys — Stripe's restricted keys let you grant only the operations the agent needs — never a full-access secret. Keep the key with the server or a gate, not in the agent's context. And put a guardrail in front of spend: per-transaction and daily caps, a payee allowlist, and a human-approval threshold, enforced outside the agent so even a fully injected agent cannot talk its way past them.

That guardrail plus scoped keys is the difference between a useful tool and a wire transfer waiting to happen. The concrete pattern — gate, rail, audit — is in how to give your agent a budget.

FAQ

Sources

• Stripe Docs: the remote MCP server
• Stripe Docs: building with AI agents
• Stripe Agent Toolkit (Python + TypeScript)
• Stripe: the Machine Payments Protocol (MPP)
• Coinbase: x402 stablecoin payments over HTTP
• WorkOS: x402 vs Stripe MPP for AI agents
• Nevermined: platforms for agentic payments
• Ralio: a trust layer for agentic business payments