Leestijd: 14 min

Overzicht

Met het Machine Payments Protocol (MPP) kun je voor API-toegang betalen via een HTTP-verzoek. Geen accounts, geen API-sleutels. Alleen een wallet met een saldo in stablecoins.

Sessies gaan nog een stap verder. Je opent één keer een betalingskanaal en hergebruikt dit vervolgens voor elk verzoek. Elke aanroep wordt betaald met een kleine, ondertekende voucher, zodat er niet telkens een transactie op de blockchain plaatsvindt en verzoeken snel blijven verlopen.

In deze handleiding ga je een TypeScript-script maken waarmee je één MPP-sessie opent, de saldi van native tokens op 15 EVM-ketens opvraagt via de MPP-eindpunten van Quicknode, en een opgemaakt rapport met een kostenoverzicht genereert.

Dit is ideaal voor sessies, omdat het script tijdens één uitvoering meerdere RPC-aanroepen over verschillende netwerken heen verricht. In plaats van voor elke aanroep afzonderlijk te betalen, lopen alle verzoeken via één betalingskanaal. Je betaalt de opstartkosten één keer en kunt deze vervolgens voor de rest hergebruiken.

Quicknode ondersteunt MPP-sessies op alle ondersteunde blockchains. Met dezelfde sessie waarmee je query’s uitvoert op Ethereum, kun je ook query’s uitvoeren op Base, Arbitrum, Polygon en andere blockchains, zonder dat daarvoor extra instellingen nodig zijn.

Gratis pakket

Elke wallet krijgt een gedeeld gratis quotum van 1.000.000 API-credits per maand voor alle agentgebaseerde betaalplatforms van Quicknode, waaronder MPP en x402. Standaard RPC-verzoeken kosten elk 1 API-credit, terwijl SQL Explorer het aantal API-credits verbruikt dat door de query wordt gebruikt.

MPP is een van de twee agentgebaseerde betalingsprotocollen op Quicknode

Quicknode ondersteunt twee op wallets gebaseerde betalingsprotocollen voor RPC-toegang zonder account: MPP (gebruikt in deze handleiding) en x402 (een open standaard van Coinbase). Met beide kunnen scripts en AI-agenten API-aanroepen direct betalen, zonder dat er een account of API-sleutels nodig zijn, maar ze verschillen qua gegevensformaat, sessiemechanismen en ondersteunde betaalmethoden. Zie het overzicht van Agentic Payments voor een vergelijking naast elkaar, of ga naar de x402-documentatie en de MPP-documentatie voor details over de protocollen.

Wat je gaat leren

• Hoe het Machine Payments Protocol werkt en waarom er sessies bestaan
• De volledige levenscyclus van een sessie: 402-uitdaging, storting via het kanaal, ondertekening van de voucher en afwikkeling
• Hoe gebruik je de mppx SDK voor het aanmaken en beheren van betalingssessies
• Hoe je in één sessie meerdere RPC-aanroepen kunt doen over verschillende ketens heen met behulp van de MPP-eindpunten van Quicknode

Wat je nodig hebt

• Node.js v20 of hoger
• Basiskennis van TypeScript en EVM-ketens
• Er is geen Quicknode-account of API-sleutels nodig (MPP regelt de toegang en de facturering)
• Een kleine hoeveelheid PathUSD op het Tempo-testnet (automatisch gefinancierd via de faucet in het script) of PathUSD/USDC.e op het Tempo-mainnet voor productiegebruik

Wat is het Machine Payments Protocol?

Het Machine Payments Protocol is een open standaard die bij de IETF is voorgesteld en waarmee inline-betalingen aan elk HTTP-eindpunt kunnen worden toegevoegd. Het is ontworpen om een specifiek probleem op te lossen: programmatische clients (agenten, scripts, bots) hebben geen goede manier om voor API-toegang te betalen zonder dat een mens eerst de facturering heeft ingesteld.

Traditionele betalingsstromen zijn gebaseerd op afrekenformulieren, browsersessies en visuele CAPTCHA’s. MPP vervangt deze door een machinaal leesbare betalingsonderhandeling die is gebaseerd op HTTP 402 Betaling vereist.

Hoe het werkt

Het protocol volgt een challenge-response-patroon:

1. Verzoek: De klant stuurt een normaal HTTP-verzoek naar een betaald eindpunt.
2. Uitdaging: De server antwoordt met 402 Betaling vereist en een WWW-Authenticate: Betaling koptekst met informatie over de prijs, de geaccepteerde valuta’s en de beschikbare betaalmethoden.
3. Betaling: De klant kiest een betaalmethode en voert deze uit (ondertekent een stablecoin-overdracht, opent een betalingskanaal, enz.).
4. Opnieuw proberen: De client verstuurt het oorspronkelijke verzoek opnieuw met een Autorisatie: Betaling koptekst met het betalingsbewijs.
5. Leveren: De server controleert de betaling en stuurt een antwoord terug met een Betalingsbewijs koptekst.

Clientbibliotheken zoals mppx stappen 2 tot en met 4 worden automatisch afgehandeld. Vanuit het perspectief van je code werkt het verzoek gewoon.

Kosten versus sessie

MPP definieer twee betalingsintenties die bepalen hoe de facturering werkt:

	Lading	Sessie
Patroon	Eenmalige betaling per aanvraag	Pay-as-you-go via een betalingskanaal
Afwikkeling	On-chain-transactie per verzoek	Off-chain-vouchers, afwikkeling op de blockchain alleen bij opening/sluiting
Verificatietijdvertraging	Honderden milliseconden (on-chain)	Microseconden (CPU-gebonden ecrecover)
Het meest geschikt voor	Incidentele vragen, eenvoudige integraties	Veelvoorkomende verzoeken, batch-workflows, agents

Het belangrijkste verschil zit hem in de manier waarop de betaling wordt geverifieerd. Bij ‘charge’ leidt elk verzoek tot een on-chain transactie. Bij ‘sessions’ verifieert de server een ondertekende voucher met behulp van één enkele ecrecover aanroep, waarbij er geen RPC-aanroepen of database-schrijfbewerkingen in het kritieke pad voorkomen. Dit betekent dat de server tijdens de sessie nooit in aanraking komt met de blockchain, waardoor de doorvoer wordt beperkt door de CPU van de server en niet door de blockchain-consensus.

Op de MPP-eindpunten van Quicknode vertaalt zich dit ook in concrete kostenbesparingen: verzoeken om kosten door te berekenen kosten elk $0,001, terwijl sessieverzoeken elk $0,00001 kosten. Voor een script dat in één uitvoering meer dan 15 RPC-aanroepen over verschillende netwerken verstuurt, zijn sessies de logische keuze:

Opgevraagde ketens	Kosten ($0,001 per verzoek)	Sessie ($0,00001 per verzoek)
10	$0.010	$0.0001
25	$0.025	$0.00025
50	$0.050	$0.0005

Inzicht in de levenscyclus van een sessie

Voordat we ons op de code storten, is het belangrijk om te begrijpen hoe sessies achter de schermen werken. Het volgende diagram toont het volledige proces van onze multichain-saldo-checker:

Belangrijke begrippen

Betalingskanaal: Een on-chain escrow-contract waarbij de klant vooraf geld stort. Dit gebeurt eenmalig bij aanvang van de sessie.

Cumulatieve vouchers: Elk verzoek bevat een ondertekend bericht met de tekst: „Ik heb nu in totaal X verbruikt.” Vouchers zijn cumulatief, niet incrementeel. De server heeft alleen de meest recente voucher nodig om alle verschuldigde bedragen te innen. Bijvoorbeeld, na drie verzoeken van elk $0,00001: voucher(1) = 10, voucher(2) = 20, voucher(3) = 30 atomaire eenheden.

Sessies met meerdere netwerken: Eén sessie-instantie verwerkt verzoeken uit verschillende /sessie/:netwerk eindpunten. De sessie beheert het betalingskanaal; de netwerkslug bepaalt naar welke Quicknode RPC-backend het verzoek wordt doorgestuurd.

Afwikkeling: Wanneer de sessie wordt afgesloten, wikkelt de server de definitieve voucher op de blockchain af. De klant krijgt het eventuele ongebruikte voorschot terugbetaald.

Projectopzet

Het volledige script staat in het qn-gids-voorbeelden repository (het bronbestand rechtstreeks bekijken). Maak een kloon ervan en installeer de afhankelijkheden:

git clone https://github.com/quiknode-labs/qn-guide-examples.git
cd qn-guide-examples/mpp/multichain-balance-checker
npm install

Je kunt ook de index.ts bestand in je eigen project en installeer de benodigde afhankelijkheden.

Het project maakt gebruik van twee runtime-afhankelijkheden:

Verpakking	Doel
mppx	MPP-protocolclient (sessiebeheer, ondertekening van vouchers)
viem	Beheer van de portemonnee en opmaak van het saldo

En twee ontwikkelingsafhankelijkheden: tsx om TypeScript rechtstreeks uit te voeren, en typescript voor typecontrole.

Het ketenregister definiëren

Het script vraagt de inheemse saldi op binnen meerdere EVM-ketens. Elke keten wordt gedefinieerd aan de hand van de MPP-netwerkslug, de weergavenaam, het symbool van het inheemse token en de decimale nauwkeurigheid:

const CHAINS = [
  { slug: 'ethereum-mainnet', name: 'Ethereum', symbol: 'ETH', decimals: 18 },
  { slug: 'base-mainnet', name: 'Base', symbol: 'ETH', decimals: 18 },
  { slug: 'arbitrum-mainnet', name: 'Arbitrum', symbol: 'ETH', decimals: 18 },
  { slug: 'optimism-mainnet', name: 'Optimism', symbol: 'ETH', decimals: 18 },
  { slug: 'matic-mainnet', name: 'Polygon', symbol: 'POL', decimals: 18 },
  { slug: 'worldchain-mainnet', name: 'World Chain', symbol: 'ETH', decimals: 18 },
  { slug: 'bsc-mainnet', name: 'BNB Chain', symbol: 'BNB', decimals: 18 },
  { slug: 'fantom-mainnet', name: 'Fantom', symbol: 'FTM', decimals: 18 },
  { slug: 'celo-mainnet', name: 'Celo', symbol: 'CELO', decimals: 18 },
  { slug: 'xdai-mainnet', name: 'Gnosis', symbol: 'xDAI', decimals: 18 },
  { slug: 'zksync-mainnet', name: 'zkSync Era', symbol: 'ETH', decimals: 18 },
  { slug: 'scroll-mainnet', name: 'Scroll', symbol: 'ETH', decimals: 18 },
  { slug: 'linea-mainnet', name: 'Linea', symbol: 'ETH', decimals: 18 },
  { slug: 'mantle-mainnet', name: 'Mantle', symbol: 'MNT', decimals: 18 },
  { slug: 'blast-mainnet', name: 'Blast', symbol: 'ETH', decimals: 18 },
]

De netwerkslug is hier het belangrijkste onderdeel. Deze verwijst naar het eindpunt van de MPP-sessie op https://mpp.quicknode.com/session/:slug. De /sessie/ Het voorvoegsel in de URL geeft de server de opdracht om de ‘session intent’ te gebruiken in plaats van de ‘charge intent’.

Je kunt naar behoefte ketens toevoegen of verwijderen. De MPP-eindpunten van Quicknode ondersteunen alle ondersteunde netwerken. Je kunt ook de volledige lijst met ondersteunde slugs dynamisch ophalen:

curl https://mpp.quicknode.com/networks

Houd er rekening mee dat de ketens die u opvraagt, los staan van het betalingsnetwerk. Uw sessie draait op de Tempo-blockchain (testnet of mainnet), maar heeft toegang tot RPC-eindpunten op elke ondersteunde keten.

De portemonnee instellen

Het script heeft een wallet nodig om vouchers voor het betalingskanaal te ondertekenen. Het kan ofwel een bestaande privésleutel uit de omgeving gebruiken, ofwel automatisch een nieuwe genereren:

import { generatePrivateKey, privateKeyToAccount } uit 'viem/accounts'

const privateKey = (process.env.MPPX_PRIVATE_KEY als `0x${string}`) || generatePrivateKey()
const account = privateKeyToAccount(privateKey)

Wanneer een sleutel automatisch wordt gegenereerd, slaat het script deze op in een .env bestand (met chmod 600 (toestemmingen) zodat bij toekomstige uitvoeringen dezelfde wallet wordt gebruikt:

import { existsSync, writeFileSync } from 'fs'

if (isGenerated && !existsSync(envPath)) {
  writeFileSync(
    envPath,
    [
      '# Auto-generated by multichain balance checker',
      '# This file is gitignored — never commit private keys.',
      `MPPX_PRIVATE_KEY=${privateKey}`,
      '',
    ].join('\n'),
    { mode: 0o600 },
  )
}

Financiering via de Testnet Faucet

Bij gebruik op het testnet vult het script de wallet automatisch aan via de Tempo-testnet-faucet. Hierdoor krijgt de wallet PathUSD (een stablecoin op het testnet) en gas op Tempo Moderato (chain-ID 42431):

async function fundWallet(address: string): Promise<void> {
  const res = await fetch('https://docs.tempo.xyz/api/faucet', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ address }),
  })
  if (res.ok) {
    console.log('Faucet: Request accepted — waiting for onchain confirmation...')
    await waitForFunding(address)
  }
}

De waitForFunding De functie vraagt het PathUSD-contract op Tempo Moderato op om te controleren of het saldo is bijgeschreven, voordat er verder wordt gegaan:

const TEMPO_RPC = 'https://rpc.moderato.tempo.xyz'
const PATHUSD_ADDRESS = '0x20c0000000000000000000000000000000000000'

async function getPathUSDBalance(walletAddress: string): Promise<bigint> {
  const data = '0x70a08231' + walletAddress.slice(2).padStart(64, '0')
  const res = await fetch(TEMPO_RPC, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0', id: 1,
      method: 'eth_call',
      params: [{ to: PATHUSD_ADDRESS, data }, 'latest'],
    }),
  })
  const json = (await res.json()) as { result?: string }
  return BigInt(json.result ?? '0x0')
}

Dankzij deze wrijvingsloze opzet kan iedereen de repository klonen en het script uitvoeren zonder zich ergens voor aan te melden of handmatig geld in een wallet te storten.

info

De MPP-sessiestroom van Quicknode maakt gebruik van dezelfde gratis bucket als x402: 1.000.000 API-credits per maand per wallet. RPC-verzoeken kosten elk 1 API-credit, terwijl SQL Explorer de API-credits verbruikt die door de query worden gebruikt. Schakel over naar een wallet die via het mainnet wordt gefinancierd zodra de gratis quota is opgebruikt. Zie ‘Going to Production’.

De sessie aanmaken en saldi opvragen

Hier bevindt zich de kernlogica van de sessie. Het script maakt een MPP-sessie aan met tempo.session(), en doorloopt vervolgens elke keten, waarbij het eth_getBalance verzoeken tijdens de sessie:

import { tempo } from 'mppx/client'

const session = tempo.session({
  account,
  maxDeposit: '1', // 1 PathUSD — covers 100,000 requests at $0.00001/each
})

De maxDeposit Met deze parameter stel je het totale budget voor het betalingskanaal in. Wat je niet hebt uitgegeven, krijg je terug wanneer de sessie wordt afgesloten.

info

Als het saldo van het kanaal halverwege de sessie opraakt, dan mppx De klant kan het kanaal aanvullen met een extra storting via de blockchain, zonder de sessie te hoeven sluiten en opnieuw te openen. Voor ons 15-chain-script is zelfs een kleine storting ruim voldoende, maar dit is handig als je applicaties bouwt die langere tijd draaien en duizenden verzoeken versturen.

RPC-aanroepen uitvoeren via de sessie

Voor elke keten roept het script het volgende aan session.fetch() met een standaard JSON-RPC eth_getBalance payload. De sessie regelt alle MPP-processen automatisch:

const MPP_BASE_URL = 'https://mpp.quicknode.com/session'

for (const chain of CHAINS) {
  const response = await session.fetch(`${MPP_BASE_URL}/${chain.slug}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      jsonrpc: '2.0',
      id: 1,
      method: 'eth_getBalance',
      params: [WALLET_ADDRESS, 'latest'],
    }),
  })

  const data = (await response.json()) as { result?: string; error?: { message: string } }
  // Parse hex balance to human-readable format
  const balance = formatBalance(data.result!, chain.decimals)
}

Op de eerste verzoek, session.fetch() verwerkt de volledige 402-challenge-response-stroom: het ontvangt de challenge, stort PathUSD in het on-chain escrow-contract en probeert het opnieuw met een ondertekende voucher. Dit duurt ongeveer 500 ms.

Op elk volgend verzoek, de sessie verhoogt dan gewoon het cumulatieve voucherbedrag en neemt dit op in de Autorisatie header. De server controleert de voucher met één enkele ecrecover bewerking (geen transactie op de blockchain nodig), waardoor reacties worden teruggestuurd met vrijwel geen betalingskosten.

Het script bevat ook een herhalingspoging bij 404-responsen om tijdelijke MPP-routeringsproblemen op te vangen:

if (response.status === 404) {
  response = await session.fetch(`${MPP_BASE_URL}/${chain.slug}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: rpcBody,
  })
}

De balans opmaken

De eth_getBalance Het antwoord bevat een hexadecimale tekenreeks die het saldo in wei (of de kleinste eenheid die in die blockchain wordt gebruikt) weergeeft. Het script zet dit om in een voor mensen leesbaar decimaal getal:

import { formatUnits } from 'viem'

function formatBalance(hexBalance: string, decimals: number): string {
  const value = BigInt(hexBalance)
  return parseFloat(formatUnits(value, decimals)).toFixed(4)
}

De sessie afsluiten

Zodra alle verzoeken zijn voltooid, sluit het script de sessie af om de afwikkeling op de blockchain in gang te zetten. De server verrekent de uiteindelijke cumulatieve voucher en stort het ongebruikte voorschot terug naar de wallet:

// Sessiegegevens vastleggen voordat de sessie wordt afgesloten
const channelId = sessie.channelId
const cumulativeSpend = sessie.cumulative

console.logboek('Sessie wordt afgesloten en op de blockchain verwerkt...')
const ontvangstbewijs = await sessie.close()

Het script geeft vervolgens een overzicht weer met de totale kosten, het terug te betalen bedrag en de afrekeningsgegevens:

printSummary(
      resultaten,
      totaal aantal verzoeken,
      channelId,
      cumulativeSpend,
      ontvangstbewijs?.txHash,
    );

Het script omvat bovendien de gehele query-lus in een try/catch-blok en probeert de sessie zelfs bij fouten te sluiten, zodat het betalingskanaal niet voor onbepaalde tijd open blijft:

try {
  // ... query loop ...
  await session.close()
} catch (err) {
  console.error('Fatal error:', err instanceof Error ? err.message : err)
  try {
    await session.close()
    console.log('Session closed after error.')
  } catch {
    console.log('Could not close session.')
  }
  process.exit(1)
}

Het script uitvoeren

Als alles is ingesteld, voer je het script uit:

# Draai met een automatisch gegenereerde testnet-portemonnee (geen installatie nodig)
npx tsx index.ts

# Of geef je eigen privésleutel op via een .env-bestand
echo "MPPX_PRIVATE_KEY=0x..." > .env
npx tsx --env-file=.env index.ts

Je zou ongeveer de volgende uitvoer moeten zien:

Multichain-saldo-checker (via MPP-sessie)
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Portemonnee:  0x1234...abcd (automatisch gegenereerd)
Doel:  0xd8dA...6045

 Keten            | Saldo               | Status
──────────────────┼───────────────────────┼──────────
 Ethereum         | 1,2345 ETH            | ok
 Basis             | 0,5000 ETH            | ok
 Arbitrum         | 0,0000 ETH            | ok
 Optimism         | 2,1000 ETH            | ok
 Polygon          | 150,0000 POL          | ok
 BNB Chain        | 0,0312 BNB            | ok
 ...              | ...                   | ...

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 Sessieoverzicht
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 Geraadpleegde ketens:    15 (15 ok, 0 fouten)
 Totaal aantal RPC-aanroepen:   15
 Sessiekosten:      0,000150 PathUSD ($0,00015)
 Storting op kanaal:   1,000000 PathUSD
 Terugbetaald:          0,999850 PathUSD
 Kanaal-ID:        0xdef456...abc123
 Afwikkelingstransactie:     0xabc123...def456

Zodra de sessie is afgesloten, kun je de afwikkeling controleren via de block explorer. De Afwikkeling tx De hash in de uitvoerlinks verwijst naar de uiteindelijke transactie op de blockchain. Gebruik de testnet-verkenner voor Tempo Moderato of de mainnet-explorer voor productieseries.

Op de onderstaande schermafbeelding is te zien hoe een afwikkelingstransactie eruitziet:

Het rode kader toont de twee saldooverdrachten die aan het betalingskanaal zijn gekoppeld: 1 PathUSD die bij het openen van de sessie naar het escrow-contract is gestuurd, en 0,99985 PathUSD die bij de afwikkeling als terugbetaling is teruggestort. Het oranje kader toont de daadwerkelijke sessiekosten (0,00015 PathUSD) die als onderdeel van de afwikkelingstransactie aan de server zijn betaald.

Je kunt het adres van de wallet dat wordt gecontroleerd wijzigen door het WALLET_ADDRESS constante bovenaan index.ts:

const WALLET_ADDRESS = '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045' // willekeurig adres

Overgang naar productie

Het script is standaard ingesteld op testnet om een soepele onboarding mogelijk te maken. Dit is wat er verandert bij gebruik in de productieomgeving:

	Testnet (standaard)	Mainnet
Betalingsnetwerk	Tempo Moderato (keten-ID 42431)	Tempo-mainnet (keten-ID 4217)
Valuta	PathUSD	PathUSD of USDC.e
Gratis pakket	1.000.000 API-credits per maand per wallet, verdeeld over MPP en x402	Onbeperkt
Financiering via de portemonnee	Automatisch gefinancierd via de faucet	Handmatige financiering vereist

Om over te schakelen naar het mainnet, moet je een wallet-sleutel opgeven die PathUSD of USDC.e op het Tempo-mainnet bevat. De mppx De client detecteert automatisch de beschikbare saldi en kiest de juiste betaalmethode uit de 402-challenge.

Het script uitbreiden

De saldochecker is bewust eenvoudig gehouden om de aandacht op de werking van de sessie te houden. Het belangrijkste om te onthouden is het patroon: open één sessie, voer veel RPC-aanroepen uit over verschillende ketens, sluit de sessie af en verwerk de transacties. Aangezien één enkele MPP-sessie verzoeken over alle netwerkslugs afhandelt, kun je het script uitbreiden om elke RPC-methode op elke ondersteunde keten aan te roepen zonder de sessie-instellingen te wijzigen. Je zou bijvoorbeeld saldochecks voor ERC-20-tokens kunnen toevoegen door te swappen eth_getBalance voor een eth_call naar het tokencontract's saldo van functie.

Conclusie

Je hebt een multichain-saldo-checker gebouwd die via één enkele MPP-sessie 15 EVM-ketens doorzoekt. Het belangrijkste patroon om te onthouden: open één betalingskanaal, voer zoveel RPC-aanroepen uit als je nodig hebt over elke combinatie van ondersteunde ketens met behulp van off-chain vouchers, en sluit en vereffen vervolgens. De sessie heeft alle betalingsmechanismen automatisch afgehandeld, van de eerste 402-challenge via het ondertekenen van vouchers tot de uiteindelijke vereffening en terugbetaling.

Dit patroon is van toepassing op elke workflow die meerdere RPC-aanroepen uitvoert: portefeuille-trackers, monitoringscripts, datapijplijnen of AI-agenten die de on-chain-status over verschillende netwerken heen moeten uitlezen. Dankzij sessies kunnen deze tools programmatisch voor toegang betalen, zonder accounts of API-sleutels, terwijl de overhead van de betaling buiten het kritieke pad blijft.

Volgende stappen

Raadpleeg de volgende bronnen voor meer informatie over MPP, Tempo en de MPP-integratie van Quicknode:

• Documentatie over het Machine Payments Protocol
• Handleiding voor facturering op basis van MPP-sessies
• mppx SDK op npm
• Quicknode MPP-protocolreferentie
• IETF-specificatie voor betalingsverificatie
• Gebruik MPP met Foundry en Tempo (begeleidende handleiding voor Solidity-ontwikkelaars)

Veelgestelde vragen

Wat is MPP en waarin verschilt het van traditionele authenticatie via een API-sleutel?

Het Machine Payments Protocol (MPP) is een open standaard waarmee inline-betalingen kunnen worden toegevoegd aan HTTP-eindpunten met behulp van de statuscode 402 (Payment Required). In plaats van een account aan te maken en API-sleutels te beheren, betaal je per verzoek met stablecoins vanuit een wallet. Hierdoor kunnen scripts, agents en bots direct gebruikmaken van API’s, zonder dat er een factureringsproces door mensen hoeft te worden ingesteld.

Wanneer moet ik een MPP-sessie gebruiken in plaats van betalingen per verzoek?

Gebruik sessies wanneer je script of applicatie meerdere RPC-aanroepen uitvoert tijdens één uitvoering. Sessies openen één betalingskanaal on-chain en maken gebruik van off-chain vouchers voor volgende verzoeken. Het verifiëren van vouchers is een CPU-intensieve handtekeningcontrole die enkele microseconden overhead met zich meebrengt, in vergelijking met honderden milliseconden voor on-chain betalingen via ‘charge’. Op de MPP-eindpunten van Quicknode zijn sessies bovendien aanzienlijk goedkoper per verzoek. Als je minder dan 10 verzoeken doet, is ‘charge’ eenvoudiger.

Heb ik een Quicknode-account nodig om MPP-eindpunten te gebruiken?

Nee. Voor MPP-eindpunten is geen account, geen API-sleutels en geen registratie nodig. Je hebt alleen een wallet nodig met stablecoins (of testnet-tokens). De betaling vindt inline plaats bij elk HTTP-verzoek.

Kan ik via een MPP-sessie query's uitvoeren op niet-EVM-ketens, zoals Solana?

De MPP-eindpunten van Quicknode ondersteunen Solana en andere niet-EVM-ketens. Je kunt dezelfde sessie-instantie gebruiken om gegevens op te vragen van elke ondersteunde keten door de netwerkslug in de URL aan te passen. Gebruik bijvoorbeeld /session/solana-mainnet om via hetzelfde betalingskanaal gegevens op te vragen bij de RPC-eindpunten van Solana.

Wat gebeurt er als mijn script vastloopt voordat de sessie wordt afgesloten?

Als de sessie niet expliciet wordt afgesloten, blijft het betalingskanaal open totdat de time-out is bereikt. De server kan dan nog steeds de laatst ontvangen voucher verwerken. Om dit te voorkomen, plaatst het script de query-lus in een try/catch-blok en probeert het de sessie zelfs bij fouten af te sluiten.

Hoe werkt het gratis abonnement en hoe stap ik over naar het mainnet?

De MPP-eindpunten van Quicknode maken gebruik van dezelfde gratis quota van 1.000.000 API-credits per maand per wallet, die ook voor x402 geldt. RPC-verzoeken kosten elk 1 API-credit, terwijl SQL Explorer de API-credits verbruikt die door de query worden gebruikt. Voor onbeperkt gebruik moet je een wallet opgeven die is gefinancierd met PathUSD of USDC.e op het Tempo-mainnet (chain-ID 4217).

We ❤️ feedback!

Laat het ons weten als je feedback hebt of suggesties voor nieuwe onderwerpen. We horen graag van je.