Quickstart for Sellers

go get github.com/x402-foundation/x402/go

// proxy.ts
export const proxy = paymentProxy(
  {
    // Next.js-style param — matches /api/articles/any-slug
    "/api/articles/[slug]": {
      accepts: [
        {
          scheme: "exact",
          price: "$0.01",
          network: "eip155:84532",
          payTo,
        },
      ],
      description: "Read a premium article by slug",
      mimeType: "application/json",
    },
  },
  server,
);

export const config = {
  matcher: ["/api/articles/:slug"],
};

r.Use(ginmw.X402Payment(ginmw.Config{
    Routes: x402http.RoutesConfig{
        // Named param — matches /articles/any-slug
        "GET /articles/:slug": {
            Accepts: x402http.PaymentOptions{
                {
                    Scheme:   "exact",
                    PayTo:    payTo,
                    Price:    "$0.01",
                    Network:  network,
                },
            },
            Description: "Read a premium article by slug",
            MimeType:    "application/json",
        },
        // Wildcard — matches /api/v1/anything, /api/v2/other, etc.
        "GET /api/*": {
            Accepts: x402http.PaymentOptions{
                {
                    Scheme:   "exact",
                    PayTo:    payTo,
                    Price:    "$0.001",
                    Network:  network,
                },
            },
            Description: "Premium API access",
            MimeType:    "application/json",
        },
    },
    Facilitator: facilitatorClient,
    Schemes: []ginmw.SchemeConfig{
        {Network: network, Server: evm.NewExactEvmScheme()},
    },
    Initialize: true,
    Timeout:    30 * time.Second,
}))

r.GET("/articles/:slug", func(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{"slug": c.Param("slug"), "content": "Article content..."})
})

r.GET("/api/*path", func(c *gin.Context) {
    c.JSON(http.StatusOK, gin.H{"message": "API response"})
})

routes: dict[str, RouteConfig] = {
    # Named param — matches /articles/any-slug
    "GET /articles/:slug": RouteConfig(
        accepts=[
            PaymentOption(
                scheme="exact",
                pay_to=pay_to,
                price="$0.01",
                network="eip155:84532",
            ),
        ],
        mime_type="application/json",
        description="Read a premium article by slug",
    ),
    # Wildcard — matches /api/v1/anything, /api/v2/other, etc.
    "GET /api/*": RouteConfig(
        accepts=[
            PaymentOption(
                scheme="exact",
                pay_to=pay_to,
                price="$0.001",
                network="eip155:84532",
            ),
        ],
        mime_type="application/json",
        description="Premium API access",
    ),
}

app.add_middleware(PaymentMiddlewareASGI, routes=routes, server=server)


@app.get("/articles/{slug}")
async def get_article(slug: str) -> dict[str, Any]:
    return {"slug": slug, "content": "Article content..."}


@app.get("/api/{subpath:path}")
async def get_api(subpath: str) -> dict[str, Any]:
    return {"path": subpath, "message": "API response"}

routes: dict[str, RouteConfig] = {
    # Named param — matches /articles/any-slug
    "GET /articles/:slug": RouteConfig(
        accepts=[
            PaymentOption(
                scheme="exact",
                pay_to=pay_to,
                price="$0.01",
                network="eip155:84532",
            ),
        ],
        mime_type="application/json",
        description="Read a premium article by slug",
    ),
    # Wildcard — matches /api/v1/anything, /api/v2/other, etc.
    "GET /api/*": RouteConfig(
        accepts=[
            PaymentOption(
                scheme="exact",
                pay_to=pay_to,
                price="$0.001",
                network="eip155:84532",
            ),
        ],
        mime_type="application/json",
        description="Premium API access",
    ),
}

payment_middleware(app, routes=routes, server=server)


@app.route("/articles/<slug>")
def get_article(slug: str):
    return jsonify({"slug": slug, "content": "Article content..."})


@app.route("/api/<path:subpath>")
def get_api(subpath: str):
    return jsonify({"path": subpath, "message": "API response"})

package main

import (
    "fmt"
    "math/rand"
    "net/http"
    "time"

    x402 "github.com/x402-foundation/x402/go"
    x402http "github.com/x402-foundation/x402/go/http"
    ginmw "github.com/x402-foundation/x402/go/http/gin"
    uptoevm "github.com/x402-foundation/x402/go/mechanisms/evm/upto/server"
    "github.com/gin-gonic/gin"
)

func main() {
    payTo := "0xYourAddress"
    network := x402.Network("eip155:84532") // Base Sepolia

    r := gin.Default()

    facilitatorClient := x402http.NewHTTPFacilitatorClient(&x402http.FacilitatorConfig{
        URL: "https://x402.org/facilitator",
    })

    maxPrice := "$0.10" // Maximum the client authorizes

    r.Use(ginmw.X402Payment(ginmw.Config{
        Routes: x402http.RoutesConfig{
            "GET /api/generate": {
                Accepts: x402http.PaymentOptions{
                    {
                        Scheme:  "upto",
                        Price:   maxPrice,
                        Network: network,
                        PayTo:   payTo,
                    },
                },
                Description: "AI text generation - billed by token usage",
                MimeType:    "application/json",
            },
        },
        Facilitator: facilitatorClient,
        Schemes: []ginmw.SchemeConfig{
            {Network: network, Server: uptoevm.NewUptoEvmScheme()},
        },
        Timeout: 30 * time.Second,
    }))

    r.GET("/api/generate", func(c *gin.Context) {
        maxAmountAtomic := 100000 // 10 cents in 6-decimal USDC atomic units
        actualUsage := rand.Intn(maxAmountAtomic + 1)

        // Settle only the actual usage
        ginmw.SetSettlementOverrides(c, &x402.SettlementOverrides{
            Amount: fmt.Sprintf("%d", actualUsage),
        })

        c.JSON(http.StatusOK, gin.H{
            "result": "Here is your generated text...",
            "usage": gin.H{
                "authorizedMaxAtomic": fmt.Sprintf("%d", maxAmountAtomic),
                "actualChargedAtomic": fmt.Sprintf("%d", actualUsage),
            },
        })
    })

    r.Run(":4021")
}

import random
from typing import Any

from fastapi import FastAPI, Response

from x402.http import FacilitatorConfig, HTTPFacilitatorClient, PaymentOption
from x402.http.middleware.fastapi import PaymentMiddlewareASGI, set_settlement_overrides
from x402.http.types import RouteConfig
from x402.mechanisms.evm.upto import UptoEvmServerScheme
from x402.server import x402ResourceServer

app = FastAPI()

pay_to = "0xYourAddress"

facilitator = HTTPFacilitatorClient(
    FacilitatorConfig(url="https://x402.org/facilitator")
)

server = x402ResourceServer(facilitator)
server.register("eip155:84532", UptoEvmServerScheme())

max_price = "$0.10"  # Maximum the client authorizes (10 cents)

routes: dict[str, RouteConfig] = {
    "GET /api/generate": RouteConfig(
        accepts=[
            PaymentOption(
                scheme="upto",
                pay_to=pay_to,
                price=max_price,
                network="eip155:84532",  # Base Sepolia
            ),
        ],
        mime_type="application/json",
        description="AI text generation — billed by token usage",
    ),
}

app.add_middleware(PaymentMiddlewareASGI, routes=routes, server=server)


@app.get("/api/generate")
async def generate(response: Response) -> dict[str, Any]:
    max_amount_atomic = 100000  # 10 cents in 6-decimal USDC atomic units
    actual_usage = random.randint(0, max_amount_atomic)

    # Settle only the actual usage — the client is never charged more than this
    set_settlement_overrides(response, {"amount": str(actual_usage)})

    return {
        "result": "Here is your generated text...",
        "usage": {
            "authorizedMaxAtomic": str(max_amount_atomic),
            "actualChargedAtomic": str(actual_usage),
        },
    }


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=4021)

import random

from flask import Flask, jsonify

from x402.http import FacilitatorConfig, HTTPFacilitatorClientSync, PaymentOption
from x402.http.middleware.flask import payment_middleware, set_settlement_overrides
from x402.http.types import RouteConfig
from x402.mechanisms.evm.upto import UptoEvmServerScheme
from x402.server import x402ResourceServerSync

app = Flask(__name__)

pay_to = "0xYourAddress"

facilitator = HTTPFacilitatorClientSync(
    FacilitatorConfig(url="https://x402.org/facilitator")
)

server = x402ResourceServerSync(facilitator)
server.register("eip155:84532", UptoEvmServerScheme())

max_price = "$0.10"  # Maximum the client authorizes (10 cents)

routes: dict[str, RouteConfig] = {
    "GET /api/generate": RouteConfig(
        accepts=[
            PaymentOption(
                scheme="upto",
                pay_to=pay_to,
                price=max_price,
                network="eip155:84532",  # Base Sepolia
            ),
        ],
        mime_type="application/json",
        description="AI text generation — billed by token usage",
    ),
}

payment_middleware(app, routes=routes, server=server)


@app.route("/api/generate")
def generate():
    max_amount_atomic = 100000  # 10 cents in 6-decimal USDC atomic units
    actual_usage = random.randint(0, max_amount_atomic)

    resp = jsonify({
        "result": "Here is your generated text...",
        "usage": {
            "authorizedMaxAtomic": str(max_amount_atomic),
            "actualChargedAtomic": str(actual_usage),
        },
    })

    # Settle only the actual usage — the client is never charged more than this
    set_settlement_overrides(resp, {"amount": str(actual_usage)})
    return resp


if __name__ == "__main__":
    app.run(host="0.0.0.0", port=4021)

package main

import (
    "context"
    "fmt"
    "math/rand"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"

    "github.com/gin-gonic/gin"
    x402 "github.com/x402-foundation/x402/go"
    x402http "github.com/x402-foundation/x402/go/http"
    ginmw "github.com/x402-foundation/x402/go/http/gin"
    batchsettlement "github.com/x402-foundation/x402/go/mechanisms/evm/batch-settlement"
    batchedserver "github.com/x402-foundation/x402/go/mechanisms/evm/batch-settlement/server"
)

func main() {
    payTo := "0xYourAddress"
    network := x402.Network("eip155:84532") // Base Sepolia

    facilitator := x402http.NewHTTPFacilitatorClient(&x402http.FacilitatorConfig{
        URL: "https://api.cdp.coinbase.com/platform/v2/x402",
    })

    scheme := batchedserver.NewBatchSettlementEvmScheme(payTo, &batchedserver.BatchSettlementEvmSchemeServerConfig{})

    // ChannelManager runs in the background: claims vouchers, settles to your wallet,
    // and refunds idle channels on the configured intervals.
    manager := scheme.CreateChannelManager(facilitator, network)
    manager.Start(batchedserver.AutoSettlementConfig{
        ClaimIntervalSecs:  60,
        SettleIntervalSecs: 120,
        RefundIntervalSecs: 180,
        MaxClaimsPerBatch:  100,
        SelectRefundChannels: func(channels []*batchedserver.ChannelSession, ctx batchedserver.AutoSettlementContext) ([]*batchedserver.ChannelSession, error) {
            var out []*batchedserver.ChannelSession
            for _, c := range channels {
                if c.Balance == "" || c.Balance == "0" {
                    continue
                }
                if c.PendingRequest != nil && c.PendingRequest.ExpiresAt > ctx.Now {
                    continue
                }
                if ctx.Now-c.LastRequestTimestamp < 180_000 {
                    continue
                }
                out = append(out, c)
            }
            return out, nil
        },
        OnClaim:  func(r batchedserver.ClaimResult) { fmt.Printf("Claimed %d vouchers (tx: %s)\n", r.Vouchers, r.Transaction) },
        OnSettle: func(r batchedserver.SettleResult) { fmt.Printf("Settled (tx: %s)\n", r.Transaction) },
        OnRefund: func(r batchedserver.RefundResult) { fmt.Printf("Refunded channel %s\n", r.Channel) },
        OnError:  func(err error) { fmt.Printf("Settlement error: %v\n", err) },
    })

    sigCh := make(chan os.Signal, 1)
    signal.Notify(sigCh, syscall.SIGINT)

    r := gin.Default()

    r.Use(ginmw.X402Payment(ginmw.Config{
        Routes: x402http.RoutesConfig{
            "GET /weather": {
                Accepts: x402http.PaymentOptions{{
                    Scheme:  batchsettlement.SchemeBatched,
                    Price:   "$0.01",
                    Network: network,
                    PayTo:   payTo,
                }},
                Description: "Weather data — billed by usage",
                MimeType:    "application/json",
            },
        },
        Facilitator: facilitator,
        Schemes:     []ginmw.SchemeConfig{{Network: network, Server: scheme}},
        Timeout:     30 * time.Second,
    }))

    r.GET("/weather", func(c *gin.Context) {
        chargedPercent := 1 + rand.Intn(100)
        // Settle a random fraction of the authorized amount
        ginmw.SetSettlementOverrides(c, &x402.SettlementOverrides{
            Amount: fmt.Sprintf("%d%%", chargedPercent),
        })
        c.JSON(http.StatusOK, gin.H{"report": gin.H{"weather": "sunny", "temperature": 70}})
    })

    go r.Run(":4021")

    <-sigCh
    fmt.Println("Shutting down — flushing pending claims…")
    ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
    defer cancel()
    _ = manager.Stop(ctx, &batchedserver.StopOptions{Flush: true})
}

import random
import signal
import sys
from typing import Any

from fastapi import FastAPI
from fastapi import Response as FastAPIResponse

from x402 import x402ResourceServer
from x402.http import FacilitatorConfig, HTTPFacilitatorClient
from x402.http.middleware.fastapi import payment_middleware, set_settlement_overrides
from x402.mechanisms.evm.batch_settlement import SCHEME_BATCH_SETTLEMENT
from x402.mechanisms.evm.batch_settlement.server import (
    AutoSettlementConfig,
    BatchSettlementEvmScheme,
    BatchSettlementEvmSchemeServerConfig,
)

pay_to = "0xYourAddress"
network = "eip155:84532"  # Base Sepolia

facilitator = HTTPFacilitatorClient(
    FacilitatorConfig(url="https://api.cdp.coinbase.com/platform/v2/x402")
)

scheme = BatchSettlementEvmScheme(pay_to, BatchSettlementEvmSchemeServerConfig())
server = x402ResourceServer(facilitator)
server.register(network, scheme)

# ChannelManager runs in the background: claims vouchers, settles to your wallet,
# and refunds idle channels on the configured intervals.
manager = scheme.create_channel_manager(facilitator, network)
manager.start(
    AutoSettlementConfig(
        claim_interval_secs=60,
        settle_interval_secs=120,
        refund_interval_secs=180,
        max_claims_per_batch=100,
        select_refund_channels=lambda channels, ctx: [
            c for c in channels
            if c.balance not in ("", "0")
            and (c.pending_request is None or c.pending_request.expires_at <= ctx.now)
            and ctx.now - c.last_request_timestamp >= 180_000
        ],
        on_claim=lambda r: print(f"Claimed {r.vouchers} vouchers (tx: {r.transaction})"),
        on_settle=lambda r: print(f"Settled (tx: {r.transaction})"),
        on_refund=lambda r: print(f"Refunded channel {r.channel}"),
        on_error=lambda err: print(f"Settlement error: {err}"),
    )
)

app = FastAPI()

routes = {
    "GET /weather": {
        "accepts": {
            "scheme": SCHEME_BATCH_SETTLEMENT,
            "payTo": pay_to,
            "price": "$0.01",
            "network": network,
        },
        "description": "Weather data — billed by usage",
        "mimeType": "application/json",
    },
}


@app.middleware("http")
async def x402_payment_middleware(request, call_next):
    return await payment_middleware(routes, server)(request, call_next)


@app.get("/weather")
async def weather(response: FastAPIResponse) -> dict[str, Any]:
    percent = 1 + random.randint(0, 99)
    # Settle a random fraction of the authorized amount
    set_settlement_overrides(response, {"amount": f"{percent}%"})
    return {"report": {"weather": "sunny", "temperature": 70}}


def _shutdown(signum, frame):
    print("Shutting down — flushing pending claims…")
    manager.stop(flush=True)
    sys.exit(0)


signal.signal(signal.SIGINT, _shutdown)
signal.signal(signal.SIGTERM, _shutdown)


if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=4021, log_level="warning")

"GET /protected": {
    Accepts: x402http.PaymentOptions{
        {
            Scheme:  "exact",
            PayTo:   payTo,
            Network: network,
            Price: map[string]interface{}{
                "amount": "1000",
                "asset":  "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
                "extra": map[string]interface{}{
                    "assetTransferMethod": "permit2",
                },
            },
        },
    },
},

from x402.extensions.eip2612_gas_sponsoring import declare_eip2612_gas_sponsoring_extension
from x402.extensions.bazaar import declare_discovery_extension, OutputConfig

# In your route configuration:
routes = {
    "GET /protected": {
        "accepts": {
            "payTo": "0xYourAddress",
            "scheme": "exact",
            "network": "eip155:84532",
            "price": "$0.001",
            "extra": {"assetTransferMethod": "permit2"},
        },
        "extensions": {
            **declare_discovery_extension(
                output=OutputConfig(
                    example={"message": "Hello, world!"},
                    schema={
                        "properties": {"message": {"type": "string"}},
                        "required": ["message"],
                    },
                )
            ),
            **declare_eip2612_gas_sponsoring_extension(),
        },
    },
}

"GET /protected": {
    Accepts: x402http.PaymentOptions{
        {
            Scheme:  "exact",
            PayTo:   payTo,
            Network: network,
            Price: map[string]interface{}{
                "amount": "1000",
                "asset":  "0xYourTokenAddress",
                "extra": map[string]interface{}{
                    "assetTransferMethod": "permit2",
                },
            },
        },
    },
},

from x402.extensions.erc20_approval_gas_sponsoring import (
    declare_erc20_approval_gas_sponsoring_extension,
)

# In your route configuration:
routes = {
    "GET /protected": {
        "accepts": {
            "payTo": "0xYourAddress",
            "scheme": "exact",
            "network": "eip155:84532",
            "price": {
                "amount": "1000",
                "asset": "0xYourTokenAddress",
                "extra": {"assetTransferMethod": "permit2"},
            },
        },
        "extensions": {
            **declare_erc20_approval_gas_sponsoring_extension(),
        },
    },
}

// Update network to mainnet
network := x402.Network("eip155:8453") // Base mainnet (CAIP-2)

// Create facilitator client for mainnet (CDP)
facilitatorClient := x402http.NewHTTPFacilitatorClient(&x402http.FacilitatorConfig{
    URL: "https://api.cdp.coinbase.com/platform/v2/x402",
    // CDP requires API key authentication. Pass an AuthProvider that adds
    // CDP_API_KEY_ID and CDP_API_KEY_SECRET as auth headers.
    // For a complete working example with CDP auth, see:
    // https://github.com/x402-foundation/x402/tree/main/go/legacy/examples/mainnet
})

r.Use(ginmw.X402Payment(ginmw.Config{
    Routes: x402http.RoutesConfig{
        "GET /weather": {
            Accepts: x402http.PaymentOptions{
                {Scheme: "exact", PayTo: payTo, Price: "$0.001", Network: network},
            },
            Description: "Get weather data for a city",
            MimeType:    "application/json",
        },
    },
    Facilitator: facilitatorClient,
    Schemes: []ginmw.SchemeConfig{
        {Network: network, Server: evm.NewExactEvmScheme()},
    },
    Timeout: 30 * time.Second,
}))

from x402.http import FacilitatorConfig, HTTPFacilitatorClient

facilitator = HTTPFacilitatorClient(
    FacilitatorConfig(url="https://api.cdp.coinbase.com/platform/v2/x402")
)

from x402.http import FacilitatorConfig, HTTPFacilitatorClientSync

facilitator = HTTPFacilitatorClientSync(
    FacilitatorConfig(url="https://api.cdp.coinbase.com/platform/v2/x402")
)

// Polygon mainnet
{
  scheme: "exact",
  price: "$0.001",
  network: "eip155:137", // Polygon mainnet
  payTo: "0xYourAddress",
}

// Solana mainnet
{
  scheme: "exact",
  price: "$0.001",
  network: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp", // Solana mainnet
  payTo: "YourSolanaWalletAddress",
}

// Solana devnet
{
  scheme: "exact",
  price: "$0.001",
  network: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1", // Solana devnet
  payTo: "YourSolanaWalletAddress",
}

// Support multiple networks on the same endpoint
{
  "GET /weather": {
    accepts: [
      {
        scheme: "exact",
        price: "$0.001",
        network: "eip155:8453",
        payTo: "0xYourEvmAddress",
      },
      {
        scheme: "exact",
        price: "$0.001",
        network: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
        payTo: "YourSolanaAddress",
      },
    ],
    description: "Weather data",
  },
}