The Model Context Protocol is the upstream tool-discovery layer that almost every agentic commerce protocol now sits on top of. Anthropic open-sourced MCP on November 25, 2024, then donated it to the Linux Foundation's Agentic AI Foundation on December 9, 2025, co-founded with Block and OpenAI. By the donation date the spec already had 10,000+ active public servers, 75+ Claude connectors built on it, and 97 million monthly SDK downloads across Python and TypeScript. That scale is the precondition for what came next: x402 returns HTTP 402 inside MCP tool calls; OpenAI's ACP, Google's UCP, and Google's AP2 all assume MCP is the data plane underneath. MCP itself never moves a dollar. It is the wire format that lets an agent ask "what tools do you have," "what does this one cost," and "let me call it" in a way every payment protocol can compose against. This guide covers the JSON-RPC 2.0 mechanics, the tools-resources-prompts model, the production payment integrations (Stripe, Coinbase, Akeneo, Block, Cloudflare), and the composition patterns that pair MCP with each commerce protocol.
​

MCP is an open standard, introduced by Anthropic in November 2024, that defines how AI applications connect to external data sources, tools, and prompts. MCP is not a payment protocol. It is the discovery and invocation layer that every agentic commerce protocol now uses to find and call tools across hosts.
​

MCP defines a JSON-RPC 2.0 message exchange between an MCP host (the AI application like Claude Desktop, VS Code, or ChatGPT), one or more MCP clients (one per server), and MCP servers (the programs providing context). The host instantiates a fresh client for each server it talks to, and each client maintains a dedicated connection. The official architecture overview at modelcontextprotocol.io describes the participants, the two-layer structure, and the JSON-RPC handshake in detail.
​

Anthropic open-sourced MCP under MIT-style terms on November 25, 2024 with launch partners Block and Apollo on the application side and Zed, Replit, Codeium, and Sourcegraph on the developer-tools side. The reference SDKs shipped in Python and TypeScript at github.com/modelcontextprotocol, alongside reference servers for Google Drive, Slack, GitHub, Git, Postgres, and Puppeteer. The current specification version, dated 2025-11-25, lives at modelcontextprotocol.io/specification/2025-11-25 and adds asynchronous operations, statelessness affordances, and server-identity primitives.
​

The protocol was donated to the Linux Foundation's Agentic AI Foundation on December 9, 2025, as a directed fund stewarded by the LF. Anthropic, Block, and OpenAI co-founded AAIF. Google, Microsoft, AWS, Cloudflare, and Bloomberg signed on as supporting members. Maintainer composition and governance stayed unchanged through the transition; the donation moved the spec out of any single vendor's hands and into a neutral foundation, which mattered for the larger commerce protocols (UCP, ACP, AP2) that depend on MCP being a stable, vendor-neutral substrate.
​

By the time of the donation MCP had reached scale numbers most protocols never see. The announcement post cites 10,000+ active public MCP servers, 75+ connectors inside Claude built on the protocol, and 97 million monthly SDK downloads across Python and TypeScript. OpenAI adopted MCP across its products in March 2025, Microsoft made it generally available in Copilot Studio in May 2025, and AWS expanded support across Bedrock, Connect, and the Knowledge MCP server through late 2025. By April 2026 every major model provider and most major SaaS platforms either ship or consume MCP servers in production.
​

MCP runs as a stateful JSON-RPC 2.0 protocol with two layers: a data layer for message schema and primitives, and a transport layer for underlying channels. Servers expose three primitives — tools, resources, and prompts — discovered via list methods and invoked via call or read. Transports are stdio for local processes and Streamable HTTP for remote.
​

The data layer carries the protocol's semantics. Every connection begins with an initialize request from client to server, including a protocolVersion field (e.g., "2025-06-18"), a capabilities object, and a clientInfo block. The server replies with its own capabilities and serverInfo. The client then sends notifications/initialized. Capability negotiation matters because both sides advertise which primitives they support and whether they emit notifications when state changes. The full handshake is documented at modelcontextprotocol.io with sample JSON-RPC payloads.
​

Three primitives anchor what servers can offer. Tools are executable functions the agent can invoke (think create_payment_intent, list_products, refund_charge). Each tool exposes a JSON Schema describing its inputs. The client lists tools with tools/list and invokes them with tools/call. Resources are read-only data sources (file contents, database rows, API responses), discovered via resources/list and read via resources/read. Prompts are parameterized templates that structure interactions with the host's language model. Each primitive type has discovery methods, retrieval methods, and in the case of tools, an execution method.
​

Clients can also expose primitives that servers consume. Sampling lets a server request an LLM completion from the host without shipping its own model SDK. Elicitation lets a server ask the user for additional input or confirmation through the host's UI. Logging lets a server emit log messages back to the client. These reverse primitives are what make MCP interactive rather than purely declarative — a payment-MCP server can ask "is the user okay paying $4.99 for this?" and the host will surface that prompt in the chat thread.
​

The transport layer carries those JSON-RPC messages over one of two channels. Stdio uses standard input and output for local processes on the same machine, with no network overhead — Claude Desktop launches local MCP servers this way. Streamable HTTP uses HTTP POST for client-to-server messages and optional Server-Sent Events for streaming, which is what remote MCP servers like mcp.stripe.com use. The HTTP path supports standard authentication, with OAuth recommended for remote servers because it gives more granular permissions than bearer tokens or API keys.
​

Notifications close the loop. When a server's tool list changes — a new tool ships, an existing one is deprecated — the server can emit notifications/tools/list_changed. Clients that registered "listChanged": true during initialization respond by re-fetching the list. This event-driven design is what lets agentic commerce protocols layer on top safely: a merchant's MCP server can add a new payment-tied tool at runtime and the agent picks it up without restarting.
​

For a payments-aware MCP server, the three primitives map naturally. Tools are the side effects: create_payment_intent, send_invoice, create_refund, list_charges. Resources are read-only context the agent needs to act safely: customer records, product catalogs, balance, recent transactions. Prompts are templates that wrap recurring conversations — a "find a discount code for this customer" prompt, a "draft a refund email" prompt. Stripe's MCP server, documented at docs.stripe.com/mcp, exposes ~25 tools across 13 resource categories under exactly this shape.
​

Every major agentic commerce protocol launched after MCP either runs over MCP or assumes MCP-discovered tools as input. x402 returns 402 inside MCP tool calls. OpenAI's ACP, Google's UCP, and Google's AP2 all assume catalogs are discovered via MCP. MCP solved tool discovery first under a vendor-neutral foundation — a precondition payment protocols need.
​

The pattern is visible in the public timeline. Anthropic launched MCP in November 2024. By March 2025, OpenAI had adopted it. Microsoft Copilot Studio went GA in May 2025. AWS rolled support through late 2025. By the time the first commerce-specific protocols started shipping in late 2025 — Visa TAP on October 14, 2025, OpenAI's ACP on September 29, 2025, x402 in May 2025 — MCP was already the default tool layer. None of those commerce protocols wanted to re-litigate tool discovery. Each composed against MCP instead.
​

The Linux Foundation donation cemented that role. Hosting MCP under a neutral foundation, separate from any one vendor, removed the implicit risk that Anthropic could change the spec for competitive reasons. Block and OpenAI co-founding AAIF specifically signals that two of MCP's biggest commercial users wanted seats at the governance table. As the official donation announcement notes, "the project's maintainers will continue to prioritize community input and transparent decision-making" — language designed to reassure the protocol layer above.
​

The result is a clean split of concerns. MCP carries discovery and invocation. Payment protocols carry settlement, authorization, identity. Each layer evolves on its own cadence. When OpenAI retired ChatGPT Instant Checkout in March 2026 and replaced it with retailer apps, the underlying MCP plumbing did not change. When Coinbase launched Agent.market in April 2026 with 165 million transactions and roughly $50 million in cumulative x402 volume, the agents using it still discovered services through MCP. The composition pattern protects each protocol from the others' churn.
​

One concrete advantage MCP gives payment protocols: capability negotiation. Because every MCP connection negotiates capabilities up front, a merchant's server can advertise "I accept x402 micropayments" or "I accept ACP Shared Payment Tokens" or "I accept AP2 mandates" as part of its declared capabilities. The agent picks the path it can satisfy and proceeds. No prior bilateral integration required. This is what makes MCP genuinely upstream — every commerce protocol benefits from MCP's pre-existing handshake rather than rebuilding one.
​

Five named MCP servers are in production for payments today: Stripe's remote MCP server at mcp.stripe.com, Coinbase's x402 MCP example plus AgentKit MCP extension, Block's MCP integrations, Cloudflare's Agents SDK + MCP, and Akeneo's PIM-side MCP server. Each composes MCP with one or more commerce protocols rather than reinventing the data plane.
​

Stripe MCP server. Stripe operates a remote MCP server at mcp.stripe.com, authenticated via OAuth, accessible from Cursor, VS Code, Claude Code, ChatGPT (Pro, Plus, Business, Enterprise, Education tiers), Windsurf, Claude Desktop, and any other MCP-compatible host. The server exposes around 25 tools spanning account, balance, customer, product, price, invoice, payment intent, refund, subscription, dispute, coupon, and payment link operations, plus search and fetch helpers for the Stripe knowledge base. The Stripe MCP server was first released on February 20, 2025; v0.3.3 is current as of Stripe Sessions on April 29-30, 2026, with the latest tool catalog refresh dated April 23, 2026 per the Stripe MCP documentation. The MCP server lives in the same stripe/ai monorepo as the Agent Toolkit (framework integrations for OpenAI, LangChain, CrewAI, Vercel AI SDK), the AI SDK, and Stripe's token-meter package.
​

Coinbase x402 MCP server example. Coinbase ships an official x402 MCP example at github.com/coinbase/x402/examples/typescript/mcp. The server paywalls its MCP tools with HTTP 402: when a client calls tools/call, the server returns 402 with a PAYMENT-REQUIRED envelope describing the chain (CAIP-2), the asset contract (typically USDC on Base), the amount, and the recipient. The client signs an EIP-3009 transferWithAuthorization payload, retries the call with a PAYMENT-SIGNATURE header, the server's facilitator verifies and submits onchain, and the tool result returns once settlement confirms. This is the canonical "MCP + x402" composition that Cloudflare's x402 blog post describes as the production pattern.
​

Coinbase AgentKit MCP extension. The npm package @coinbase/agentkit-model-context-protocol turns AgentKit's onchain actions — wallet creation, USDC transfers, swaps, smart-contract calls — into MCP tools that any host can invoke. Documentation lives at docs.cdp.coinbase.com/agent-kit. The extension means an MCP host that supports the AgentKit MCP package gets onchain payment capability as a discoverable tool, with the same capability-negotiation pattern as any other MCP server.
​

Block. Block was a launch partner for MCP in November 2024 and a co-founder of AAIF in December 2025. Block CTO Dhanji R. Prasanna's quote in the Anthropic launch announcement called open technologies like MCP "the bridges that connect AI to real-world applications." Block's commerce, payments, and seller-tools surfaces (Square, Cash App, Bitkey) all consume and expose MCP servers across internal agent fleets. The AAIF co-founder seat reflects how central MCP is to Block's agent strategy.
​

Cloudflare Agents SDK + MCP. Cloudflare ships native MCP support inside its Agents SDK, including a remote MCP server template, a Streamable HTTP transport implementation, and a deferred-payment x402 facilitator that batches sub-cent payments and settles on a separate cadence. Cloudflare's pitch is that an MCP server running on Cloudflare Workers gets x402 paywalls as a one-line middleware. Cloudflare added x402 support to its Agents SDK on September 23, 2025, the same day the x402 Foundation was announced; the SDK itself first shipped in February 2025.
​

Akeneo MCP server. Akeneo, the product information management (PIM) vendor, launched a native MCP server as part of its Winter Release on January 12, 2026. The Akeneo MCP server functions as the governance layer for product intelligence: agents read product catalogs as MCP resources and propose updates as MCP tool calls, with Akeneo's data-quality rules enforced server-side. On February 18, 2026, Akeneo announced a partnership with Stripe to integrate the Stripe Agentic Commerce Suite alongside the MCP server, so a single brand can expose its catalog over MCP and accept agentic-commerce payments through Stripe's ACP rail in one integration. The pattern — MCP for catalog discovery, ACP for checkout — is the cleanest live example of layered composition.
​

Around these five anchors, dozens of payment-relevant MCP servers ship from PayPal, Shopify (four official servers), and a long tail of fintech and SaaS vendors. The Shopify MCP server roster spans storefront, admin, agent, and partner surfaces, with Universal Commerce Protocol announced by Google at NRF 2026 on January 11, 2026 — built jointly with Shopify, Walmart, Target, Etsy, and Wayfair — specifically as the transaction layer that composes on top of MCP.
​

MCP is the data plane every payment protocol composes against. x402 returns 402 inside MCP tool calls for stablecoin micropayments; ACP passes Shared Payment Tokens through MCP arguments; UCP wraps MCP discovery with a checkout journey; AP2 attaches user-signed mandates to tool calls. The four protocols rarely substitute for each other.
​

The clearest way to see the composition is a side-by-side. The table below maps each protocol against the role MCP plays in its flow, the layer that protocol occupies, and what production deployment looks like as of April 2026.

Read across the rows and a pattern emerges: every commerce protocol has an answer to "what does MCP do here?" and that answer is never "nothing." The protocols are not alternatives to MCP. They are payloads on top of it.
​

MCP + x402. The simplest composition. An MCP server paywalls one or more of its tools by returning HTTP 402 over Streamable HTTP transport. The MCP client, holding a wallet (Circle Wallet, Coinbase Smart Wallet, MPC-backed agent wallet), signs an EIP-3009 or Permit2 authorization and retries. Best for sub-dollar machine-to-machine payments where there is no human in the loop. Coinbase's reference example is the working version. x402 protocol mechanics live in the dedicated explainer.
​

MCP + ACP. The agent uses MCP to discover the merchant's catalog and checkout tool. The buyer's wallet provider mints a Stripe Shared Payment Token scoped to the merchant + amount. The agent passes the token as an argument inside tools/call. The merchant's MCP server forwards the token to its Stripe account, which processes the card payment. The buyer's card never reaches the agent. Best for retail purchases on the OpenAI surface, the Stripe-issued buyer surfaces, or any host where the user's wallet provider supports SPT minting. The Akeneo + Stripe partnership announced February 18, 2026 is the cleanest live example.
​

MCP + UCP. UCP runs as a journey: capability profile discovery, checkout call, post-purchase events. MCP carries the capability profile lookup and the tool catalog the agent uses to assemble a basket. UCP's checkout endpoint is itself reachable as an MCP tool. AP2 chains in for the payment-authorization step. The Google UCP under-the-hood writeup documents how the MCP layer feeds UCP's broader journey.
​

MCP + AP2. AP2 is the user-consent layer, not a payment rail itself. The agent presents the user with a payment proposal. The user's wallet or identity provider signs an AP2 mandate carrying the merchant ID, amount, expiry, and unique mandate ID. The mandate flows through the MCP tools/call as an argument. The merchant verifies the signature server-side and runs whatever payment rail the mandate authorizes. AP2 is the most useful when the merchant requires non-repudiation — a cryptographic receipt of consent — rather than just an SPT.
​

None of these compositions exist as substitutes for one another. A typical agent stack uses MCP for tool discovery, then either x402 for stablecoin micropayments to APIs, or ACP / UCP / AP2 for retail checkout. The agent payment protocols comparison covers the full matrix, including Visa TAP and A2A which sit alongside rather than on top of MCP.
​

MCP defines how an agent talks to a server. The payment protocol on top of MCP defines what kind of payment instrument moves. Neither layer specifies which chain the dollars settle on. When an agent uses an MCP server to discover an x402-paywalled tool and the merchant's treasury sits on a chain different from the agent's wallet, the cross-chain step is its own engineering problem. Eco operates as the stablecoin execution network across 15 chains that closes that gap, abstracting routing, solver selection, and finality so that an agent paying USDC on Base can transact with a counterparty whose treasury sits on Solana, Arbitrum, or Tron without holding liquidity on every chain. For teams composing MCP with x402 or any other stablecoin-settled commerce protocol, Eco handles the cross-chain orchestration that the commerce protocol itself does not. The same logic applies to agentic payments and Stripe Link agents + x402 — protocols define the agent-to-server conversation, orchestration networks define where the money lives.
​

Sources and methodology. MCP launch and donation details verified against the Anthropic launch post and December 9, 2025 AAIF donation announcement. Architecture details from the official MCP architecture overview and current spec (2025-11-25). Stripe MCP details from docs.stripe.com/mcp. Stablecoin supply figures pulled from DeFiLlama on April 29, 2026. Figures refresh quarterly.
​