Copied to clipboard
Machine Payments Protocol · Mainnet live March 18, 2026

APIs built for the
machine economy

Token security on 63 chains and AI trading on 24 chains. Pay per request via MPP, the open standard for autonomous agent payments. No accounts. No API keys.

$0.03
Per Token Scan
63+
Chains Scanned
$0.20
Per AI Trade
2
Live Pay Methods
About MPP

Pay per request. No accounts. No API keys.

Both Quick Intel and Tator use the Machine Payments Protocol, an open HTTP 402 standard for autonomous agent payments. Your agent requests a resource, pays the 402 challenge, and gets the result back with a receipt. One round-trip, no checkout flow.

📋
How it works under the hood
MPP is built on HTTP 402 and is on the IETF standards track. The mppx SDK handles the full challenge/credential/receipt flow transparently. You call mppx.fetch() and it deals with the rest. For the full protocol spec visit mpp.dev or read the IETF draft.
Payment Methods

Three ways for agents to pay

MPP is payment-method agnostic. This gateway accepts Tempo stablecoins and Stripe (cards, Link, and stablecoins via Stripe). Bitcoin Lightning is on the roadmap.

Live now
Tempo
method="tempo" · TIP-20 stablecoins · chainId 4217
Pay with USDC or USDT on the Tempo blockchain, a payment-native L1 by Stripe and Paradigm. Sub-second deterministic finality (~0.5s), sub-$0.001 fees, and dedicated payment lanes that never compete with DeFi activity. Two intents available: charge (one-time per request, settled on-chain) and session (pre-fund escrow once, pay with off-chain signed vouchers for near-zero per-request cost and sub-100ms latency, ideal for high-throughput scanning).
USDC · USDTchainId 4217 ~0.5s finality<$0.001 fees charge + sessionTIP-20 native
💳
Live now
Stripe
method="stripe" · Cards via SPTs · Stablecoins via deposit address
Two payment flows via Stripe. Cards and wallets use Shared Payment Tokens (SPTs). Clients register a card or Link wallet once and pay across any MPP service without re-entering details, settling through Stripe's payment rails. Stablecoins go through Stripe's crypto deposit address flow on the Tempo network, with Stripe handling PaymentIntent capture when funds settle on-chain.
Visa · MastercardLink USDC on TempoFiat + crypto Stripe Dashboard
🌩️
Coming soon
Lightning
method="lightning" · BOLT11 invoices · via Lightspark Spark
Pay with Bitcoin over the Lightning Network via Lightspark Spark. The charge intent uses BOLT11 invoices for one-time payments. The session intent enables streaming micropayments over an open channel, ideal for per-token billing or continuous data feeds. Payments settle off-chain with Bitcoin's security model. Sub-cent transactions are possible.
BitcoinBOLT11 Lightspark Sparkcharge + session Sub-cent txs
🔗
Already using x402? Nothing changes.
x402 clients on Base, Ethereum, Arbitrum, Solana and 11 other chains continue working unchanged. Both protocols are accepted simultaneously on all paid endpoints and the gateway auto-detects from request headers.
x402 Gateway →
APIs

Two APIs. Both MPP-enabled.

Pay per request. No account. No key. Your agent pays $0.03 or $0.20, gets results, moves on.

🔍
$0.03MPP + x402
Quick Intel Scanner
Comprehensive smart contract security analysis across 63 blockchains. Detect honeypots, tax manipulation, scam patterns, ownership risks, proxy contracts, and more before your agent trades.
63 chainsHoneypot Tax analysisScam patterns LP locksOwnership
POST/v1/scan/full
Tator
$0.20MPP + x402
Tator AI Trading
Natural language to unsigned transactions across 24 chains. Tator plans the trade, automatically runs a Quick Intel security scan, and returns transactions ready for your wallet to sign and broadcast.
24 chainsSwaps BridgesPerps PredictionsYield
POST/v1/tator/prompt
Documentation

Integrate in minutes

Installation
Install mppx and configure your payment method. Two options are live: Tempo (crypto wallet) and Stripe (cards, Link, or stablecoins via Stripe).
1
Install mppx and viem
Official TypeScript SDK by Tempo Labs and Wevm. Also available as pympp (Python) and mpp (Rust).
Install
bash
npm install mppx viem
Option A: Pay with Tempo (crypto wallet)
Best for agents and on-chain workflows. Pay with USDC directly on the Tempo blockchain. Requires an EVM wallet funded with Tempo USDC.
2
Get a Tempo wallet with USDC
Use the CLI for testnet, or fund a mainnet wallet at wallet.tempo.xyz. Mainnet USDC: 0x20c000000000000000000000b9537d11c60e8b50 on chainId 4217.
Testnet wallet via CLI
bash
# Create and fund a testnet wallet
npx mppx account create
npx mppx account fund

# Mainnet wallet: https://wallet.tempo.xyz
# Mainnet USDC:   0x20c000000000000000000000b9537d11c60e8b50
# Testnet pathUSD:0x20c0000000000000000000000000000000000000
Tempo client
JavaScript
import { Mppx, tempo } from 'mppx/client';
import { privateKeyToAccount } from 'viem/accounts';

const account = privateKeyToAccount(process.env.PRIVATE_KEY);

export const mppx = Mppx.create({
  methods: [tempo({ account })]
});
Option B: Pay with Stripe (cards, Link, or stablecoins)
💳Best for developers without a crypto wallet. Pay with a card or Link via Shared Payment Tokens, or with USDC through Stripe's crypto deposit address flow. No on-chain wallet required for card payments.
Stripe SPT client (cards and Link)
JavaScript
import { Challenge } from 'mppx';
import { loadStripe } from '@stripe/stripe-js';

// 1. Hit the endpoint, get the 402 challenge
const response = await fetch('https://mpp.quickintel.io/v1/scan/full', {
  method: 'POST',
  body: JSON.stringify({ chain: 'base', tokenAddress: '0x...' })
});
const charge = stripe.charge({ createToken: async (params) => {
  const res = await fetch('/api/create-spt', {
    method: 'POST',
    body: JSON.stringify(params)
  });
  return (await res.json()).spt;
}});
const challenge = Challenge.fromResponse(response, { methods: [charge] });

// 2. Collect card details with Stripe Elements, create PaymentMethod
const stripeClient = await loadStripe(process.env.STRIPE_PUBLISHABLE_KEY);
const { paymentMethod } = await stripeClient.createPaymentMethod({ elements });

// 3. Create credential and retry with payment
const credential = await charge.createCredential({
  challenge,
  context: { paymentMethod: paymentMethod.id }
});
const paid = await fetch('https://mpp.quickintel.io/v1/scan/full', {
  method: 'POST',
  headers: { 'Authorization': credential },
  body: JSON.stringify({ chain: 'base', tokenAddress: '0x...' })
});
ℹ️For full Stripe MPP integration details including PaymentIntent setup, sandbox testing, and live mode configuration see the Stripe MPP docs.
💡How mppx.fetch() works: For Tempo payments, mppx.fetch() handles the full 402 challenge cycle automatically. For Stripe card payments the SPT flow requires Stripe Elements to collect card details, so you handle credentials manually as shown above.
Quick test via CLI (Tempo)
bash
# Full end-to-end payment test
npx mppx post https://mpp.quickintel.io/v1/scan/full \
  --body '{"chain":"base","tokenAddress":"0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"}'
Token Security Scan API
Full smart contract security audit. 63 blockchains. Returns honeypot detection, tax analysis, ownership status, scam patterns, proxy detection, and more.
$0.03 per scan. 63 chains including Ethereum, Base, BSC, Solana, Sui, Tron, Avalanche, and all major EVM L2s. Payment auto-handled by mppx.
Basic scan
JavaScript
import { mppx } from './client.js';

const res = await mppx.fetch(
  'https://mpp.quickintel.io/v1/scan/full',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      chain: 'base',
      tokenAddress: '0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913'
    })
  }
);

const scan = await res.json();
console.log(scan.tokenDynamicDetails.is_Honeypot); // false
Production guard pattern
JavaScript
async function safeToTrade(chain, tokenAddress) {
  const scan = await (
    await mppx.fetch('https://mpp.quickintel.io/v1/scan/full', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ chain, tokenAddress })
    })
  ).json();

  if (scan.tokenDynamicDetails.is_Honeypot)
    throw new Error('Honeypot detected');

  if (scan.isScam === true)
    throw new Error('Known scam token');

  const sellTax = parseFloat(scan.tokenDynamicDetails.sell_Tax);
  if (sellTax > 5) console.warn(`High sell tax: ${sellTax}%`);

  return scan;
}
Request Body
FieldTypeRequiredDescription
chainstringrequired"eth", "base", "bsc", "sol", "sui", "trx", "arb", "op", and 55 more
tokenAddressstringrequiredEVM: 0x-hex. Solana: base58. Sui: full object ID.
Key Response Fields
FieldTypeDescription
tokenDynamicDetails.is_HoneypotbooleanTrue = cannot be sold
tokenDynamicDetails.buy_TaxstringBuy tax % e.g. "5.0"
tokenDynamicDetails.sell_TaxstringSell tax %
isScamboolean|nullTrue = known scam. null = unknown.
contractVerifiedbooleanSource verified on block explorer
quickiAudit.contract_RenouncedbooleanOwnership renounced
quickiAudit.can_MintbooleanCan mint new supply
quickiAudit.can_BlacklistbooleanCan blacklist wallets
quickiAudit.is_ProxybooleanUpgradeable proxy contract
quickiAudit.has_ScamsbooleanMatches known scam patterns
Tator AI Trading API
Natural language to unsigned transactions. Tator plans the trade, auto-scans for security, and returns transaction data your wallet signs and broadcasts.
$0.20 per request. Includes automatic Quick Intel security scan at no extra cost. 24 chains. Sync and async modes.
Sync trade
JavaScript
const res = await mppx.fetch(
  'https://mpp.quickintel.io/v1/tator/prompt',
  {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      prompt: 'Swap 0.1 ETH to USDC on Base',
      walletAddress: '0xYourAgentWallet',
      provider: 'my-agent'
    })
  }
);

const { transactions } = await res.json();

// Sign and broadcast, you keep full custody
for (const tx of transactions) {
  const hash = await wallet.sendTransaction(tx);
}
Async mode: bridges and complex ops
JavaScript
// async: true returns jobId immediately, poll for result
const { jobId } = await (
  await mppx.fetch('https://mpp.quickintel.io/v1/tator/prompt', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      prompt: 'Bridge 500 USDC from Base to Arbitrum',
      walletAddress: '0xYourAgentWallet',
      provider: 'my-agent',
      async: true
    })
  })
).json();

// Poll for result (FREE, no payment required)
let job;
do {
  await new Promise(r => setTimeout(r, 2000));
  job = await (await fetch(
    `https://mpp.quickintel.io/v1/tator/jobs/${jobId}`
  )).json();
} while (job.status === 'pending');
Request Body
FieldTypeRequiredDescription
promptstringrequired"swap 0.1 ETH to USDC on Base", "buy PEPE with 100 USDC", "bridge ETH to Arbitrum"
walletAddressstringrequiredEVM or Solana wallet that will sign and broadcast returned transactions
providerstringrequiredYour agent identifier e.g. "my-agent", "openclaw"
asyncbooleanoptionalDefault false. True → returns jobId to poll at /v1/tator/jobs/:jobId (free)
chainstringoptional"base", "ethereum", "solana", etc. Tator infers if omitted.
slippagenumberoptionalSlippage tolerance %. Default 1.
All Endpoints
Complete reference for every route on the gateway.
POST/v1/scan/full
Token security scan. Body: { chain, tokenAddress }. Payment via MPP or x402. Returns full security analysis.
POST/v1/tator/prompt
AI trade execution. Body: { prompt, walletAddress, provider }. Returns unsigned transactions. Includes auto security scan.
GET/v1/tator/jobs/:jobIdFREE
Poll async job status. Returns { status: "pending"|"complete"|"error", result }.
GET/v1/tator/healthFREE
Tator backend health check.
GET/healthFREE
Gateway health. Returns backend status, Redis, active networks, x402 and MPP config.
GET/openapi.jsonFREE
OpenAPI 3.1 discovery with x-payment-info. Used by MPPScan and AgentCash.
GET/.well-known/x402FREE
x402 discovery document. Resources, ownership proofs, instructions for x402 indexers.
GET/acceptedFREE
Agent discovery. Full route list with networks, pricing, schemas, and protocol flags.
Error Handling
mppx handles all payment errors automatically. Handle API-level errors from the gateway itself.
ℹ️mppx absorbs 402 responses. mppx.fetch() intercepts, pays, and retries. You only receive 200 or non-payment errors. If payment fails (e.g. insufficient USDC), mppx throws with an error message.
Recommended error pattern
JavaScript
try {
  const res = await mppx.fetch('...', options);
  if (!res.ok) {
    const err = await res.json();
    throw new Error(`${res.status}: ${err.message}`);
  }
  return await res.json();
} catch (err) {
  if (err.message.includes('insufficient')) {
    // Fund wallet: https://wallet.tempo.xyz
  }
  throw err;
}
HTTP Status Codes
StatusMeaningAction
200SuccessParse response body
400Bad requestCheck required fields
402Payment required (auto-handled)mppx retries automatically
502Backend unavailableRetry with backoff, check /health
503Backend not configuredContact support
MPP Error Types (in 402 body)
Type suffixDescription
/payment-requiredStandard challenge, resource requires payment
/payment-insufficientAmount sent is too low
/payment-expiredChallenge expired (5-minute window)
/verification-failedCredential signature invalid
/invalid-challengeChallenge ID unknown, expired, or already used
/malformed-credentialAuthorization header malformed
x402 Compatibility
Already on x402? Everything continues to work exactly as before. MPP is additive, a new payment lane, not a replacement.
Zero breaking changes. x402 clients on Base, Ethereum, Arbitrum, Solana and 11 other chains are fully unaffected. Protocol is auto-detected from request headers.
🔀Auto-detection: Authorization: Payment routes to MPP. X-PAYMENT or PAYMENT-SIGNATURE routes to x402. No header on mpp.quickintel.io issues an MPP challenge. No header on x402.quickintel.io issues an x402 challenge.
x402 client (unchanged)
JavaScript
import { x402Fetch } from '@x402/fetch';
// Fully unchanged
const res = await x402Fetch(
  'https://x402.quickintel.io/v1/scan/full',
  { method: 'POST', body: JSON.stringify({...}), wallet }
);
MPP client (new)
JavaScript
import { Mppx, tempo } from 'mppx/client';
const mppx = Mppx.create({ methods: [tempo({ account })] });
const res = await mppx.fetch(
  'https://mpp.quickintel.io/v1/scan/full',
  { method: 'POST', body: JSON.stringify({...}) }
);
Protocol Comparison
x402MPP
Payment headerX-PAYMENT · PAYMENT-SIGNATUREAuthorization: Payment
Challenge headerPAYMENT-REQUIREDWWW-Authenticate: Payment
Receipt headerPAYMENT-RESPONSEPayment-Receipt
SettlementBase, ETH, ARB, SOL + 11 moreTempo (chainId 4217)
Idempotencypayment-identifier extensionBuilt-in (challengeId)
Replay protectionRedis nonce trackingBuilt-in single-use semantics
SDK@x402/fetchmppx
Agent Discovery

Machine-readable endpoints

Point any agent, discovery tool, or MPPScan indexer at these endpoints to find and invoke this API automatically.