Most developers who have tried selling API access know the frustration well. You start with a useful endpoint, then spend weeks building a billing system instead of improving the actual product. The standard approach involves integrating Stripe, designing a subscription flow, issuing API keys, storing them in a database, validating keys on every request, building a usage dashboard, and handling failed payments. By the time you finish, you have built a separate billing product. That was never the goal.
The real problem becomes obvious when you want to charge small amounts. A fee of $0.001 per API call is not viable with traditional processors because the transaction fee alone exceeds the charge. This forces developers into subscriptions, credit packs, or tiered bundles. Your pricing model turns into a product design problem instead of a simple cost-per-call model.
There is a cleaner path forward. It has existed in the HTTP specification since 1999 but lacked the infrastructure to function. HTTP status code 402, Payment Required, was reserved in the original HTTP 1.1 spec. The concept is straightforward: the server tells the client to pay first and retry. The client makes a payment, retries with proof, and receives the resource. The missing pieces were always how to specify the amount, in what form the client pays programmatically, and how the server verifies payment without a central authority.
Blockchains finally answer those questions. Solana, in particular, handles the specifics: it specifies amounts in SOL or any SPL token, accepts payment through a signed transaction, provides on-chain verification with no intermediary, confirms transactions in about two seconds, and charges fractions of a cent in fees. The MPP Testkit SDK wires all of this together.
This api monetization tutorial walks through building a running pay-per-request API server, a client that pays automatically, and a test suite covering the full payment flow. Everything runs on devnet, completely free. The total code comes to about 20 lines for the server and 10 for the client.
Step 2: How Blockchain Infrastructure Unlocks HTTP 402
Blockchain technology answers every question that made HTTP 402 impractical. Solana in particular provides a complete solution. The network specifies amounts in SOL or any SPL token. The client submits a signed transaction as payment. The server verifies the transaction on-chain with no intermediary. Confirmations settle in roughly two seconds. Network fees cost fractions of a cent.
The MPP Testkit SDK wraps these capabilities into Express middleware. The mpp.charge() function checks incoming requests for a valid payment receipt. If no receipt exists, it returns a 402 status. If a receipt is present, it verifies the transaction on-chain. If everything checks out, it calls next() and the request proceeds to the actual endpoint handler.
This approach eliminates the need for API keys, databases, subscription logic, or payment processor integrations. The blockchain itself becomes the billing system. Each request carries its own proof of payment, and the server validates it in real time.
Step 3: Setting Up the Project and Writing the Server
This api monetization tutorial uses Node.js with Express and the MPP Testkit SDK. Start by creating a new directory and installing dependencies.
mkdir my-paid-api && cd my-paid-api
npm init -y
npm install express mpp-test-sdkCreate a file named server.js. This file contains the entire API server with three endpoints: one free, two paid.
import express from "express";
import { createTestServer } from "mpp-test-sdk";
const app = express();
const mpp = createTestServer();
// Free endpoint - no payment needed
app.get("/api/ping", (req, res) => {
res.json({ status: "ok", ts: Date.now() });
});
// 0.001 SOL per call
app.get("/api/weather", mpp.charge({ amount: "0.001" }), (req, res) => {
res.json({
city: "San Francisco",
temp: 62,
condition: "Partly cloudy",
paid: true,
});
});
// 0.005 SOL per call - premium tier
app.get("/api/forecast", mpp.charge({ amount: "0.005" }), (req, res) => {
res.json({
city: "San Francisco",
forecast: [
{ day: "Mon", high: 65, low: 54 },
{ day: "Tue", high: 68, low: 57 },
{ day: "Wed", high: 61, low: 52 },
],
model: "v2-premium",
paid: true,
});
});
app.listen(3001, () => {
console.log("Server running on:3001");
console.log("Payment recipient:", mpp.recipientAddress);
});That is the entire server. The mpp.charge() middleware handles all payment logic. It returns a 402 response if no valid payment receipt accompanies the request. If a receipt exists, it verifies the transaction on Solana devnet. If verification succeeds, it passes control to the route handler.
The free /api/ping endpoint has no middleware. The /api/weather endpoint charges 0.001 SOL per call. The /api/forecast endpoint charges 0.005 SOL per call, representing a premium tier with more data.
Start the server with:
node server.js
# Server running on:3001
# Payment recipient: 7xKmPq2rNbMd.The server logs its recipient address. This address is where all payments will be sent during testing.
Step 4: Writing the Client That Pays Automatically
The client script handles wallet creation, funding, payment, and verification without any manual steps. Create a file named client.js.
import { createTestClient } from "mpp-test-sdk";
const client = await createTestClient({
network: "devnet",
onStep: (step) => console.log(step),
});
const endpoints = [
"http://localhost:3001/api/ping",
"http://localhost:3001/api/weather",
"http://localhost:3001/api/forecast",
];
for (const url of endpoints) {
const response = await client.fetch(url);
const data = await response.json();
console.log(url, data);
}The client uses createTestClient with the devnet network and an onStep callback. The callback logs each step of the flow: wallet creation, funding, request initiation, payment submission, and verification. The client.fetch() method wraps the standard fetch API but automatically attaches payment receipts for endpoints that require them.
You may also enjoy reading: Why Netflix Delays Greta Gerwig’s Narnia for 2027 Release.
Run the client with:
node client.jsThe output shows the full lifecycle. The client creates a new wallet, requests a devnet airdrop for SOL, hits the free ping endpoint, then hits the weather endpoint. For the weather endpoint, the client automatically pays 0.001 SOL before receiving the response. For the forecast endpoint, it pays 0.005 SOL. Each step is logged so you can see exactly what happens.
That is the complete payment flow, automated, on devnet, for free. No API keys, no database, no Stripe integration.
Step 5: Testing the Full Payment Flow
Testing is built into the flow itself. The createTestServer and createTestClient functions from MPP Testkit are designed for devnet testing. They handle wallet creation, funding through airdrops, transaction submission, and on-chain verification automatically.
To run a full test, start the server in one terminal window and run the client in another. The client logs every step, so you can verify each stage of the payment lifecycle. The free endpoint returns data immediately. The paid endpoints require the client to submit a valid payment receipt before the server returns data.
If a payment fails or the receipt is invalid, the server returns a 402 status. The client can then retry. This mirrors the HTTP 402 design precisely: the server says pay first, the client pays, and the client retries with proof.
The beauty of this approach is that you can extend it to any number of endpoints with different pricing. Each endpoint declares its own cost through the mpp.charge() middleware. The client handles payment automatically. The blockchain provides verification. No additional infrastructure is required.
This api monetization tutorial demonstrates that pay-per-request billing is not only possible but practical with modern blockchain infrastructure. The total code required is minimal. The setup takes minutes. The entire system runs on devnet for free, making it accessible for prototyping and testing.
The implications extend beyond simple APIs. Any service that provides data or computation on a per-request basis can use this model. Machine learning inference endpoints, data feeds, image processing APIs, and web scraping services can all charge micro-amounts per call without worrying about payment processor fees eating the revenue.
HTTP 402 finally has the infrastructure it always needed. The blockchain provides the payment mechanism, the verification layer, and the settlement system. The SDK handles the integration. The developer focuses on building the actual API.
