Accepting Stripe's Machine Payments Protocol (MPP) in Your MCP Server

curl https://api.stripe.com/v2/network/business_profiles/me \
  -u sk_test_BQokikJOvBiI2HlWgH4olfQ2: \
  -H "Stripe-Version: 2026-07-29.preview"

npm install @hono/node-server @modelcontextprotocol/sdk hono mppx stripe zod

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
import {
  WebStandardStreamableHTTPServerTransport,
} from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js'
import { z } from 'zod'
import { getItem, validatePurchase } from './catalog.js'

function createMcpServer(): McpServer {
  const server = new McpServer({
    name: 'your-mcp-server',
    version: '1.0.0',
  })

  server.registerTool(
    'create_purchase_link',
    {
      description:
        'Returns a payment link for a one-time purchase. ' +
        'POST to the link with an MPP credential to pay automatically, ' +
        'or open it in a browser to preview the browser checkout fallback.',
      inputSchema: {
        itemId: z.string(),
        quantity: z.number().int().positive(),
        customerName: z.string(),
        customerEmail: z.string(),
      },
    },
    async ({ itemId, quantity, customerName, customerEmail }) => {
      const params = new URLSearchParams({
        itemId,
        quantity: String(quantity),
        customerName,
        customerEmail,
      })
      const paymentLink = `${process.env.BASE_URL}/api/purchase?${params}`

      const item = getItem(itemId)
      if (!item) throw new Error('Item not found')
      if (!validatePurchase({ item, quantity, customerName, customerEmail })) {
        throw new Error('Invalid purchase request')
      }

      return {
        content: [{
          type: 'text',
          text: JSON.stringify({
            // This link must be MPP enabled
            paymentLink,
            instructions: {
              agent: `POST to paymentLink. Server returns 402 on first call — use link-cli to obtain an SPT for networkId "${process.env.STRIPE_PROFILE_ID}" and retry.`,
              browser: 'Open paymentLink in a browser to view the checkout page.',
            },
            item: {
              title: item.title,
              quantity,
              price: `${(item.priceCents / 100).toFixed(2)} USD`,
            },
          }, null, 2),
        }],
      }
    },
  )

  return server
}

export async function handleMcpRequest(request: Request): Promise<Response> {
  const server = createMcpServer()
  const transport = new WebStandardStreamableHTTPServerTransport({
    sessionIdGenerator: undefined,
    enableJsonResponse: true,
  })

  await server.connect(transport)
  try {
    return await transport.handleRequest(request)
  } finally {
    await server.close()
  }
}

import crypto from 'crypto'
import StripeClient from 'stripe'
import { serve } from '@hono/node-server'
import { Hono } from 'hono'
import { Mppx, stripe } from 'mppx/server'
import { completeOrder, getItem, validatePurchase } from './catalog.js'
import { handleMcpRequest } from './mcp.js'

if (!process.env.STRIPE_SECRET_KEY) {
  throw new Error('STRIPE_SECRET_KEY environment variable is required')
}
if (!process.env.STRIPE_PROFILE_ID) {
  throw new Error('STRIPE_PROFILE_ID environment variable is required')
}
if (!process.env.BASE_URL) {
  throw new Error('BASE_URL environment variable is required')
}

// Secret used to secure payment challenges
// https://mpp.dev/protocol/challenges#challenge-binding
const mppSecretKey = crypto
  .createHmac('sha256', process.env.STRIPE_SECRET_KEY)
  .update('mpp-challenge-signing')
  .digest('base64')

const stripeClient = new StripeClient(process.env.STRIPE_SECRET_KEY)

const stripeMachinePayments = stripe.create({
  client: stripeClient,
  networkId: process.env.STRIPE_PROFILE_ID,
  livemode: !process.env.STRIPE_SECRET_KEY.includes('_test_'),
})

const mppx = Mppx.create({
  methods: [stripeMachinePayments.spt.charge()],
  secretKey: mppSecretKey,
})

async function handler(request: Request): Promise<Response> {
  const url = new URL(request.url)
  const params = url.searchParams

  // Browser redirect — replace with your real checkout flow
  const accept = request.headers.get('Accept') ?? ''
  if (accept.includes('text/html')) {
    return Response.redirect(new URL(
      `/checkout/${params.get('itemId')}?${params}`,
      process.env.BASE_URL,
    ))
  }

  // Agent/programmatic path — MPP 402-challenge flow
  const item = getItem(params.get('itemId'))
  if (!item) return Response.json({ error: 'Not found' }, { status: 404 })
  const quantity = Number(params.get('quantity'))
  const customerName = params.get('customerName')
  const customerEmail = params.get('customerEmail')
  const purchase = { item, quantity, customerName, customerEmail }
  if (!validatePurchase(purchase)) {
    return Response.json({ error: 'Invalid purchase request' }, { status: 400 })
  }

  const result = await mppx.compose([
    'stripe/charge',
    {
      amount: ((purchase.item.priceCents * purchase.quantity) / 100).toFixed(2),
      currency: 'usd',
      decimals: 2,
      description: purchase.item.title,
    },
  ])(request)

  if (result.status === 402) return result.challenge

  // Payment confirmed — run your business logic
  const order = completeOrder(purchase)
  return result.withReceipt(Response.json({ success: true, orderId: order.id }))
}

const app = new Hono()
app.post('/mcp', (context) => handleMcpRequest(context.req.raw))
app.on(['GET', 'POST'], '/api/purchase', (context) => handler(context.req.raw))
app.get('/checkout/:itemId', (context) =>
  context.text('Replace this route with the browser checkout flow for your application.'),
)

serve({ fetch: app.fetch, port: Number(process.env.PORT ?? 4242) })

curl https://api.stripe.com/v1/crypto/deposit_addresses \
  -u sk_test_BQokikJOvBiI2HlWgH4olfQ2: \
  -H "Stripe-Version: 2026-07-29.preview" \
  -d network=tempo

const stripeMachinePayments = stripe.create({
  client: stripeClient,
  networkId: process.env.STRIPE_PROFILE_ID,
  livemode: !process.env.STRIPE_SECRET_KEY.includes('_test_'),
  depositAddresses: {
    tempo: process.env.TEMPO_DEPOSIT_ADDRESS!,
  },
});

const stripeMachinePayments = stripe.create({
  client: stripeClient,
  networkId: process.env.STRIPE_PROFILE_ID,
  livemode: true,
  hostedFeePayer: true,
  depositAddresses: {
    tempo: process.env.TEMPO_DEPOSIT_ADDRESS!,
  },
});

npx mppx@latest validate 

npx tsx --env-file=/absolute/path/to/.env /absolute/path/to/server.ts

npx skills add stripe/link-cli

Use the `create_purchase_link` tool from the paid-catalog MCP to purchase one
item with the ID `coffee` for a customer named `Alice` with the email
`test@example.com`. This flow uses test mode, so it doesn't move real funds.