x402 Payments for AI Agents

Autonomous payment protocol for AI agents using HTTP 402 + stablecoins.

What is x402?

x402 is an open standard for internet-native payments. It enables AI agents to pay for API calls automatically using stablecoins, without accounts or human intervention.

How it works:

Agent requests API endpoint
Server responds with HTTP 402 + payment details
Agent signs payment authorization
Payment settled on blockchain
Request fulfilled automatically

Key benefits:

No accounts or API keys
Instant settlement
Micropayments per request
Blockchain-agnostic (EVM + Solana)
Perfect for autonomous agents

Quick Start

Check if endpoint supports x402

neckr0ik-x402-payments check https://api.example.com/premium

Pay for API access

neckr0ik-x402-payments pay https://api.example.com/premium --amount 0.01

Accept payments (for your API)

neckr0ik-x402-payments serve --port 8080 --price 0.01

Payment Flow

Agent                x402 Facilitator           API Server
  |                        |                        |
  |-- GET /premium ------>|----------------------->|
  |                        |                        |
  |<-- HTTP 402 -----------|------------------------|
  |    (payment required)  |                        |
  |    {amount, address,   |                        |
  |     chain, facilitator}|                        |
  |                        |                        |
  |-- Sign payment ------>|                        |
  |                        |                        |
  |                        |-- Submit to chain --->|
  |                        |                        |
  |                        |<-- Confirmation ------|
  |                        |                        |
  |-- GET /premium --------|----------------------->|
  |    PAYMENT-SIGNATURE   |                        |
  |                        |                        |
  |<-- 200 OK -------------|------------------------|
  |    (data)              |                        |

Supported Chains

Ethereum (Mainnet, L2s)
Polygon
Base
Arbitrum
Optimism
Solana

Supported Stablecoins

USDC
USDT
DAI

Commands

check

Check if an endpoint supports x402 payments.

neckr0ik-x402-payments check <url>

Options:
  --timeout <ms>    Request timeout (default: 10000)

pay

Pay for API access and receive data.

neckr0ik-x402-payments pay <url> [options]

Options:
  --amount <amount>    Maximum amount to pay (in USD)
  --chain <chain>      Preferred chain (default: base)
  --token <token>      Stablecoin token (default: usdc)
  --wallet <address>   Wallet to use for payment
  --dry-run            Show payment details without paying

serve

Start an x402-enabled API server.

neckr0ik-x402-payments serve [options]

Options:
  --port <port>        Server port (default: 8080)
  --price <amount>     Price per request (in USD)
  --chain <chain>      Accept payments on chain (default: base)
  --token <token>      Accept stablecoin (default: usdc)
  --wallet <address>   Receiving wallet address

balance

Check your payment wallet balance.

neckr0ik-x402-payments balance [options]

Options:
  --chain <chain>      Chain to check (default: all)

history

View payment history.

neckr0ik-x402-payments history [options]

Options:
  --limit <n>         Number of transactions (default: 10)
  --chain <chain>      Filter by chain

Configuration

Set up your wallet for payments:

# Set wallet private key (stored securely)
neckr0ik-x402-payments config set wallet.private_key <key>

# Or use environment variable
export X402_PRIVATE_KEY=<key>

# Set receiving address for payments
neckr0ik-x402-payments config set wallet.address <address>

Use Cases

As an Agent (Pay for API Access)

# Before: Need API key, account, subscription
response = requests.get("https://api.example.com/data", 
    headers={"Authorization": "Bearer YOUR_API_KEY"})

# After: Autonomous payment, no account needed
response = x402.get("https://api.example.com/data")

As a Provider (Accept Payments)

from x402 import PaymentMiddleware

app = Flask(__name__)
app.wsgi_app = PaymentMiddleware(app.wsgi_app, price=0.01)

@app.route("/premium-data")
def premium_data():
    return {"data": "only accessible after payment"}

# Requests to /premium-data automatically require payment

Security

Private keys never leave your machine
Payments signed locally
Transaction broadcast through facilitators
All settlements verified on-chain
Payment receipts stored for audit

Neckr0ik X402 Payments