# Machine Payments Protocol \[The open protocol for internet-native payments] The Machine Payments Protocol (MPP) lets you accept payments from any client— agents, apps, or humans—using standard HTTP control flows. Clients pay inline with their request, and you receive payment confirmation before delivering the response. MPP is built around a simple extensible core and is designed to be neutral to the implementation of underlying payment flows and methods. * **Open standard built for the internet**—Built on an [open specification proposed to the IETF](https://tempoxyz.github.io/mpp-specs/), not a proprietary API * **Designed for payments**—Idempotency, security, and receipts are first-class primitives * **Multi rail**—Stablecoins, cards, bank transfers, and digital wallets. All payment methods can be supported through one protocol and flexible control flow * **Multi currency**—The protocol is currency agnostic, allowing for transactions in USD, EUR, BRL, USDC, BTC, or any other asset * **Composable and designed for extension**—A flexible core allows advanced flows like disputes or additional primitives like identity to be gradually introduced ## The problem with payments on the internet There is no shortage of ways to pay for things on the internet. Hundreds of payment methods give users ample space for personal preference, and optimized payment forms with one-click checkout ensure that the act of paying is low-friction and highly secure. However, the very things that make these payment flows familiar and fast for human purchasers are structural headwinds for programmatic consumption. Many have tried, but it is a consistent uphill battle to fight browser automation pipelines, visual captchas, and ever changing payment forms—all of which reduce reliability, increase latency, and bear high costs. This is not the fault of any individual payment method or credential. This is a global problem which exists at the *interface* level: how buyer and seller negotiate cost, supported payment methods, and ultimately transact. The Machine Payments Protocol addresses this gap by providing an internet-native payment interface that strips away the complexity of rich checkout flows, while still providing robust security and reliability. By using MPP, you can accept payments from any client — agents, apps, or humans — and across any payment method, without the need for a complex checkout flows and integrations. ## Try it out This documentation site is itself an MPP server. Create an account, fund it with testnet tokens, and make a paid request to see the full flow in action. ## Use cases * **Paid APIs**—Accept payments inline without requiring API keys, billing accounts, or manual signup. Clients pay per request. * **MCP servers**—Monetize tool calls served through the Model Context Protocol (MCP). Clients pay autonomously without complicated OAuth or account setup. * **Digital content**—Monetize articles, data, or media without subscription paywalls. Charge per access or per query. ## Payment flow When a client requests a paid resource, the server returns a `402` response with the payment options they support. The client chooses a payment method, fulfills the request and retries with a payment `Credential` which contains proof of payment. The server verifies the payment and returns the resource with a `Receipt` which contains proof of delivery. ## Official SDKs MPP comes with a suite of official SDKs maintained by [Tempo Labs](https://tempo.xyz) and [Wevm](https://wevm.dev). The SDKs offer high-level abstractions and low-level primitives to implement and extend the Machine Payments Protocol. ## Next steps