x402 in Rust

x402 is plain HTTP 402, so adding USDC pay-per-request to an axum service takes only a handler and a facilitator call — and Rust is a favorite for high-throughput facilitators.

Which approach should you use?

Server (axum)

Return 402 with payment requirements until a valid X-PAYMENT header arrives, then serve.

// axum handler that requires payment.
// x402 is just HTTP 402, so you can implement it directly in Rust.
use axum::{routing::get, Json, Router, http::{HeaderMap, StatusCode}};
use serde_json::{json, Value};

async fn weather(headers: HeaderMap) -> (StatusCode, Json<Value>) {
    let payment = headers.get("X-PAYMENT").and_then(|v| v.to_str().ok());

    match payment {
        Some(p) if verify_with_facilitator(p).await => {
            // Paid: serve the response
            (StatusCode::OK, Json(json!({ "city": "Tokyo", "forecast": "sunny" })))
        }
        _ => {
            // 402 with payment requirements
            let requirements = json!({
                "scheme": "exact",
                "network": "base-sepolia",  // use "base" in production
                "maxAmount": "10000",         // 0.01 USDC (6 decimals)
                "payTo": "0xYourReceivingWalletAddress",
                "asset": "USDC"
            });
            (StatusCode::PAYMENT_REQUIRED, Json(json!({ "accepts": [requirements] })))
        }
    }
}

#[tokio::main]
async fn main() {
    let app = Router::new().route("/weather", get(weather));
    let listener = tokio::net::TcpListener::bind("0.0.0.0:8080").await.unwrap();
    axum::serve(listener, app).await.unwrap();
}

Verifying the payment

A facilitator checks the signed USDC payment on-chain so your server stays simple.

// Verify the payment by POSTing to an x402 facilitator's
// /verify (and later /settle) endpoint over HTTP.
async fn verify_with_facilitator(payment: &str) -> bool {
    // Send the X-PAYMENT payload + requirements to your facilitator,
    // which checks the signed USDC payment on-chain and returns valid=true.
    // Use a hosted facilitator or run your own (several are written in Rust).
    call_facilitator("/verify", payment).await.unwrap_or(false)
}

Middleware for multiple routes

Apply the check to every route with a tower layer instead of repeating it per handler.

// Extract the check into a tower middleware so every route gets it
// without repeating the logic in each handler.
use axum::{middleware::{self, Next}, extract::Request, response::Response};

async fn require_payment(headers: HeaderMap, req: Request, next: Next) -> Response {
    let payment = headers.get("X-PAYMENT").and_then(|v| v.to_str().ok());
    match payment {
        Some(p) if verify_with_facilitator(p).await => next.run(req).await,
        _ => {
            let body = Json(json!({ "accepts": [/* ...requirements */] }));
            (StatusCode::PAYMENT_REQUIRED, body).into_response()
        }
    }
}

let app = Router::new()
    .route("/weather", get(weather))
    .layer(middleware::from_fn(require_payment));

Client (manual retry)

No official Rust client package exists yet, so a caller reads the 402 body and retries with a signed payment itself.

// A Rust client that pays automatically by handling the 402 itself.
// There's no official Rust client SDK yet, so this shows the manual flow —
// most Rust usage of x402 today is on the server/facilitator side.
let resp = reqwest::get("http://localhost:8080/weather").await?;

if resp.status() == reqwest::StatusCode::PAYMENT_REQUIRED {
    let body: serde_json::Value = resp.json().await?;
    let requirement = &body["accepts"][0];
    // Sign a USDC payment for the requirement above, then retry with the
    // signed payload in the X-PAYMENT header.
    let signed = sign_payment(requirement);
    let resp = reqwest::Client::new()
        .get("http://localhost:8080/weather")
        .header("X-PAYMENT", signed)
        .send()
        .await?;
}

Troubleshooting

Get amounts right with the free base-unit converter.

Rust x402 projects

Real open-source implementations · stars live from GitHub.

Frequently asked questions

More: all SDKs · Python · Node.js · Go