# Tempo charge \[One-time TIP-20 token transfers] The Tempo implementation of the [charge](/intents/charge) intent. For non-zero charges, the client signs a TIP-20 `transfer` transaction, the server broadcasts it to Tempo, and settlement completes in ~500ms with deterministic finality. For zero-amount identity flows, the client sends a `proof` Credential payload instead of a real transaction. The server verifies the signed proof message against the client's `source` identity and returns a Receipt without broadcasting anything on-chain. This method is best for single API calls, content access, or one-off purchases. ## Server Use [`mppx.charge`](/sdk/typescript/server/Method.tempo.charge) to gate any endpoint behind a one-time payment. The method handles Challenge generation, Credential verification, transaction broadcast for paid requests, and Receipt creation. ```ts twoslash import { Mppx, tempo } from "mppx/server"; const mppx = Mppx.create({ methods: [tempo()], }); export async function handler(request: Request) { const result = await mppx.charge({ amount: "0.1", currency: "0x20c0000000000000000000000000000000000000", recipient: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", })(request); if (result.status === 402) return result.challenge; return result.withReceipt(Response.json({ data: "..." })); } ``` ### With expiry ```ts twoslash import { Mppx, tempo } from "mppx/server"; const mppx = Mppx.create({ methods: [tempo()] }); // ---cut--- import { Expires } from "mppx"; export async function handler(request: Request) { const result = await mppx.charge({ amount: "0.1", currency: "0x20c0000000000000000000000000000000000000", expires: Expires.minutes(10), // [!code hl] recipient: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", })(request); if (result.status === 402) return result.challenge; return result.withReceipt(Response.json({ data: "..." })); } ``` ### With fee sponsorship ```ts twoslash import { Mppx, tempo } from "mppx/server"; const mppx = Mppx.create({ methods: [tempo()] }); declare const request: Request; // ---cut--- const result = await mppx.charge({ amount: "0.1", currency: "0x20c0000000000000000000000000000000000000", feePayer: true, // [!code hl] recipient: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", })(request); ``` When `feePayer` is `true`, the server adds a fee payer signature (domain `0x78`) before broadcasting. The client doesn't need gas tokens. See [fee sponsorship](/payment-methods/tempo#fee-sponsorship) for details. ### Zero-dollar auth Set `amount: "0"` to issue an identity-only Challenge. The client returns a `proof` payload instead of `transaction` or `hash`, and the server verifies the signature against the `source` DID. ```ts twoslash import { Mppx, tempo } from "mppx/server"; const mppx = Mppx.create({ methods: [tempo()] }); declare const request: Request; // ---cut--- const result = await mppx.charge({ amount: "0", // [!code hl] currency: "0x20c0000000000000000000000000000000000000", recipient: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", })(request); ``` Use this for polling, free follow-up requests, and unlock flows after an initial payment. ### With split payments Split a charge across multiple recipients in a single transaction. The primary `recipient` receives `amount` minus the sum of all splits. ```ts twoslash import { Mppx, tempo } from "mppx/server"; const mppx = Mppx.create({ methods: [tempo()] }); declare const request: Request; // ---cut--- const result = await mppx.charge({ amount: "1.00", currency: "0x20c0000000000000000000000000000000000000", // pathUSD recipient: "0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266", // seller splits: [ // [!code hl] { // [!code hl] amount: "0.10", // [!code hl] recipient: "0x70997970C51812dc3A010C7d01b50e0d17dc79C8", // platform fee // [!code hl] }, // [!code hl] ], // [!code hl] })(request); ``` Up to 10 splits per charge. Each split must have a positive amount, and the sum of all splits must be less than the total `amount`. See the [split payments guide](/guides/split-payments) for more details. ### With Stripe ```ts twoslash // @noErrors import { Mppx, tempo } from "mppx/server"; function async createPayToAddress(request: Request) { // Create Stripe PaymentIntent } export async function handler(request: Request) { const recipientAddress = await createPayToAddress(request) const mppx = Mppx.create({ methods: [ tempo.charge({ currency: "0x20c0000000000000000000000000000000000000", recipient: recipientAddress, }), ], }); const result = await mppx.charge({ amount: "0.01" })(request); if (result.status === 402) return result.challenge; return result.withReceipt(Response.json({ data: "..." })); } ``` Use Stripe to create a dynamic recipient address per payment, each backed by a PaymentIntent. To learn more, read the [Stripe documentation](https://docs.stripe.com/payments/machine/mpp) on accepting MPP. :::info See [`tempo.charge` server reference](/sdk/typescript/server/Method.tempo.charge) for the full parameter list. ::: ## Client Use [`tempo.charge`](/sdk/typescript/client/Method.tempo.charge) with `Mppx.create` to automatically handle `402` responses. For non-zero amounts, the client signs a TIP-20 transfer and retries with the Credential. For zero-amount Challenges, it signs a proof message and retries with a `proof` payload instead. ```ts twoslash import { Mppx, tempo } from "mppx/client"; import { privateKeyToAccount } from "viem/accounts"; const account = privateKeyToAccount("0xabc…123"); Mppx.create({ methods: [tempo.charge({ account })], }); const response = await fetch("https://api.example.com/resource"); ``` ### Without polyfill If you don't want to patch `globalThis.fetch`, use `mppx.fetch` directly: ```ts twoslash import { Mppx, tempo } from "mppx/client"; import { privateKeyToAccount } from "viem/accounts"; const account = privateKeyToAccount("0xabc…123"); const mppx = Mppx.create({ methods: [tempo.charge({ account })], polyfill: false, }); const response = await mppx.fetch("https://api.example.com/resource"); ``` :::info See [`tempo.charge` client reference](/sdk/typescript/client/Method.tempo.charge) for the full parameter list. ::: ### Auto-swap When the client doesn't hold the requested currency, `autoSwap` automatically swaps from a fallback stablecoin (pathUSD, USDC.e) via the Tempo DEX before transferring. ```ts twoslash import { Mppx, tempo } from "mppx/client"; import { privateKeyToAccount } from "viem/accounts"; const account = privateKeyToAccount("0xabc…123"); Mppx.create({ methods: [ tempo.charge({ account, autoSwap: true, // [!code hl] }), ], }); ``` Pass an object for custom fallback tokens or slippage: ```ts twoslash import { Mppx, tempo } from "mppx/client"; import { privateKeyToAccount } from "viem/accounts"; const account = privateKeyToAccount("0xabc…123"); Mppx.create({ methods: [ tempo.charge({ account, autoSwap: { // [!code hl] slippage: 2, // max slippage % (default: 1) // [!code hl] tokenIn: ["0x0000000000000000000000000000000000000001"], // [!code hl] }, // [!code hl] }), ], }); ``` See [auto-swap](/payment-methods/tempo#auto-swap) for more details. ## Specification