Author: Beosin

With the explosive demand for AI Agents and automated clients to autonomously execute tasks, how machines can complete payments without human intervention is becoming an urgent infrastructure issue. Traditional payment interfaces struggle to adapt to high-frequency, dynamic, cross-platform machine-to-machine transaction scenarios.

To address this, Stripe and Tempo have jointly launched an open protocol designed specifically for machine-to-machine payments, the Machine Payments Protocol (MPP), aimed at allowing clients and servers to seamlessly complete price negotiations, payment method selections, credential submissions, and transaction settlements in automation processes. This article will analyze the protocol design and real progress of MPP from three dimensions: the MPP protocol mechanism, comparison with x402, and the current ecosystem status.

MPP Protocol Analysis

MPP borrows from the challenge-response structure familiar to developers in HTTP, embedding payments naturally into the lifecycle of web requests, completing transactions through Stripe's payment channels or blockchain platforms like Tempo. The entire process follows a challenge-response model based on standard HTTP headers:

1. The client sends a standard HTTP request (like GET) to the payment endpoint

2. The server returns a payment challenge: 402 Payment Required and the WWW-Authenticate: Payment header. This header informs the client of the currently supported currencies, prices, receiving addresses, and available payment methods

3. The client selects a payment method and completes the payment (stablecoin transfer, credit card payment, etc.)

4. The client resends the original request, including the payment credential with the Authorization: Payment header

5. The server verifies the payment and returns a response with the Payment-Receipt header

https://mpp.dev/protocol

There are two important concepts throughout the process: payment challenge and payment credential. The payment challenge is the specific payment requirement issued by the server, structured as follows:

WWW-Authenticate: Payment id="qB3wErTyU7iOpAsD9fGhJk",    realm="mpp.dev",    method="tempo",    intent="charge",    expires="2025-01-15T12:05:00Z",    opaque="eyJyb3V0ZSI6Ii92MS9zZWFyY2gifQ",    request="eyJhbW91bnQiOiIxMDAwIiwiY3VycmVuY3kiOiJ1c2QifQ"

The intent parameter is currently divided into three categories: charge, subscription, and session. Taking the Tempo blockchain as an example:

The request parameter is a base64url encoded JSON string, decoded by the client to obtain detailed payment method information, such as

{  "amount": "1000",  "currency": "usd",  "recipient": "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266"}

The payment credential is used to prove that you have paid or authorized the payment, and its content is also a base64url encoded JSON string:

Authorization: Payment eyJjaGFsbGVuZ2UiOnsiaWQiOiJxQjN3RXJUeVU3aU9wQXNEOWZHaEprIiwi...

Decoded content includes the original payment challenge, specific payment method and payment proof, payer identity information (address, DID, account ID)

{  "challenge": {    "expires": "2025-01-15T12:05:00Z",    "id": "qB3wErTyU7iOpAsD9fGhJk",    "intent": "charge",    "method": "tempo",    "opaque": "eyJyb3V0ZSI6Ii92MS9zZWFyY2gifQ",    "realm": "mpp.dev",    "request": "eyJhbW91bnQiOiIxMDAwIi4uLn0",  },  "payload": {    "signature": "0xabc123...",    "type": "transaction"  },  "source": "did:pkh:eip155:4217:0x1234567890abcdef..."}

Using the MPP TypeScript SDK as an example, its specific implementation is as follows:

Server-Side

1. Create a server endpoint to handle payment requests

import crypto from 'crypto';import Stripe from 'stripe';// 'stripe' here is the mppx payment method factory, not the Stripe Node SDKimport { Mppx, stripe as mppStripe, tempo } from 'mppx/server'; // Tempo testnet token contract address for pathUSD (testnet USDC).const PATH_USD = '0x20c0000000000000000000000000000000000000';const mppSecretKey = crypto.randomBytes(32).toString('base64');const stripeClient = new Stripe(process.env.STRIPE_SECRET_KEY!, {  apiVersion: '2026-03-04.preview',}); export async function handler(request: Request) {  const recipientAddress = await createPayToAddress(request);   const mppx = Mppx.create({    methods: [      tempo.charge({        currency: PATH_USD,        recipient: recipientAddress,        testnet: true,      }),      mppStripe.charge({        client: stripeClient,        networkId: process.env.STRIPE_PROFILE_ID!,        paymentMethodTypes: ['card', 'link'],      }),    ],    secretKey: mppSecretKey,  });   const response = await Mppx.compose(    mppx.tempo.charge({ amount: '0.01', recipient: recipientAddress }),    mppx.stripe.charge({ amount: '0.50', currency: 'usd' }),  )(request);   if (response.status === 402) return response.challenge;   return response.withReceipt(Response.json({ data: '...' }));}

2. Create a Payment Intent to receive stablecoin/cryptocurrency payments; when the client initiates the request, createPayToAddress will return a cryptocurrency deposit address, which the client will receive and use for payment.

import Stripe from 'stripe';import { Credential } from 'mppx';import NodeCache from 'node-cache';const paymentCache = new NodeCache({ stdTTL: 300, checkperiod: 60 }); async function createPayToAddress(request: Request): Promise`0x${string}`> {  const authHeader = request.headers.get('authorization');  if (authHeader && Credential.extractPaymentScheme(authHeader)) {    const credential = Credential.fromRequest(request);    const toAddress = credential.challenge.request.recipient as `0x${string}`;     if (!toAddress) {      throw new Error(        'PaymentIntent did not return expected crypto deposit details'      );    }    if (!paymentCache.has(toAddress)) {      throw new Error('Invalid payTo address: not found in server cache');    }    return toAddress;  }   const decimals = 6;  const amountInCents = Number(10000) / 10 ** (decimals - 2);   const paymentIntent = await stripe.paymentIntents.create({    amount: amountInCents,    currency: 'usd',    payment_method_types: ['crypto'],    payment_method_data: {      type: 'crypto',    },    payment_method_options: {      crypto: {        mode: 'deposit',        deposit_options: {          networks: ['tempo'],        },      } as Stripe.PaymentIntentCreateParams.PaymentMethodOptions.Crypto,    },    confirm: true,  });   if (    !paymentIntent.next_action ||    !('crypto_display_details' in paymentIntent.next_action)  ) {    throw new Error(      'PaymentIntent did not return expected crypto deposit details'    );  }   const depositDetails = paymentIntent.next_action    .crypto_display_details as unknown as {    deposit_addresses?: Recordstring, { address?: string }>;  };  const payToAddress = depositDetails.deposit_addresses?.tempo?.address;   if (!payToAddress) {    throw new Error(      'PaymentIntent did not return expected crypto deposit details'    );  }   console.log(    `Created PaymentIntent ${paymentIntent.id} for $${(      amountInCents / 100    ).toFixed(2)} -> ${payToAddress}`  );   paymentCache.set(payToAddress, true);  return payToAddress as `0x${string}`;}

Client-Side

Create a Tempo/other accounts for payment

import { Mppx, tempo } from 'mppx/client'const provider = Provider.create({ mpp: false }) // Avoid double 402 handling; mppx is configured below.await provider.request({ method: 'wallet_connect' })

Based on this, create a payment handler

import { Provider } from 'accounts' Mppx.create({   methods: [tempo({     account: provider.getAccount({ signable: true }),     getClient: provider.getClient,   })], }) 

Use fetch to request resources

const response = await fetch('https://mpp.dev/api/ping/paid')

Differences Between MPP and x402

In May 2025, Coinbase launched the x402 protocol, using 402 Payment Required to implement a stablecoin payment protocol, whose process is very similar to MPP: client requests resource -> server returns HTTP 402 with payment header -> client signs a stablecoin transfer and retries with payment signature -> Facilitator verifies the settlement on-chain -> server returns HTTP 200.

The x402 protocol is groundbreaking for stablecoin payments, being very simple, allowing developers to integrate quickly. However, x402 does not have channels for fiat currency payments, and enterprise-level agents cannot use x402 to pay for various APIs with company credit cards. Stripe fills this gap in fiat currency channels through the MPP protocol, which includes payment methods such as Tempo, EVM, Solana, Stellar, Lightning, Stripe, and credit cards, designed with different payment specifications for various scenarios: Charge, Session, Discovery, JSON-RPC/MCP transport. In summary, x402 is the on-chain stablecoin payment standard for the internet, while MPP is a more general HTTP payment standard:

Current Status of MPP Ecosystem Development

According to the official registry (MPP Service Registry), MPP has recorded 137 services (where one service can belong to multiple categories) and 1439 endpoints. Among them, 128 services only support Tempo payments, 2 services only support Stripe payments, and 7 services support both Tempo and Stripe payments.

*Note: The payment methods supported by the MPP protocol document are not limited to these two; it also supports lightning, evm, card, solana, and others, but this official service registry currently only includes Tempo and Stripe payment services.

From the endpoint perspective, the registry lists 1261 endpoints marked with fixed or dynamic prices, where 1068 are fixed prices, 193 are dynamic prices, while 178 have no explicit price or can be considered free/unpriced. The median of fixed prices is $0.02/request, and the average is about $0.139/request, with the highest fixed price being $20/request for the purchase mobile number endpoint of StablePhone.

In terms of intent usage: 129 services use charge, while 8 services use session. Session services include high-frequency, multiple-call, dynamically variable services like Anthropic, Dune, Google Gemini, Modal, OpenRouter, Alchemy, Conduit, Tempo RPC, while regular data services are more suitable for one request per charge.

In classification, the registered services are distributed towards data and tool APIs consumable by agents:

data source: https://raw.githubusercontent.com/tempoxyz/mpp/main/schemas/services.ts

Third-party data platform MPPscan has recorded over 3700 MPP servers; according to its statistics, the total transaction count of MPP exceeds 1.1 million, with a transaction volume of about $140,000, and an average transaction amount of approximately $0.127.

Due to the x402 protocol being launched about 8 months earlier than the MPP protocol, we only compared the data of the MPP protocol with the x402 protocol over the past 30 days (excluding MPP non-blockchain payment channel data), as shown in the figure below:

The overall adoption scale of the x402 protocol at this stage is significantly higher than that of the MPP protocol. In the past 30 days, the total transaction count of x402 is 10.6 times that of the MPP protocol, and the total transaction amount is 20.2 times that of the latter. In terms of protocol positioning, x402 emphasizes lightweight, open access, and quick integration, making it easier to achieve large transaction scales first; while MPP emphasizes multiple payment methods and the integrity of payment systems, resulting in scale differences with the x402 protocol in the current early stage of ecosystem development and scenario validation.

Conclusion

MPP deeply embeds payment logic into the lifecycle of HTTP requests, reducing the threshold for accessing machine payments through a challenge-response model familiar to developers. Compared to Coinbase’s x402 protocol, MPP offers a more diverse range of payment methods (covering stablecoins, credit cards, Lightning network, etc.) and supports one-time charges, session-level pro-rata settlements, and subscription services in settlement modes. By leveraging Stripe's fiat currency channels and Tempo's on-chain compliance controls, MPP provides a more complete payment framework for enterprise applications of various scales.

In the future, whether MPP can become the universal payment protocol for the AI Agent economy depends on whether more service providers register and actually enable various payment methods. In blockchain payment channel transaction data, x402 is currently significantly ahead. Although MPP provides more robust payment channels through platforms like Tempo and Stripe, its payment scale and developer adoption rate still require time for validation.

免责声明：本文章仅代表作者个人观点，不代表本平台的立场和观点。本文章仅供信息分享，不构成对任何人的任何投资建议。用户与作者之间的任何争议，与本平台无关。如网页中刊载的文章或图片涉及侵权，请提供相关的权利证明和身份证明发送邮件到support@aicoin.com，本平台相关工作人员将会进行核查。