Overview
What is x402 RPC Proxy?
x402 RPC Proxy is a production-grade, Web3-native RPC gateway and two-sided marketplace that provides secure, metered, and monetizable access to blockchain infrastructure.
At its core, x402 solves a fundamental gap in the Web3 ecosystem: there is no standardized, enforceable economic model for RPC access. Public endpoints are rate-limited and unreliable. Private endpoints have no built-in payment layer. Providers have no mechanism to monetize infrastructure fairly. x402 addresses all of these at the protocol level.
x402 acts as a unified intermediary layer between API consumers (developers, applications, autonomous agents) and RPC providers (infrastructure operators, node services). It enforces authentication, metering, and payment before any request reaches an upstream node — making RPC access programmable, auditable, and economically sovereign.
The x402 Protocol
The name "x402" references HTTP 402 Payment Required — a status code reserved since 1991 for future use in micropayment systems. x402 fulfills this vision for blockchain infrastructure:
- When a client has insufficient credits, the gateway returns
402 Payment Requiredwith structured payment metadata - The client resolves the payment on-chain
- Credits are issued and the request proceeds
This creates a machine-readable, protocol-native payment enforcement mechanism compatible with both human-operated clients and autonomous AI agents.
Platform Architecture at a Glance
x402 operates as a four-layer system:
┌─────────────────────────────────────────────┐
│ Client Layer │
│ Apps · Backends · AI Agents · Wallets │
└─────────────────────┬───────────────────────┘
│ JSON-RPC 2.0 / REST
┌─────────────────────▼───────────────────────┐
│ Gateway Layer (x402) │
│ Auth · Credit Check · Routing · Metering │
└──────┬────────────────────────┬─────────────┘
│ │
┌──────▼──────┐ ┌────────▼────────────┐
│ Payment & │ │ RPC Provider │
│ Credit │ │ Layer │
│ Layer │ │ EVM · Cosmos · │
│ │ │ Solana (planned) │
└─────────────┘ └─────────────────────┘Every request follows a deterministic lifecycle:
- Client sends a JSON-RPC 2.0 request to
/mcp - Gateway validates the JWT (wallet-issued session token)
- Credit balance is checked for the authenticated address
- If insufficient →
402 Payment Requiredis returned with plan metadata - If sufficient → credits are atomically deducted
- Request is routed to the appropriate RPC provider
- Response is returned transparently to the client
See the Architecture guide for a full breakdown of each layer.
Who Uses x402?
RPC Consumers
Developers, application backends, and autonomous agents that require reliable blockchain access:
- Access all supported chains through a single unified endpoint (
/mcp) - Authenticate using wallet-native standards — no API keys or passwords
- Pay on-chain and receive credits; spend credits per request
- Benefit from automatic failover across multiple providers
- Monitor usage, credit balance, and payment history via dashboard
Typical consumer profiles:
| Profile | Use Case |
|---|---|
| dApp Backend | Contract reads/writes with predictable cost |
| Indexing Service | High-volume eth_getLogs and historical queries |
| AI Agent | Autonomous blockchain queries with built-in payment resolution |
| Internal Tooling | Enterprise teams with controlled spend per wallet |
RPC Providers
Infrastructure operators publishing RPC endpoints to the marketplace:
- Register and manage multi-chain RPC endpoints across protocols (JSON-RPC, REST, gRPC, WebSocket)
- Serve EVM, Cosmos, and Solana (planned) traffic through a standardized interface
- Earn revenue proportional to verified request volume
- Participate in the marketplace without managing billing, auth, or metering directly
Note
Pricing plans are defined and managed by the platform to ensure consistency and fairness across providers.
Supported Chains & Protocols
Blockchain Ecosystems
| Ecosystem | Auth Standard | Status |
|---|---|---|
| EVM (Ethereum, Polygon, Arbitrum, Base, ...) | SIWE — Sign-In with Ethereum | Available |
| Cosmos (Cosmos Hub, Osmosis, ...) | SIWC — Sign-In with Cosmos | Available |
| Solana | SIWS — Sign-In with Solana | Coming Soon |
Transport Protocols
| Protocol | Use Case |
|---|---|
| JSON-RPC | Standard EVM and Cosmos RPC calls |
| REST | REST-based chain APIs (e.g., Cosmos LCD) |
| gRPC | High-performance binary transport |
| WebSocket | Subscriptions and streaming event feeds |
Authentication Model
x402 uses wallet-native authentication — no usernames, passwords, or API keys. Identity is proven cryptographically at the session level.
How It Works
- Client requests a one-time nonce tied to their wallet address
- Wallet signs a structured message (EIP-4361 for Ethereum, equivalent for Cosmos)
- Gateway verifies the signature on-chain and issues a JWT access token
- All subsequent requests carry the JWT in the
Authorizationheader - Tokens expire after 1 hour; refresh tokens enable seamless re-authentication
Supported Standards
| Standard | Description |
|---|---|
| SIWE | Sign-In with Ethereum (EIP-4361) |
| SIWC | Sign-In with Cosmos (ADR-036 equivalent) |
| SIWS | Sign-In with Solana (planned) |
See the Authentication guide for the full flow, token management, and error handling.
Payment & Credit Model
x402 introduces a credit-based metering system backed by verifiable on-chain payments.
Credit Tiers by Method Type
| Method Category | Examples | Credits |
|---|---|---|
| Standard reads | eth_blockNumber, eth_getBalance | 1 |
| Historical queries | eth_getLogs, eth_getStorageAt | 5 |
| Write operations | eth_sendRawTransaction | 10 |
Pricing Plans
| Plan | Asset | Amount | Credits | Cost per Credit |
|---|---|---|---|---|
| Starter | USDC | $10 | 10,000 | $0.001 |
| Pro | USDC | $50 | 60,000 | $0.00083 |
| Enterprise | Custom | Custom | Custom | Negotiated |
Credits are non-expiring and tied to the wallet address across chains.
See the Payments guide for the full payment flow and API reference.
Security Model
| Layer | Mechanism |
|---|---|
| Identity | Wallet signature verification (no shared secrets) |
| Session | Short-lived JWT with cryptographic signing |
| Request | Credit check enforced before any upstream call |
| Payment | On-chain transaction verification (not self-reported) |
| Abuse prevention | Credit exhaustion triggers hard stop, not soft degradation |
| Token hygiene | Single-use refresh tokens; full revocation on logout |
Key properties:
- Non-custodial — x402 never holds private keys or manages wallets
- Verifiable — all payment claims are verified against on-chain state
- Deterministic — credits are deducted atomically before request execution
- Auditable — full payment and usage history is queryable via API
Reliability & Failover
- Multi-provider routing — each chain can have multiple registered providers
- Automatic failover — on provider failure, traffic is rerouted seamlessly
- Retry policies — configurable retry behavior per provider
- Stateless gateway — horizontal scaling with no shared state beyond session tokens
Rate Limits
Requests are governed by credits rather than traditional rate limits. Soft connection limits apply per tier:
| Tier | Max Requests/sec |
|---|---|
| Standard | 50 |
| Pro | 200 |
| Enterprise | Unlimited |
Design Principles
| Principle | Description |
|---|---|
| Marketplace-first | Two-sided platform connecting providers and consumers |
| Protocol-native | Built on open standards: JSON-RPC 2.0, SIWx, HTTP 402 |
| Chain-agnostic | Consistent interface and economics across ecosystems |
| Economic sovereignty | Consumers pay on-chain; no intermediary custody |
| Deterministic metering | Credits enforced atomically — no ambiguous billing |
| Enterprise-ready | Scalable, observable, extensible, and auditable |
Value Proposition
For Consumers
- Unified access to all supported chains through one endpoint and credential
- Pay-as-you-go model with on-chain, verifiable payments
- No vendor lock-in — wallet-based identity works across any client
- Works for agents — HTTP 402 is machine-readable; autonomous systems can self-fund and resume
For Providers
- Monetization without complexity — no billing infrastructure to build or maintain
- Revenue tied to actual usage — no flat-rate commitments
- Protocol-level enforcement — the gateway handles all payment and auth
For the Ecosystem
- Standardized economic layer for metered RPC access
- Foundation for autonomous Web3 agents that pay their own way
Getting Started
| Step | Guide |
|---|---|
| 1. Authenticate with your wallet | Authentication |
| 2. Purchase credits on-chain | Payments |
| 3. Send your first RPC request | Quickstart |
| 4. Explore all available methods | MCP Endpoint |
| 5. Understand system internals | Architecture |
x402 establishes a foundational economic infrastructure layer for the next generation of multi-chain, pay-per-use applications — and the autonomous agents that will operate them.