Pay per
request. on-chain.
MPPHOOD is the 402 Protocol Lab — pay-per-request infrastructure for humans and autonomous agents. Your code calls fetch(), we mint an ephemeral wallet, dust it with faucet HOOD, and settle on Robinhood Chain in under 2 seconds. Zero config, real receipts.
Free HOOD via faucet airdrop. The default sandbox — break things without burning a cent.
Mainnet-like validator behaviour, still funded by faucet. Use for stress tests and CI runs.
Live Robinhood Chain mainnet with real HOOD. Flip one flag, point at a funded keypair, ship.
DevLabs
Wire-real 402 flows on Robinhood Chain — 4 free, 6 metered endpoints to poke at.
Pick an endpoint and fire a request
The full HTTP 402 settlement trace streams here in real time
The 402 pipeline, unpacked.
HTTP 402 Payment Required has existed since 1999. MPPHOOD makes it real — on Robinhood Chain, end-to-end.
Call mppFetch() with any URL. No setup, no config — the SDK conjures a wallet and dusts it with faucet HOOD on sandbox/testnet.
The API responds with HTTP 402 Payment Required and a Payment-Request header specifying cost and recipient address.
The SDK builds a native HOOD transfer, signs with the ephemeral key, and confirms on Robinhood Chain. Usually under 2 seconds.
The request is retried with a Payment-Receipt header. The server verifies on-chain and streams the payload back.
Six ways teams are wiring it up.
The 402 pattern collapses payments and access into a single HTTP round-trip. Here's where it clicks hardest.
LLM agents that pay-per-call for premium APIs — no API keys, no billing dashboards, just receipts on-chain.
Ship pay-per-request endpoints without Stripe integrations, quotas, or per-user auth headaches.
Gate individual articles, downloads, or media assets behind micropayments smaller than any card fee.
Charge fractions of a cent per inference. Perfect for open-model providers and embedding services.
Sell single rows, single queries, or single files. Settlement receipts double as immutable audit logs.
Let bots pay bots. Machine-to-machine commerce with no shared trust anchor other than the chain.
Built for machines that pay each other.
Every design decision optimizes for developer experience and API-first workflows.
Import the SDK. Call fetch. Wallet creation, faucet funding, and settlement are automatic. No env vars, no dashboards.
Built on the HTTP standard for payment-required responses. RESTful, stateless, inspectable end-to-end.
Run on sandbox or testnet with free faucet HOOD. Flip one flag for Robinhood Chain mainnet — same SDK, same interface.
Same SDK, same middleware. Promote to mainnet without a rewrite or new mental model.
Server-side is a single function — mpp.charge({ amount }). Drop it before any route. Plays nice with your auth and rate-limit stack.
onStep callback gives real-time visibility into the settlement lifecycle: wallet, faucet, submit, confirm, retry, deliver.
Two sides. Both stupid simple.
Client auto-handles the settlement loop. Server adds one middleware line. That's the entire integration.
import { mppFetch } from "mpphood-sdk";
// That's it. No wallet setup, no config.
const res = await mppFetch("https://api.example.com/data");
const data = await res.json();
// Under the hood:
// 1. SDK generated an ephemeral keypair
// 2. Airdropped 2 HOOD from sandbox faucet
// 3. Server returned 402 Payment Required
// 4. SDK settled 0.001 HOOD on Robinhood Chain
// 5. Retried with Payment-Receipt → 200 OK402 vs. the card rails.
Where the sandbox is headed.
Client + Express middleware ship with sandbox faucet integration.
Real-time lifecycle hooks and DevLabs playground go public.
Mainnet-like validator behavior plus CI-safe deterministic mode.
Production mainnet toggle and drop-in adapters for popular agent frameworks.
Builders shipping on 402.
"This is what fetch was always supposed to feel like. My agent pays for its own APIs now."
"Killed our metering microservice in one afternoon. The 402 pattern is stupidly obvious in hindsight."
"Sub-2s settlement, zero config, no billing tables. It felt illegal at first."
Questions, answered.
Everything you need to know about the 402 micropay protocol and the MPPHOOD sandbox.
Open DevLabsWhat is HTTP 402?
402 Payment Required is a reserved HTTP status code from RFC 7231. MPPHOOD uses it to negotiate a tiny on-chain payment, then retry the request with a receipt header.
Is this real money?
By default DevLabs runs in Simulated mode against sandbox/testnet faucets — completely free. Flip to mainnet to use real HOOD.
Which chain is supported?
Robinhood Chain — sandbox, testnet, and mainnet. The SDK abstracts all three behind the same fetch() interface.
Do I need a wallet?
No. The SDK generates an ephemeral keypair per session and dusts it with faucet HOOD on test networks. Bring your own keypair only for mainnet.
How fast is settlement?
Robinhood Chain confirms in roughly 1–2 seconds. The full request → 402 → settle → retry → 200 round-trip usually finishes under 3 seconds on sandbox.
Can I use this in production?
Yes. The same SDK and middleware run on mainnet — flip one config flag, point at a funded keypair, and ship.
Stop mocking payments. Start settling them.
Fire real-shaped requests at a simulated Robinhood Chain settlement server. Watch every step of the 402 pipeline as it happens.