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 September 2026 public trackers put the ecosystem at roughly 15,000-20,000 active public MCP servers across major registries and over 97 million monthly SDK downloads across Python and TypeScript, per Digital Applied's registry analysis. 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, including where real usage has landed versus where it was projected to land.
​

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 Architecture (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, alongside reference servers for Google Drive, Slack, GitHub, Git, Postgres, and Puppeteer. The protocol keeps shipping dated spec revisions; the official roadmap notes a 2026-07-28 release that made remote MCP server support a first-class part of the spec, on top of the async-operations and server-identity work added earlier in 2026.
​

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.
​

Counting MCP servers precisely is harder than the early headline numbers suggested, because registries overlap and count differently. Digital Applied's May 2026 pull of the official MCP Registry API counted 9,652 latest server records, excluding private enterprise servers and every npm/PyPI package merely named "MCP." Aggregating across the four major public directories put the count closer to 15,930 by August 2026, and MCP.so and Glama.ai independently list over 20,000 and 23,000 servers respectively, per Nordic APIs. By September 2026 every major model provider and most major SaaS platforms either ship or consume MCP servers in production, even as the exact count depends on which registry is doing the counting.
​

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 Architecture (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 whether the user is okay paying a stated amount for a tool call, 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 Stripe (docs), exposes this shape through a smaller set of general-purpose tools rather than one narrow tool per API method, described below.
​

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 settlement activity on x402 itself swung sharply through 2026, discussed below, the agents that used MCP to discover those paywalled tools did not need any change to their MCP integration. 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 Stripe (mcp), currently in public preview and authenticated via OAuth or API key, accessible from Cursor, VS Code, Claude Code, ChatGPT, Windsurf, Claude Desktop, and any other MCP-compatible host. Rather than one narrow tool per API method, the server now consolidates around a smaller set of general-purpose tools per the current Stripe MCP documentation: stripe_api_search and stripe_api_details for discovering methods, stripe_api_read and stripe_api_write for calling any Stripe GET or write method without a 1:1 tool per endpoint, plus get_stripe_account_info, stripe_analytics (Sigma-backed natural-language reporting), get_balance_summary for Treasury, and search_stripe_documentation. Stripe requires human confirmation before sensitive stripe_api_write actions such as refunds; the agent presents an approval URL and the human has 24 hours to approve. The consolidated-tool design keeps the MCP context window small while covering the full API surface, a deliberate shift from earlier per-endpoint catalogs. The server lives alongside Stripe's agent plugins and Agent Skills, installable via stripe agent setup.
​

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, and it is also the pattern Cloudflare's Monetization Gateway generalizes at the network edge, covered below.
​

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 and a Streamable HTTP transport implementation. On July 1, 2026, Cloudflare opened the waitlist for its Monetization Gateway, which extends its earlier Pay Per Crawl product to let any Cloudflare customer charge any caller, human, agent, or script, for a web page, dataset, API, or MCP tool, with the charge metered and enforced at Cloudflare's network edge across 330+ cities and settled in stablecoins over x402. The pitch is that a server operator gets x402 paywalls on MCP tools without building payment infrastructure itself. The Defiant's coverage frames it as the piece that turns x402 from a protocol demo into something publishers can flip on.
​

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 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 the 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, and their real-world usage has diverged sharply from early projections, x402 in particular.
​

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 usage actually looks like as of September 2026, not what was projected earlier in the year.

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." But the x402 row also shows why MCP's role as a neutral discovery layer matters more than any single protocol's traction: the composition pattern lets an agent stack keep working even when one payload protocol's real-world usage swings hard in either direction.
​

MCP + x402. The simplest composition, and the one with the clearest public usage data. 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. That data now tells an uneven story: settlement activity tracked by agenteconomy.to shows roughly 188 million cumulative x402 transactions and $41.8 million in cumulative settled volume across 12 chains as of September 21, 2026, with Base the largest chain at over 85 million transactions. But the trend inside that total matters more: daily settlement volume peaked near $800,000-$1 million during Q4 2025, then fell roughly 93% year-to-date by August 2026 to a seven-day average near $41,800 per day, per analyst Jamie Coutts citing Helios Analytics data in reporting from CCN via Yahoo Finance. The read is that the late-2025 surge was largely developers testing the rail, not agents buying services at production scale. Cloudflare's July 2026 Monetization Gateway, which puts x402 paywalls in front of any page, API, or MCP tool at the network edge, is the infrastructure bet most likely to convert that testing activity into sustained demand, but as of September 2026 it remains early. Best fit today: sub-dollar machine-to-machine payments where there is no human in the loop and the counterparty tolerates thin, still-maturing settlement infrastructure. 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 uneven x402 trajectory is a reminder to evaluate each payload protocol's actual usage separately rather than assuming "built on MCP" implies production traction. 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 roadmap. Server-count estimates from Digital Applied and Nordic APIs. Stripe MCP tool catalog verified against the live Stripe MCP documentation as of September 2026. x402 settlement figures from agenteconomy.to's public on-chain tracker and Helios Analytics data reported by CCN via Yahoo Finance. Cloudflare Monetization Gateway details from the official Cloudflare announcement. Figures refresh quarterly.
​