HTTP 402 Payment Required:
From RFC 7231 to Real-World
x402 Use Cases in 2026

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

const BASE_RPC = "https://mainnet.base.org";
const USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
const MY_WALLET = "0xYourWalletAddress";

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

function x402Paywall(priceUSDC: string, description: string) {
  return async (req: express.Request, res: express.Response, next: express.NextFunction) => {
    const paymentSig = req.headers["payment-signature"] as string;

    if (!paymentSig) {
      // Return 402 with structured payment terms
      return res.status(402).json({
        x402Version: 1,
        price: (parseFloat(priceUSDC) * 1e6).toString(),
        currency: "USDC",
        decimals: 6,
        recipient: MY_WALLET,
        network: "base",
        description,
        expiresAt: new Date(Date.now() + 300_000).toISOString(),
        resourceUrl: req.originalUrl,
        acceptedNetworks: ["base", "solana"],
      });
    }

    // Verify on-chain payment
    const provider = new ethers.JsonRpcProvider(BASE_RPC);
    const receipt = await provider.getTransactionReceipt(paymentSig);

    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: "no_usdc_transfer_found" });
    }

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

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

    // Attach payment info and proceed
    (req as any).x402Payment = {
      txHash: paymentSig,
      amount: paidAmount,
      from: parsed!.args.from
    };
    next();
  };
}

// Usage: protect any route
const app = express();
app.get("/v1/data",
  x402Paywall("0.10", "Single API call"),
  (req, res) => {
    res.json({ data: "premium content", payment: (req as any).x402Payment });
  }
);

import { ethers } from "ethers";

const USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
const ERC20_ABI = ["function transfer(address to, uint256 amount) returns (bool)"];

async function x402Fetch(url: string, walletKey: string): Promise<any> {
  // Step 1: Initial request
  const res = await fetch(url);

  if (res.status !== 402) {
    return res.json(); // Resource was free or already paid
  }

  // Step 2: Parse x402 payment terms
  const terms = await res.json();
  console.log(`Payment required: ${terms.price / 1e6} ${terms.currency} on ${terms.network}`);

  // Step 3: Check expiration
  if (new Date(terms.expiresAt) < new Date()) {
    throw new Error("Payment terms expired, retry the request");
  }

  // Step 4: Execute on-chain USDC transfer
  const provider = new ethers.JsonRpcProvider("https://mainnet.base.org");
  const wallet = new ethers.Wallet(walletKey, provider);
  const usdc = new ethers.Contract(USDC_BASE, ERC20_ABI, wallet);

  const tx = await usdc.transfer(terms.recipient, BigInt(terms.price));
  const receipt = await tx.wait();
  console.log(`Paid: tx ${receipt.hash}`);

  // Step 5: Retry with payment proof
  const paidRes = await fetch(url, {
    headers: {
      "Payment-Signature": receipt.hash,
      "X-Payment-Network": terms.network,
    },
  });

  if (!paidRes.ok) {
    throw new Error(`Payment verified but resource failed: ${paidRes.status}`);
  }

  return paidRes.json();
}

// Usage
const proxy = await x402Fetch(
  "https://api.proxies.sx/v1/x402/proxy/create?country=US&type=4g",
  process.env.AGENT_WALLET_KEY!
);
console.log("Proxy credentials:", proxy);