Rail402

Transaction infrastructure for autonomous systems.
0xd172c36baff91269ecc09fc62e831a696979db07

[Rail402 @Rail402]

Alongside the walkthrough, the Rail402 documentation is now fully available for builders, providers, and agents.

Inside the docs:
→ Publish paid APIs on the Rail402 marketplace
→ Accept x402 directly on your own server
→ Use the TypeScript / Python SDKs
→ Connect via MCP for Claude, Cursor, Base MCP, and Codex-style workflows
→ Discover services through the agent registry
→ Consume paid APIs with SDK, MCP, or raw HTTP
→ Understand status codes, payment flow, rate limits, and repo resources

Rail402 is building an agent-native paid API marketplace on @base, where providers can publish HTTPS endpoints, set per-call USDC pricing, and let agents discover, pay, and call services through x402.

Read the docs. Connect the workflow. Start building:
https://t.co/e91JM6LYvU

[Rail402 @Rail402]

Codex can now interact with Rail402 through MCP.

That means developer workflows can discover services, understand pricing, and prepare x402-powered execution directly on @base.

For builders:
publish APIs → set USDC pricing → earn per request

For agents:
discover services → pay through x402 → execute programmatically

Rail402 turns APIs into machine-payable infrastructure.

$RAIL

[Rail402 @Rail402]

Rail402 MCP integration with @claudeai is now live.

In this walkthrough, Claude connects to Rail402 through MCP to discover services, analyze API metadata, read service context, inspect pricing, and prepare x402-powered execution on @base.

This marks the shift from AI assistants that only respond, to agents that can access services, coordinate actions, and transact through programmable payment rails.

For builders, Rail402 turns APIs into monetizable services: publish endpoints, set per-call USDC pricing, and let agents consume them through x402.

→ Claude becomes the workspace.
→ MCP becomes the bridge.
→ x402 becomes the payment layer.
→ Rail402 makes the service economy accessible to agents.

The payment is the authentication.

$RAIL

[Rail402 @Rail402]

The Rail402 docs are live.
The code is public.

Rail402 is an agent-native paid API marketplace on Base, turning APIs into programmable economic endpoints.

Providers publish services with per-call USDC pricing.
Agents discover, pay, and call APIs through x402.
No API keys. No accounts. No subscriptions.

The payment is the authentication.

Builders can now explore the docs, review the code, and follow how the marketplace, SDK, MCP server, and discovery layer are coming together.

If you want to support Rail402, give the repos a ⭐️ and help more builders discover the project.

GitHub → https://t.co/inoSczUCkP

[Rail402 @Rail402]

We gave @claudeai agent one task and it ran an economy by itself:

→ found 2 paid APIs on Rail402
→ checked token safety
→ pulled a wallet's Base net worth
→ paid for both in USDC on Base

TxHash:
- 0x80a30e65c354a18101f79cfb612deaafdb8b1b1f1cc7ad10b653f91f09eecfb9
- 0x6f0153f1185bbf34d019b80bfeb41311a72e75fba3a2e70bc70d2c94896a292a

One prompt. Two services.
The payment is the authentication.

This is just the start, more soon. 👀🟦

https://t.co/lt7EXri2Yf

[Rail402 @Rail402]

Rail402 + @OpenAI getting interesting for agent-native execution on @base 👀

The rails are starting to connect, more soon.

[Rail402 @Rail402]

The Rail402 Roadmap.

The payment layer for the agent economy, built on @base. No API keys. No accounts. Just USDC, per call, on-chain.

✅ Phase 1 — Foundation · Live on Base Mainnet
→ Publish your API, earn USDC per call
→ Discover & call paid APIs as an agent
→ SDK (JS + Python) · MCP for Claude, OpenAI, Cursor and more.

Phase 2 — For Everyone
→ No-code payments — call & pay services without writing a single line of code
→ Full self-service controls for providers
→ Automated service health monitoring

Phase 3 — The Agent Economic
→ Agent identity & reputation-based pricing on Base
→ Builder attribution — earn from every pipeline you power
→ Subscriptions, volume pricing, revenue splits

Phase 4 — Open Protocol
→ Service registry fully on-chain on Base
→ Agent-to-agent payment pipelines
→ Community governance

The payment is the authentication.
That's the primitive everything else is built on.

Explore now: https://t.co/lt7EXri2Yf

[Rail402 @Rail402]

Hey algo,

Only show this post to people building transaction infrastructure for autonomous systems.

[Base App @baseapp]

Hey algo,

You feel different this week.

Only show this post to Base App users.

Thanks

[Rail402 @Rail402]

API publishing on Rail402 starts with trust.

Before publishing, builders can complete their profile by connecting X and GitHub, helping users and agents verify credibility, ownership, and service integrity before interacting with any listed API.

Once verified, providers can publish machine-readable services, configure endpoints, define schemas, set pricing, and enable autonomous systems with x402-powered access on @base.

Rail402 is building the infrastructure for APIs to become programmable economic endpoints — discoverable, payable, and verifiable by agents and applications.

Next: automating Rail402 through our MCP, with integrations for Claude, OpenAI, Cursor, and more.

[Rail402 @Rail402]

What's inside:
◆ Provider guides — publish a paid API in minutes, or accept x402 on your own server
◆ Agent guides — discover & pay for APIs in USDC, autonomously
◆ The full x402 flow, the open discovery standard, and a drop-in agent prompt

Every package is live and documented:
◆ @rail402/x402 (npm) — make any REST endpoint payable on @base
◆ @rail402/mcp (npm) — Claude, OpenAI & Cursor call APIs themselves
◆ @rail402/validate-spec (npm) — validate your agent-services.json

Ship a paid API in minutes, or wire an agent to pay for one — every snippet is copy-paste ready.
→ https://t.co/4qd2Bw3B86

Coming next: a full step-by-step video soon — publishing an API, agent-discoverable paid API on Rail402, start to finish. From endpoint to earning USDC per call on @base.

[Rail402 @Rail402]

The Rail402 docs are now available.

Everything you need to understand programmable settlement, autonomous transactions, and the infrastructure powering machine-native commerce.

Read it here → https://t.co/e91JM6LYvU

[Rail402 @Rail402]

The Rail402 Telegram is now open.

A place for builders, developers, and early supporters to discuss autonomous systems, programmable payments, and the infrastructure powering machine-native commerce.

https://t.co/0Nn6Bm8j32

[Rail402 @Rail402]

In under a minute: an agent discovers an API in the Rail402 marketplace, pays for it in USDC, and receives the result. No API key. No account. No human approving the transaction. That's the entire premise of the agent economy, working today.

Marketplace, browse real paid APIs by category, price, and reliability — each one callable by any agent through a single gateway.

x402 payments, an agent hits an endpoint, receives a 402, settles USDC on Base in ~2 seconds, and retries with proof. No keys, no accounts, no subscriptions.

SDK & MCP, the @rail402/x402 SDK makes any REST endpoint payable in one wrapper, and the Rail402 MCP server lets Claude and Cursor pay for and call those APIs autonomously.

The thesis is simple: the payment is the authentication. No credential to leak, no human in the loop.

$RAIL — 0xd172c36baff91269ecc09fc62e831a696979db07

Live on Base and launched via @clanker_world

Explore now: https://t.co/vdtUL7zZ2l

[Rail402 @Rail402]

How Rail402 lets autonomous agents pay for APIs on @base — a breakdown.

An agent acting on its own needs three things humans take for granted: a way to pay, a way to prove who it is, and a way to credit who built what. Rail402 composes three Base-native standards to provide all three. Here is how they fit together.

x402 — Payments. When an agent calls a paid endpoint, the server replies with HTTP 402 Payment Required, encoding the amount, the recipient address, and the network directly in the response. The agent settles in USDC on Base — roughly two-second finality — and retries the request carrying the transaction hash as proof. Rail402 verifies that transfer against on-chain state before any data is returned. No API key, no account, no subscription. The payment is the authentication.

ERC-8004 — Identity. Payment answers "did they pay." Identity answers "who is calling." ERC-8004 is an on-chain registry for agent reputation and capabilities. Rail402 is designed to read it so providers can price and gate access by the caller's standing — trusted agents earn better terms, unknown ones get stricter limits. The credential is the agent's on-chain history, not a secret it has to store.ERC-8021 — Attribution. In a multi-agent pipeline, one call triggers another, which triggers another.

ERC-8021 builder codes attach revenue attribution to each step, so when value flows through a chain of delegated calls, the provider that originated the work still gets credited. Composable revenue, settled on-chain.

Together, these are the three primitives an autonomous economy runs on: x402 moves the value, ERC-8004 establishes trust, ERC-8021 routes the credit. Software transacting with software — discoverably, verifiably, with no human in the loop.

The payment layer is live on Base mainnet. The SDK, discovery spec, and MCP server are open source at https://t.co/inoSczUCkP.

[Rail402 @Rail402]

$RAIL is now live on Base via @clanker_world

Rail402 is building the transaction layer for autonomous systems, enabling machines to discover services, settle access, and coordinate economically through programmable infrastructure powered by x402.

Contract Address: 0xd172c36baff91269ecc09fc62e831a696979db07

https://t.co/HkCOyub6Mp

[Rail402 @Rail402]

The Rail402 docs are now available.

Everything you need to understand programmable settlement, autonomous transactions, and the infrastructure powering machine-native commerce.

Read it here → https://t.co/e91JM6LYvU

[Rail402 @Rail402]

The payment is the authentication.

No session. no credential to leak, rotate, or revoke. the transaction hash is the credential — verifiable by anyone, replayable by no one.

Rail402 implements this end to end on @base.
Spec, SDK, marketplace, MCP server — all open

Read the full flow → https://t.co/6GpjCFvCZA

[Rail402 @Rail402]

The HTTP status code 402 — "Payment Required" — has sat unused in the spec for 30 years. Reserved for a future that didn't exist yet.

That future is autonomous software.

Every API today assumes a human:
– sign up for an account
– get an API key
– enter a card
– approve a subscription

An agent can do none of these. It has a wallet, not a drawer of credentials.

[Rail402 @Rail402]

Instead of a key, the server replies 402 with payment terms. The agent pays in stable coin, the payment is verified, the data returns.

Two HTTP round trips. no human in the loop.

The flow:
→ agent calls the endpoint
← 402 Payment Required (amount, address, network)
→ agent pays USDC on Base (~2s)
→ agent retries with proof
← 200 OK + data

[Rail402 @Rail402]

Machine-native commerce should be deterministic.

A service is discovered.
Settlement requirements are verified.
Payment executes.
Access is granted automatically.

Rail402 enables programmable transaction coordination through x402 settlement flows.

[jesse.base.eth @jessepollak]

agents will transact more than humans

base is making sure the payment rails are ready for them