MPP Session Payments

The Machine Payment Protocol (MPP) enables session-based micropayments on the Tempo blockchain. Unlike x402 where each API call is a separate payment, MPP opens a session with a deposit budget — your agent makes multiple requests against that budget, and the session settles when done. This guide walks through the full session lifecycle: pre-authorize, open, charge, close, and track.

Prerequisites

MPP vs x402

	x402	MPP
Payment model	Pay-per-request	Session with deposit
Best for	Occasional API calls	Streaming, multi-request workflows
Chain	Base (USDC), Tempo (pathUSD)	Tempo (pathUSD)
Settlement	Immediate per call	On session close
Unused funds	N/A	Returned to agent

Use x402 when each API call is independent. Use MPP when your agent will make many requests to the same service in a session (e.g., streaming data, iterative processing, chat APIs).

How MPP Works

Pre-authorize  →  Open session (deposit)  →  Make requests  →  Close session  →  Settle

Step	What happens
1	Agent calls an MPP-enabled service, gets a 402 challenge
2	Agent pre-authorizes the session deposit through Conto policies
3	Agent opens a session with a deposit budget
4	Agent makes requests — each consumes part of the deposit
5	Session closes — unused deposit is returned
6	Agent records the final settled amount in Conto

Step 1: Set Up MPP Policies

Create the policy

Go to Policies → New Policy.

Field	Value
Name	MPP Session Guardrails
Policy Type	MPP_CONTROLS

Add rules

Rule 1: Cap session deposit

Field	Value
Rule Type	MPP_SESSION_BUDGET
Operator	LTE
Value	25
Action	ALLOW

No single session can have a deposit greater than $25.Rule 2: Cap per-request charge

Field	Value
Rule Type	MPP_MAX_PER_REQUEST
Operator	LTE
Value	1.00
Action	ALLOW

No individual request within a session can charge more than $1.00.Rule 3: Limit concurrent sessions

Field	Value
Rule Type	MPP_MAX_CONCURRENT_SESSIONS
Operator	LTE
Value	3
Action	ALLOW

Agent can have at most 3 open sessions at once.

Assign to agent

Go to the agent’s Permissions tab and assign the policy.

Step 2: Pre-Authorize the Session

When your agent needs to open an MPP session, first check policies:

curl -X POST https://conto.finance/api/sdk/mpp/pre-authorize \
  -H "Authorization: Bearer $CONTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "amount": 10.00,
    "recipientAddress": "0xServiceAddress",
    "resourceUrl": "https://api.service.com/stream",
    "serviceDomain": "api.service.com",
    "intent": "session",
    "depositAmount": 10.00
  }'

If Authorized

{
  "authorized": true,
  "wallet": {
    "id": "wal_123",
    "address": "0xAgentWallet",
    "chainId": "4217",
    "availableBalance": 500.00
  },
  "reasons": ["Within MPP session budget", "Service domain allowed"]
}

Proceed to open the session with the MPP-enabled service.

If Denied

{
  "authorized": false,
  "reasons": ["MPP session deposit $10 exceeds budget cap $5"],
  "violations": [
    {
      "type": "MPP_SESSION_BUDGET",
      "limit": 5.00,
      "current": 10.00,
      "message": "Session deposit exceeds MPP budget"
    }
  ]
}

The agent should either request a smaller session or escalate.

Step 3: Open the Session

After Conto authorizes, open the MPP session with the service. The session deposit is locked on-chain:

// Using Sponge MCP or your MPP client
const session = await mppClient.openSession({
  serviceUrl: 'https://api.service.com/stream',
  maxDeposit: '10.00',
  walletAddress: auth.wallet.address,
});

console.log('Session ID:', session.sessionId);
// Session ID: mpp_session_xyz

The deposit ($10 in this case) is committed. The agent can now make requests up to this amount.

Step 4: Make Requests

Each request to the MPP service consumes part of the deposit:

// Request 1: $0.50 charge
const result1 = await mppClient.request({
  sessionId: session.sessionId,
  url: 'https://api.service.com/stream/query',
  body: { query: 'market analysis for AAPL' },
});
// Remaining deposit: $9.50

// Request 2: $0.75 charge
const result2 = await mppClient.request({
  sessionId: session.sessionId,
  url: 'https://api.service.com/stream/summarize',
  body: { text: result1.data },
});
// Remaining deposit: $8.75

The service tracks charges against the session deposit. No additional on-chain transactions happen during the session — settlement occurs on close.

Step 5: Close and Settle

When your agent is done, close the session. Unused deposit is returned:

const settlement = await mppClient.closeSession({
  sessionId: session.sessionId,
});

console.log('Total charged:', settlement.totalCharged);  // $1.25
console.log('Returned:', settlement.returned);            // $8.75
console.log('TX Hash:', settlement.transactionHash);

Session Summary	Amount
Initial deposit	$10.00
Total charged	$1.25
Returned to agent	$8.75

Step 6: Record in Conto

Record the settled amount so Conto can track spending:

curl -X POST https://conto.finance/api/sdk/mpp/record \
  -H "Authorization: Bearer $CONTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "amount": 1.25,
    "recipientAddress": "0xServiceAddress",
    "transactionHash": "0xsettlement123...",
    "resourceUrl": "https://api.service.com/stream",
    "serviceDomain": "api.service.com",
    "sessionId": "mpp_session_xyz",
    "scheme": "mpp",
    "walletId": "wal_123",
    "chainId": "4217"
  }'

Record the settled amount (

1.25), not the deposit amount (

10.00). The settled amount is what was actually charged. Recording the deposit would overcount spending against your budgets.

Step 7: Monitor Spending

Check MPP Budget

curl https://conto.finance/api/sdk/mpp/budget \
  -H "Authorization: Bearer $CONTO_API_KEY"

View MPP Services

curl https://conto.finance/api/sdk/mpp/services \
  -H "Authorization: Bearer $CONTO_API_KEY"

Dashboard

Go to Analytics to see MPP-specific metrics: session frequency, average session cost, per-service breakdown, and deposit utilization (how much of each deposit is actually used).

Full Integration Example

Complete TypeScript flow for an MPP session:

import { Conto } from '@conto/sdk';

const conto = new Conto({ apiKey: process.env.CONTO_API_KEY });

async function runMppSession(serviceUrl: string, queries: string[]) {
  const serviceDomain = new URL(serviceUrl).hostname;

  // 1. Pre-authorize with Conto
  const auth = await conto.mpp.preAuthorize({
    amount: 10.00,
    recipientAddress: '0xServiceAddress',
    resourceUrl: serviceUrl,
    serviceDomain,
    intent: 'session',
    depositAmount: 10.00,
  });

  if (!auth.authorized) {
    throw new Error(`MPP denied: ${auth.reasons.join(', ')}`);
  }

  // 2. Open session
  const session = await mppClient.openSession({
    serviceUrl,
    maxDeposit: '10.00',
  });

  // 3. Make requests
  const results = [];
  for (const query of queries) {
    const result = await mppClient.request({
      sessionId: session.sessionId,
      url: `${serviceUrl}/query`,
      body: { query },
    });
    results.push(result.data);
  }

  // 4. Close and settle
  const settlement = await mppClient.closeSession({
    sessionId: session.sessionId,
  });

  // 5. Record in Conto
  await conto.mpp.record({
    amount: settlement.totalCharged,
    recipientAddress: '0xServiceAddress',
    transactionHash: settlement.transactionHash,
    resourceUrl: serviceUrl,
    serviceDomain,
    sessionId: session.sessionId,
    scheme: 'mpp',
    walletId: auth.wallet.id,
    chainId: auth.wallet.chainId,
  });

  return { results, cost: settlement.totalCharged };
}

MPP Policy Reference

All available MPP-specific policy rules:

Rule Type	What It Controls
`MPP_MAX_PER_REQUEST`	Max charge per individual request in a session
`MPP_PRICE_CEILING`	Hard ceiling on any MPP payment
`MPP_MAX_PER_ENDPOINT`	Budget per specific endpoint
`MPP_MAX_PER_SERVICE`	Budget per service domain
`MPP_SESSION_BUDGET`	Maximum deposit per session
`MPP_MAX_SESSION_DEPOSIT`	Hard cap on session deposit
`MPP_MAX_CONCURRENT_SESSIONS`	Max open sessions at once
`MPP_MAX_SESSION_DURATION`	Maximum session length
`MPP_ALLOWED_SERVICES`	Allowlist of service domains
`MPP_BLOCKED_SERVICES`	Blocklist of service domains

See Advanced Policies for value formats and operators.

Troubleshooting

Pre-authorize denied — 'exceeds concurrent session limit'

Your agent has too many open sessions. Close existing sessions before opening new ones, or increase the MPP_MAX_CONCURRENT_SESSIONS limit in your policy.

Session deposit higher than wallet balance

The deposit is locked on-chain when the session opens. If your wallet has

15 and you try to open a

20 session, it fails. Check your wallet balance and request a smaller deposit.

Settled amount doesn't match expected charges

The service determines final settlement. If charges seem wrong, check the session details with the service provider. Conto records whatever you report — make sure you’re recording the settlement amount from the close response.

MPP only works on Tempo — can I use it on Base?

MPP is currently supported only on the Tempo blockchain (chain ID 4217). For paid APIs on Base or Ethereum, use the x402 protocol instead.

Next Steps

x402 Payments

Per-request API payments on Base and Tempo

MPP SDK Reference

Full API reference for MPP endpoints

Advanced Policies

All MPP policy rule types and value formats

Recipes

Copy-paste MPP recipes

Get Started

Quick Start

CLI

SDK

MCP Server

Policies

Integrations

Guides

MPP Session Payments

MPP Session Payments

Prerequisites

MPP vs x402

How MPP Works

Step 1: Set Up MPP Policies

Step 2: Pre-Authorize the Session

If Authorized

If Denied

Step 3: Open the Session

Step 4: Make Requests

Step 5: Close and Settle

Step 6: Record in Conto

Step 7: Monitor Spending

Check MPP Budget

View MPP Services

Dashboard

Full Integration Example

MPP Policy Reference

Troubleshooting

Next Steps

x402 Payments

MPP SDK Reference

Advanced Policies

Recipes

Get Started

Quick Start

CLI

SDK

MCP Server

Policies

Integrations

Guides

​MPP Session Payments

​Prerequisites

​MPP vs x402

​How MPP Works

​Step 1: Set Up MPP Policies

​Step 2: Pre-Authorize the Session

​If Authorized

​If Denied

​Step 3: Open the Session

​Step 4: Make Requests

​Step 5: Close and Settle

​Step 6: Record in Conto

​Step 7: Monitor Spending

​Check MPP Budget

​View MPP Services

​Dashboard

​Full Integration Example

​MPP Policy Reference

​Troubleshooting

​Next Steps

x402 Payments

MPP SDK Reference

Advanced Policies

Recipes

MPP Session Payments

Prerequisites

MPP vs x402

How MPP Works

Step 1: Set Up MPP Policies

Step 2: Pre-Authorize the Session

If Authorized

If Denied

Step 3: Open the Session

Step 4: Make Requests

Step 5: Close and Settle

Step 6: Record in Conto

Step 7: Monitor Spending

Check MPP Budget

View MPP Services

Dashboard

Full Integration Example

MPP Policy Reference

Troubleshooting

Next Steps