ERPC Launches x402-Enabled Solana RPC — Opening the Era Where AI Agents Pay for the APIs They Need on Demand

ELSOUL LABO B.V. (Headquarters: Amsterdam, the Netherlands; Representative Director and CEO: Fumitake Kawasaki) and Validators DAO, the operators of ERPC, are pleased to announce the launch of an x402-enabled Solana mainnet JSON-RPC proxy.

The newly launched service is a production-ready x402-enabled Solana RPC available on x402.erpc.global. Users, applications, and AI agents can send Solana JSON-RPC requests to POST https://x402.erpc.global/v1/solana-mainnet. When payment is required, ERPC returns HTTP 402 Payment Required with an x402 payment challenge. The client can then attach a USDC stablecoin payment payload on Solana mainnet and retry the same request to receive the Solana RPC result after payment verification and settlement.

Until now, API payments have mostly followed a model where a human signs up first, obtains an API key, and AI systems or bots use that key afterward. With x402, AI agents and programs can read payment terms presented at request time, pay within the budget and permission boundaries set by their owner, and access the API they need on the spot. ERPC has implemented this flow for a concrete infrastructure use case: Solana RPC.

Paid RPC endpoint: POST https://x402.erpc.global/v1/solana-mainnet Pricing: https://x402.erpc.global/pricing OpenAPI: https://x402.erpc.global/doc Service discovery: https://x402.erpc.global/.well-known/x402

x402 is an open payment protocol that brings the HTTP 402 Payment Required status code into modern web and API payments.

In the traditional API model, users create an account for each service, register a payment method, generate an API key, and manage subscriptions or prepaid credits. That flow works for humans signing up through a browser. It is too heavy for software and AI agents that need to choose services dynamically and pay only for what they use.

With x402, when a client accesses a paid resource, the server first responds with 402 Payment Required. The response includes payment terms: how much to pay, on which network, and with which asset. The client constructs a payment payload according to those terms and retries the same request with proof of payment. The server verifies and settles the payment, then returns the requested API response or content if everything is valid.

In other words, x402 turns paid web API access into a natural HTTP request / response conversation: this operation costs this amount; payment has been submitted; the result can now be returned.

ERPC's x402-enabled Solana RPC is a Solana mainnet JSON-RPC proxy running on Cloudflare Workers. Payment verification and settlement use the Coinbase CDP x402 facilitator, with USDC stablecoin payments on Solana mainnet. /.well-known/x402 publishes x402 version 2, the facilitator URL, Solana mainnet, USDC, and the POST endpoint at /v1/solana-mainnet.

On the first request, the client sends a normal Solana JSON-RPC body. If the request does not include X-Payment, ERPC returns 402 Payment Required together with the x402 challenge, RPC method weight, and USD-denominated price information.

The client then constructs a USDC stablecoin payment payload on Solana mainnet and retries the same JSON-RPC body with the X-Payment header. ERPC asks the facilitator to verify and settle the payment, receives a settlement receipt, and proxies the request to the upstream Solana RPC. The client receives the JSON-RPC result together with an X-Payment-Response receipt. For compatibility, ERPC also accepts Payment-Signature as a legacy header.

To prevent duplicate payment use, reused signatures are handled as 409 duplicate_payment. Invalid payments or insufficient amounts are returned as 402 payment_invalid or payment_amount_too_low.

Pricing follows ERPC's canonical token model: each method's raw weight is multiplied by 0.000001 USD. Standard JSON-RPC methods are 42 tokens, getProgramAccounts is 4200 tokens, getTokenLargestAccounts is 2400 tokens, and getMultipleAccounts adds 420 tokens per pubkey. To match the facilitator's minimum settlement amount, a 0.001 USD minimum charge applies to the whole request. For example, getSlot has a raw weight of 42 tokens, but the billed weight becomes 1000 tokens, or 0.001 USD, after the minimum charge is applied.

Free probe endpoints are also available: GET /health, GET /pricing, and GET /.well-known/x402. /pricing shows each Solana RPC method's raw weight, weight after minimum charge, and USD-denominated price.

One important implication of x402 support is that APIs and RPC can be handled at near-micropayment granularity.

Until now, infrastructure such as RPC has typically been sold through monthly plans, fixed quotas, prepaid credits, or postpaid invoices. With that model, users tend to reserve more capacity than they actually need. Unused credits are wasted, while sudden usage spikes create quota limits or require additional purchases. This mismatch is especially visible for workloads such as AI agents and bots that may read heavily only when needed and then stay almost idle.

With mechanisms such as x402, a service can present a price per API request, data retrieval, or operation, and the client can pay only for what it needs. ERPC's pricing model is also designed around each method's raw weight multiplied by 0.000001 USD. The current endpoint applies a 0.001 USD floor to the whole request to match the facilitator minimum settlement amount, but the base unit is designed at the granularity of 1 token = 0.000001 USD.

This is not realistic with traditional card payments. At 0.1 cent per request, or even smaller units, payment fees and approval flows can exceed the value of the payment itself. Stablecoin payments and internet-native payment protocols such as x402 make it practical to embed these small payments directly into API request / response flows.

Batch JSON-RPC requests can also combine multiple read-only calls into one request, applying the floor once to the total weight. For example, multiple lightweight status methods can be called together without paying a separate minimum charge for each call, allowing the request as a whole to be paid more efficiently.

In that sense, ERPC's x402 support is a step from "contract first, then use RPC" toward "pay on the spot for the data you read." This payment granularity becomes important as AI agents begin to combine many external services depending on context.

AI agents are beginning to write, research, code, monitor, find trading opportunities, and operate infrastructure autonomously. These tasks often require paid external resources at the moment they are needed: APIs, datasets, RPC endpoints, storage, compute, analytics services, authentication services, and more.

For humans, it is normal to sign a SaaS contract, review an invoice, and issue an API key before using a service. But if an AI agent makes thousands or tens of thousands of small decisions while working, requiring human approval for every contract or payment stops the workflow.

The next model is for an AI agent to read that a piece of data costs 0.001 USD or that a computation requires a certain amount, pay within the budget, permissions, and policies defined by its owner, receive the result, and record the payment receipt. The key point is not that AI should pay without limits. The point is that necessary payments can be automated within spending limits, permitted purposes, and approved service scopes defined by humans and organizations.

This is not merely automated checkout. It is payment infrastructure for machines: AI agents, bots, APIs, IoT devices, robots, and monitoring systems exchanging value at the moment a service is needed. In the future, Agent-to-Agent / Machine-to-Machine billing will become natural: one agent pays another for a task, an AI pays for each data API call, and a monitoring system pays for high-precision analysis only when an anomaly appears.

McKinsey estimates that agentic commerce could orchestrate between USD 3 trillion and USD 5 trillion globally by 2030. AI is already becoming an entry point for search, comparison, recommendations, and decision support. As identity, authorization, and payments mature, AI agents are expected to move deeper into purchasing and service execution.

At the same time, internet-native payment protocols such as x402 are already showing large-scale transaction activity and experimental use cases. The x402 official site publishes live metrics for transactions, volume, buyers, and sellers over the past 30 days. Circle has noted that x402 processed more than USD 100 million in payments in its first few months. Chainalysis has also analyzed that x402 agentic payments on Base crossed 100 million transactions by Q1 2026.

These numbers show that x402 is not merely a concept, but has already entered a phase of high-frequency machine payment experimentation and usage. The market is still early, but the infrastructure is rapidly forming for a world where APIs, data, compute, and digital services can be paid for at request granularity.

McKinsey: https://www.mckinsey.com/capabilities/quantumblack/our-insights/europes-agentic-commerce-moment-decision-influence-is-here-execution-is-coming x402: https://x402.org/ Circle: https://www.circle.com/blog/nanopayments-powered-by-circle-gateway-is-now-live-on-mainnet Chainalysis: https://www.chainalysis.com/blog/x402-agentic-payments-adoption/

For Solana applications, RPC is not a side feature. Balance checks, slot queries, account reads, program account searches, transaction status checks, block retrieval, and real-time monitoring all depend on RPC.

As AI agents begin to inspect Solana state, make decisions, and take action, RPC becomes close to their eyes and hands. The agent decides which account to inspect, which program to query, when to check again, and how deeply to search.

In that environment, monthly contracts and fixed quotas alone do not always match fine-grained usage. If an agent can call the exact RPC method it needs, at the exact moment it needs it, and pay for that request directly, it can combine external services more flexibly.

ERPC's x402 support is a production-ready first step toward that world. AI agents and programs can treat Solana RPC not only as a precontracted fixed service, but also as a service primitive they can pay for and use on demand.

For developers, x402-enabled ERPC provides a real environment for testing agentic workflows and pay-per-use API designs.

For example, a research agent that needs to inspect Solana account state can first send an RPC request to ERPC. If payment is required, the agent reads the required amount from the 402 response, confirms that it is within budget, constructs the USDC stablecoin payment payload, and retries the request. ERPC verifies the payment and returns the RPC result. The agent can save both the result and the receipt to its task log.

The same flow can be used by bots, monitoring systems, data collection pipelines, MCP servers, and AI agent runtimes. Developers can test service composition at the level of a task, API call, or data request, instead of depending only on monthly fixed contracts.

For service providers, x402 also makes API monetization more granular. Small APIs, specialized data, short compute jobs, and individual analytics results can be priced in units that traditional payment systems could not easily support.

ELSOUL LABO and Validators DAO have continuously improved the infrastructure required for Solana applications and validator operations through Solana RPC, Geyser gRPC, Shredstream, SLV, SLV AI, Validators Solutions, and the AS200261 Solana-specialized data center.

AI agent payments connect naturally with that work. As AI supports development and operations, selects the data or compute it needs, and pays for it when needed, infrastructure becomes more than a service contracted by humans. It becomes a set of primitives that agents can compose autonomously.

By adopting internet-native payment protocols such as x402 early and exposing them through a concrete Solana RPC use case, we are advancing the real-world implementation of AI agent payments.

This is not only a story about the future. The endpoint already returns HTTP 402, accepts USDC stablecoin payment, runs Solana RPC, and returns a receipt.

ERPC will continue improving its performance as Solana-specialized infrastructure while also researching and developing payment, authorization, and execution layers that are easier for AI agents and autonomous systems to use.

This endpoint is for paying ERPC Solana RPC usage fees through x402. It does not provide crypto asset exchange, brokerage, custody, or wallet services.

Paid RPC endpoint: POST https://x402.erpc.global/v1/solana-mainnet ERPC pricing: https://x402.erpc.global/pricing ERPC OpenAPI: https://x402.erpc.global/doc ERPC x402 service discovery: https://x402.erpc.global/.well-known/x402 ERPC Website: https://erpc.global/en ERPC Dashboard: https://dashboard.erpc.global/en

For inquiries about ERPC, x402-enabled Solana RPC, Solana RPC, Geyser gRPC, Shredstream, and infrastructure for AI agents, please contact us through the ERPC Dashboard.

ERPC Dashboard: https://dashboard.erpc.global/en