x402 vs Stripe for API Monetization: Why Crypto Micropayments Win in 2026

import Stripe from "stripe";
import express from "express";

const stripe = new Stripe(process.env.STRIPE_SECRET_KEY!);
const app = express();

// Step 1: Create a metered price (one-time setup)
// stripe.prices.create({
//   currency: "usd",
//   unit_amount: 0,  // usage-based
//   recurring: { interval: "month", usage_type: "metered" },
//   product: "prod_proxy_api",
// });

// Step 2: Middleware - requires pre-registered customer
async function stripeMeteredBilling(
  req: express.Request,
  res: express.Response,
  next: express.NextFunction
) {
  const apiKey = req.headers["x-api-key"] as string;

  if (!apiKey) {
    return res.status(401).json({
      error: "API key required",
      signup: "https://your-app.com/signup"  // Human signup needed
    });
  }

  // Look up Stripe subscription for this API key
  const subscription = await findSubscription(apiKey);
  if (!subscription) {
    return res.status(403).json({ error: "No active subscription" });
  }

  // Record usage (billed at end of month)
  await stripe.subscriptionItems.createUsageRecord(
    subscription.items.data[0].id,
    {
      quantity: 1,
      timestamp: Math.floor(Date.now() / 1000),
      action: "increment",
    }
  );

  // IMPORTANT: You do NOT get paid here.
  // Payment happens when Stripe invoices at month-end.
  // Settlement arrives 2+ business days after that.
  // Customer can dispute the invoice.

  next();
}

// Protected endpoint
app.get("/v1/proxy/create",
  stripeMeteredBilling,
  (req, res) => {
    res.json({ proxy: { host: "...", port: 5057 } });
  }
);

// Step 3: Webhook to handle payment (runs weeks later)
app.post("/stripe/webhook",
  express.raw({ type: "application/json" }),
  (req, res) => {
    const event = stripe.webhooks.constructEvent(
      req.body,
      req.headers["stripe-signature"]!,
      process.env.STRIPE_WEBHOOK_SECRET!
    );

    switch (event.type) {
      case "invoice.paid":
        console.log("Finally got paid (maybe 30+ days later)");
        break;
      case "invoice.payment_failed":
        console.log("Customer didn't pay. Usage already consumed.");
        break;
      case "charge.dispute.created":
        console.log("Chargeback. -$15 dispute fee. Prove you're right.");
        break;
    }
    res.sendStatus(200);
  }
);

async function findSubscription(apiKey: string) {
  // Your database lookup: apiKey -> Stripe subscription ID
  return null; // Simplified
}

app.listen(3000);

import express from "express";
import { ethers } from "ethers";

const app = express();
const BASE_RPC = "https://mainnet.base.org";
const USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
const MY_WALLET = process.env.PAYMENT_ADDRESS!;

const ERC20_ABI = [
  "event Transfer(address indexed from, address indexed to, uint256 value)"
];

// x402 middleware: protect any route
function requirePayment(amountUSDC: string, description: string) {
  return async (req: express.Request, res: express.Response, next: express.NextFunction) => {
    const proof = req.headers["x-payment-proof"] as string;

    if (!proof) {
      // Return 402 with machine-readable payment terms
      return res.status(402).json({
        error: "payment_required",
        amount: amountUSDC,
        currency: "USDC",
        network: "base",
        address: MY_WALLET,
        description,
        expires_in: 300,
      });
    }

    // Verify payment on-chain (takes ~200ms)
    const provider = new ethers.JsonRpcProvider(BASE_RPC);
    const receipt = await provider.getTransactionReceipt(proof);

    if (!receipt || receipt.status !== 1) {
      return res.status(400).json({ error: "invalid_payment" });
    }

    const iface = new ethers.Interface(ERC20_ABI);
    const transferLog = receipt.logs.find(log => {
      try {
        const parsed = iface.parseLog({
          topics: [...log.topics], data: log.data
        });
        return parsed?.name === "Transfer"
          && parsed.args.to.toLowerCase() === MY_WALLET.toLowerCase()
          && log.address.toLowerCase() === USDC_BASE.toLowerCase();
      } catch { return false; }
    });

    if (!transferLog) {
      return res.status(400).json({ error: "payment_not_found" });
    }

    const parsed = iface.parseLog({
      topics: [...transferLog.topics],
      data: transferLog.data
    });
    const paidAmount = ethers.formatUnits(parsed!.args.value, 6);

    if (parseFloat(paidAmount) < parseFloat(amountUSDC)) {
      return res.status(400).json({
        error: "insufficient_payment",
        required: amountUSDC,
        received: paidAmount
      });
    }

    // Payment verified. Funds in your wallet NOW.
    // No chargebacks. No disputes. No waiting.
    next();
  };
}

// Protected endpoint - $0.005 per request
app.get("/v1/proxy/create",
  requirePayment("0.005", "Single proxy request"),
  (req, res) => {
    res.json({ proxy: { host: "...", port: 5057 } });
  }
);

app.listen(3000);