<!-- tempo-docs-context -->
> Source: [/docs/guide/machine-payments/pay-as-you-go](https://tempo.com/developers/docs/guide/machine-payments/pay-as-you-go.md)
> Section: [Machine Payments](https://tempo.com/developers/docs/agents.md). Pay for APIs, accept API payments, find services, and use MPP (https://mpp.dev).
> [Documentation index](https://tempo.com/developers/llms.txt) · [Docs skill](https://tempo.com/developers/SKILL.md)

> Tempo MCP: Use `search`, `find_pages`, `read_page`, and `code` at `https://mcp.tempo.xyz` for Tempo and related documentation.
> If an indexed page is missing or reflects an older site, read this site’s [documentation index](https://tempo.com/developers/llms.txt) and Markdown pages directly.

# Accept pay-as-you-go payments

Use pay-as-you-go sessions when a customer should pay a small amount each time they use an API or service, without sending an on-chain transaction for every request.

The example is a photo API: the client opens one `mppx` session, then pays $0.01 each time it asks for a photo. `mppx` is the library that manages the MPP session; [Picsum](https://github.com/DMarby/picsum-photos) only supplies sample images for the demo.

:::info
Unlike [one-time payments](https://tempo.com/developers/docs/guide/machine-payments/one-time-payments), a session opens a payment channel once. Each later request is paid with a signed voucher that the server verifies off-chain.
:::

## How pay-as-you-go sessions work

```mermaid
sequenceDiagram
  participant Client
  participant Server
  participant Tempo
  Client->>Tempo: (1) Deposit tokens
  Tempo-->>Client: Channel created
  Client->>Server: (2) Open credential
  Note over Server: Verify on-chain deposit
  Server-->>Client: 200 OK (session established)
  loop Per request
      Client->>Server: (3) Request + voucher
      Note over Server: Verify voucher signature and amount
      Server-->>Client: 200 OK + Receipt
  end
  Note over Server: (4) Periodic settlement
  Server->>Tempo: settle(channelId, voucher)
  Client->>Server: (5) Close
  Server->>Tempo: close(channelId, voucher)
  Tempo-->>Client: Refund remaining deposit
```

1. **Open** — Client deposits funds into an on-chain reserve contract, creating a payment channel
2. **Session** — Client signs vouchers with increasing cumulative amounts as service is consumed
3. **Top up** — If the channel runs low, the client deposits additional tokens without closing the channel
4. **Close** — Either party closes the channel, settling the final balance on-chain and refunding unused deposit

:::info[T7 payment-channel savings]
The [T7 network upgrade](https://tempo.com/developers/docs/protocol/upgrades/t7) can make repeated sessions cheaper for the same payer. When a payer closes or withdraws a finished channel, Tempo records a channel storage credit for that payer. If the same payer opens another channel later, Tempo can use that payer's credit. Other payers cannot use it.
:::

The channel-reserve gas snapshot for the credited reopen path is:

| Channel reserve snapshot | T7 gas |
|--------------------------|-------:|
| `open_new_channel_with_storage_credit` | 60,225 |

This is a call-level gas number and excludes separate approval gas. It matters most for session services where the same payer opens, closes or withdraws, and later opens channels again.

## Pay-as-you-go server setup

::::steps
### Install pay-as-you-go dependencies

:::code-group
```bash [npm]
npm install mppx viem
```

```bash [pnpm]
pnpm add mppx viem
```

```bash [bun]
bun add mppx viem
```
:::

### Set up an `Mppx` session instance

[Set `MPP_SECRET_KEY`](https://tempo.com/developers/docs/guide/machine-payments/server#set-the-server-secret) before starting the server.

Set up an `Mppx` instance with the `tempo` method.

* `recipient` is the address where you receive payments.
* `currency` is the token address for payments (in this case, `OUSD`).

```ts
import { Mppx, tempo } from 'mppx/server'

const mppx = Mppx.create({
  methods: [tempo({
    currency: '0x20c0000000000000000000006a37da5c996874be',
    recipient: '0xa726a1CD723409074DF9108A2187cfA19899aCF8',
  })],
})
```

#### Use prepaid credits

You can accept recipient-restricted TIP-20 tokens, such as prepaid service credits, using the same session setup:

* Set `currency` to your credit token's address.
* Set `recipient` to your service's payment address, which must be permitted by the token's transfer policy.
* Ensure the customer holds enough credits to fund the session and is permitted to send them.

The issuer does not need to allowlist the channel reserve. Funding and settlement check the token's transfer policy against the customer and your service. When the channel closes, unused credits return to the customer and remain subject to the token's spending restrictions.

Token pauses and account receive policies still apply. No additional session configuration is required.

See [Configure stablecoin transfer policies](https://tempo.com/developers/docs/guide/issuance/manage-stablecoin#configure-stablecoin-transfer-policies) for token-policy configuration.

### Add a pay-as-you-go route

Add payment verification using `mppx.session` as route middleware. The handler only runs after payment is verified.

:::code-group
```ts [Next.js]
import { Mppx, tempo } from 'mppx/nextjs'

const mppx = Mppx.create({
  methods: [tempo({
    currency: '0x20c0000000000000000000006a37da5c996874be',
    recipient: '0xa726a1CD723409074DF9108A2187cfA19899aCF8',
  })],
})

export const GET =
  mppx.session({ amount: '0.01', unitType: 'photo' })
  (async () => {
    const res = await fetch('https://picsum.photos/200/200')
    return Response.json({ url: res.url })
  })
```

```ts [Hono]
import { Hono } from 'hono'
import { Mppx, tempo } from 'mppx/hono'

const app = new Hono()

const mppx = Mppx.create({
  methods: [tempo({
    currency: '0x20c0000000000000000000006a37da5c996874be',
    recipient: '0xa726a1CD723409074DF9108A2187cfA19899aCF8',
  })],
})

app.get(
  '/api/sessions/photo',
  mppx.session({ amount: '0.01', unitType: 'photo' }),
  async (c) => {
    const res = await fetch('https://picsum.photos/200/200')
    return c.json({ url: res.url })
  },
)
```

```ts [Express]
import express from 'express'
import { Mppx, tempo } from 'mppx/express'

const app = express()

const mppx = Mppx.create({
  methods: [tempo({
    currency: '0x20c0000000000000000000006a37da5c996874be',
    recipient: '0xa726a1CD723409074DF9108A2187cfA19899aCF8',
  })],
})

app.get(
  '/api/sessions/photo',
  mppx.session({ amount: '0.01', unitType: 'photo' }),
  async (req, res) => {
    const response = await fetch('https://picsum.photos/200/200')
    res.json({ url: response.url })
  },
)
```

```ts [Fetch API]
import { Mppx, tempo } from 'mppx/server'

const mppx = Mppx.create({
  methods: [tempo({
    currency: '0x20c0000000000000000000006a37da5c996874be',
    recipient: '0xa726a1CD723409074DF9108A2187cfA19899aCF8',
  })],
})

Bun.serve({
  async fetch(request) {
    const result = await mppx.session({
      amount: '0.01',
      unitType: 'photo',
    })(request)

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

    const res = await fetch('https://picsum.photos/200/200')
    return result.withReceipt(Response.json({ url: res.url }))
  },
})
```
:::

### Test the pay-as-you-go endpoint

These examples charge mainnet OUSD. Configure the `mppx` CLI with a funded mainnet account before calling the endpoint; testnet faucet tokens cannot pay a mainnet challenge. To use test funds, [configure the server and client for Moderato](https://tempo.com/developers/docs/guide/machine-payments/server#test-your-mpp-server).

```bash
npx mppx http://localhost:3000/api/sessions/photo
```
::::

## Pay-as-you-go client setup

When using sessions from a client, set `maxDeposit` to enable automatic channel management. This is the maximum amount of tokens the client locks into the payment channel's reserve contract. Any unspent deposit is refunded when the channel closes.

```ts
import { Mppx, tempo } from 'mppx/client'
import { Account } from 'viem/tempo'

const mppx = Mppx.create({
  methods: [tempo({
    account: Account.fromSecp256k1('0x...'),
    maxDeposit: '1', // Lock up to 1 OUSD per channel
  })],
})

// Mppx.create wraps global fetch by default:
// Each fetch handles session payments:
// 1st request: opens channel on-chain, sends initial voucher
// 2nd+ requests: sends off-chain vouchers (no on-chain tx)
const res = await fetch('http://localhost:3000/api/sessions/photo')
```

* **`maxDeposit: '1'`** — Locks up to 1 OUSD into the payment channel. At $0.01/photo, this covers up to 100 requests before the channel runs out.
* The client opens channels, signs vouchers, and retries `402` responses. Channels do not close automatically; use the [session manager and call `close()`](https://tempo.com/developers/docs/guide/machine-payments/streamed-payments#streamed-payment-client-setup) to release unused funds.
* If the server sets `suggestedDeposit`, the client uses `min(suggestedDeposit, maxDeposit)`.

## Next steps for pay-as-you-go payments

[Accept streamed payments](https://tempo.com/developers/docs/guide/machine-payments/streamed-payments): Per-token billing over Server-Sent Events

[Accept payments for an API](https://tempo.com/developers/docs/guide/machine-payments/server): Framework middleware reference

[Full session reference](https://mpp.dev/payment-methods/tempo/session): Complete tempo.session API documentation
