Solana Foundation Launches Pay.sh With Google Cloud — The Gateway To Agentic Commerce
The Solana Foundation, in collaboration with Google Cloud, has launched Pay.sh, a gateway service that lets AI agents discover, access, and pay for APIs — no accounts, no API keys, no subscriptions. Just a Solana wallet and stablecoins. Pay.sh represents the first serious attempt at machine-native commerce — payments designed for agents, not humans. And it’s built on a stack of open standards — x402 and MPP — that are quietly redefining how machines pay each other over HTTP.
Let’s break down what launched, how it works, and where it fits alongside comparable protocols.
What Exactly is Pay.sh?
Pay.sh is a Gateway as a Service — an API proxy sitting on Google Cloud Platform that handles account-less payment settlement for enterprise services. Here’s the flow:
- An AI agent (or CLI tool) discovers an API endpoint from Pay.sh’s unified catalog
- It receives a live per-request rate in stablecoins
- It pays from its Solana wallet — settlement in seconds
- The gateway proxies the request to the provider and returns the response
With No billing accounts, no rotating credentials, no minimum spend. At launch, Pay.sh supports official Google Cloud APIs (Gemini, BigQuery, Vertex AI, Cloud Run, BigTable) plus 75+ community-sourced endpoints across categories like e-commerce (Rye, BigCommerce), data intelligence (Exa, Dune Analytics, Nansen), communications (AgentMail, StableEmail), and Solana infrastructure (Helius, Alchemy, QuickNode, The Graph).
Onboarding is designed to be quite simple: link a Solana wallet to your AI interface (Gemini, Claude Code, Codex, Openclaw, Hermes), on-ramp with a credit card or stablecoin in 60 seconds, and your agent is ready to spend. The entire project is open source on GitHub.
The Protocols Under The Hood: x402 and MPP
Pay.sh isn’t inventing a new payment protocol — it’s a coordinated gateway built on two emerging open standards.
x402 — The Stateless Execution Layer
x402 is Coinbase’s open payment standard, launched in May 2025. It’s beautifully simple: when a server requires payment, it responds with HTTP 402 Payment Required and a PAYMENT-REQUIRED header specifying amount, recipient address, and chain. The agent pays on-chain (USDC on Base, Ethereum, or Solana), then retries with a PAYMENT-SIGNATURE header. The server validates and returns a receipt.
Key properties:
- Stateless — every request stands alone. No sessions, no pre-auth, no vouchers.
- Sub-2-second settlement with transaction costs around $0.0001.
- Zero protocol fees — just nominal network costs.
- Zero centralization — anyone can extend or build on it.
- Vending machine model — pay, get resource, done.
x402 is the execution layer for Pay.sh. Each API call behind the gateway uses an x402-style flow: the agent pays per-request, the gateway validates, and the resource is delivered. Solana’s 400ms finality and sub-cent fees make it an ideal settlement backbone for this model.
MPP — The Session-Based Coordination Layer
MPP (Machine Payments Protocol) takes a different approach. Launched in March 2026 by Stripe and Tempo Labs, MPP is session-oriented. An agent pre-authorizes a spending limit, then streams micropayments as it consumes resources — like opening a tab at a bar. MPP supports two payment modes:
On-chain mode — stablecoins and blockchain settlement (via Tempo)
Card mode — Visa’s specification for agent-initiated card payments (Stripe rails)
It defines four primitives: challenges, credentials, vouchers, and receipts. And critically, MPP is backwards-compatible with x402 — an MPP session can use x402 as its underlying payment mechanism.
MPP has also been submitted to the IETF as a Standards Track Internet-Draft, pursuing formal standardization alongside HTTP itself.
]Pay.sh vs x402 vs MPP — A Comparison
These three projects occupy different layers of the agentic payments stack. Here’s how they stack up:
| Dimension | Pay.sh | x402 | MPP |
|---|---|---|---|
| Type | Gateway service / marketplace | Payment protocol | Payment protocol |
| Creators | Solana Foundation + Google Cloud | Coinbase | Stripe + Tempo Labs |
| State model | Session-based (wallet balance) | Stateless (per-request) | Session-based (pre-auth limit) |
| Settlement | Stablecoins on Solana | USDC on Base, ETH, Solana | Stablecoins (crypto) + cards (fiat) |
| API abstraction | Full proxy + catalog + CLI | Raw HTTP headers | HTTP auth scheme (IETF draft) |
| Discovery | Unified marketplace (75+ providers) | No built-in discovery | No built-in discovery |
| Fiat support | Via on-ramp (credit card → stablecoin) | No | Yes (native Stripe card rails) |
| Open source | Yes (Apache 2.0) | Yes (MIT) | Yes |
| Best for | Agents needing turnkey API access | Simple per-request payments | Long-running sessions, streaming |
| Key integrations | Gemini, Claude Code, Codex, Openclaw | Coinbase Agentic Wallet SDK | Visa, Stripe |
The Real Relationship
The best way to think about these is as complementary layers:
Pay.sh (gateway + catalog + proxy)
└── uses MPP (session coordination)
└── can use x402 (per-request execution)
└── settles on Solana
Pay.sh is the product — a ready-to-use gateway with a marketplace, CLI, MCP server, and agent integrations. MPP and x402 are the protocols powering the payment flow underneath. Think of x402 as TCP — fast, stateless, handles individual packets. MPP as HTTP — stateful sessions built on top. Pay.sh as the browser — a full product that makes it all usable.
Concrete Use Cases
Simple API call → agent needs a single data point (e.g., “get ETH price from Dune Analytics”). x402 works perfectly here — one payment, one response, done.
AI inference session → agent runs a long generation (e.g., “summarize this 100-page document with Gemini”). Unknown token count upfront. MPP’s session model with streaming payments is ideal — authorize a budget, pay as you go.
Autonomous workflow → agent discovers, negotiates, pays for, and consumes multiple APIs in sequence (e.g., “research competitor, draft report, send email”). Pay.sh’s unified catalog + MPP sessions + x402 execution combine into a seamless pipeline.
Why This Matters
Three things make this launch significant:
1. Google Cloud’s endorsement. Google isn’t just a launch partner — it’s a Pay.sh provider. Gemini, BigQuery, and Vertex AI behind a per-request stablecoin payment wall sends a strong signal that enterprise cloud is ready for agent-native commerce.
2. The composable protocol stack. Instead of a walled garden, Pay.sh is built on open, interoperable standards. The same x402 flow powering a Pay.sh call could just as easily power a direct API integration or a Coinbase wallet transaction. This is web3 done right — protocols first, products second.
3. The subscription era is ending. “Pay per request, no minimum” isn’t just a pricing model — it’s a paradigm shift. When agents can discover and pay for services instantaneously, the subscription bundling that defined SaaS for two decades starts to look like overhead, not value.
The Open Question
The elephant in the room: adoption. x402 has been around for a year. MPP for two months. Pay.sh just launched today (May 6, 2026). The protocols are elegant, the vision is compelling, but the network effects haven’t kicked in yet.
Will Google Cloud’s weight bring enough providers and agents to reach critical mass? Can Solana’s throughput handle agentic-scale micropayments without congestion? Will IETF standardization of MPP create a single dominant protocol or just more fragmentation?
The answers are unknowable. But the direction is clear: machines are learning to pay each other, and Pay.sh is the most practical on-ramp yet.
Where To Start
- Pay.sh — Browse the catalog, install the CLI, connect your wallet
- x402.org — Read the spec, explore the ecosystem
- MPP.dev — Technical documentation and IETF draft
- Pay.sh docs — Full documentation and agent quickstart
- GitHub — Open source repo
