tab

Payments for software agents.

Give an agent a wallet with rules, instead of giving it your wallet.

Quickstart · Run a company · For agents · For sellers · Protocol · Deployment · @paidwithtab

Contents

What is tab · Why tab · Mandates · New in 3.0 · How a payment works · Quickstart · For API providers · For agent developers · Companies · Settlement · x402 · Security model · Testing · Architecture · Roadmap

What is tab

tab is an open payment protocol for software agents.

It lets an agent discover a paid HTTP service, receive a price, authorize the purchase against rules set by its owner, pay, and receive the result. No human has to create an account, enter a card, or copy an API key.

Owners define those rules once, in a signed mandate:

The owner signs once. The agent then transacts on its own, and it cannot exceed what the owner authorized.

Owner

│ │ signs mandate ▼ Agent │ │ HTTP request ▼ Gateway ────────► API │ │ verifies mandate │ enforces budget │ settles payment ▼ USDG

Why tab

Software agents can already call APIs and use tools. Paying for those services is the part that still requires a person.

Today a human creates an account, enters payment information, generates an API key, configures billing, and hands credentials to the agent. tab replaces all of that with an HTTP payment.

Without tab With tab

Agent calls API

HTTP/1.1 402 Payment Required

Account signup, card on file, API key handoff, billing setup.

Agent pays through tab

HTTP/1.1 200 OK Tab-Receipt: evm:0x...

No account. No card details. No shared owner key. No unrestricted wallet.

Mandates

A mandate is a signed spending authorization from an owner to an agent.

The owner key never has to be online while the agent is working. Every payment is checked independently by the seller's gateway against the signed mandate, so changing the agent's prompt cannot increase its authority.

New in 3.0

Five things an owner can do after the mandate is signed, all optional, all backward compatible with 2.x mandates, clients and receipts.

In tab OS each one has a home: a Revoke button on runs and agents, delegated budgets on a manager's card, payment approvals in the Inbox (with a thumb sized Approve on a phone), orders paid on delivery in Receipts, and channels in the Wallet. SPEC.md sections 2.1, 2.2, 5.4, 5.5 and 5.6 are the wire format.

How a payment works

tab uses standard HTTP payment semantics. A priced endpoint answers with 402 Payment Required and a signed challenge describing the purchase. The agent checks the price against its mandate and signs a credential bound to that exact request.

The gateway then runs the full lifecycle:

If the upstream service fails, the payment is voided.

The receipt is signed by a key the gateway publishes, and it binds the whole purchase together: the mandate that allowed it, the exact request the agent signed, a hash of the response body that came back, the seller, and the payment (on Robinhood Chain, the transaction hash). So a receipt proves what was bought, not just that money moved. The client checks it against the bytes it received, and any edit breaks it.

Quickstart

Requires Node.js 22.13 or newer.

Give an agent a tab in one command:

npx paidwithtab init

This creates an owner key and an agent key in ~/.tab, signs a mandate ($1.00 per day, $0.05 per call, 90 days), and claims $1.00 of starter credits on the public gateway at pay.paidwithtab.com. Nothing to fund, no chain, no API keys.

Those credits buy real things: 8,638 routes across 484 services, from web search, translation and speech to text to block explorers for 42 chains, market data from 20 exchanges, Wikipedia in 48 languages, SEC filings, US Treasury data, genomes, proteins and chemistry, package registries, RDAP and DNS, weather and space weather, between $0.001 and $0.02 a call. The full list with prices is in the quickstart.

1. Pay for something from the shell.

npx paidwithtab fetch "https://pay.paidwithtab.com/wikipedia/api/rest_v1/page/summary/Lisbon"

paid 0.001 (ledger:cpKKYHocOLKlDW8n)

{"type":"standard","title":"Lisbon", ...}

2. Let Claude Code spend.

claude mcp add --scope user tab -- npx -y paidwithtab mcp

Then ask Claude for something it needs to pay for, for example "find the weather in Lisbon through tab". It searches the catalog at paidwithtab.com/catalog, pays per request, and can never exceed the mandate.

3. See a price tag.

curl -i https://pay.paidwithtab.com/fx/latest?base=USD

HTTP/1.1 402 Payment Required

WWW-Authenticate: Tab challenge="eyJ2ZXIiOiJ0YWIvMCIs..."

The starter credits are sandbox money on that one gateway. For real money, fund an agent with USDG on Robinhood Chain: docs/buyers.md.

Want the whole stack on your machine? git clone https://github.com/paidwithtab/tab && cd tab && npm install && npm run demo starts a paid API, a gateway, a catalog and a local wallet. [Full walkthrough](docs/quickstart.md)

For API providers

Any HTTP API becomes payable with a small JSON specification. Leave out rail to run on sandbox balances while you develop.

{

"realm": "api.example.com", "recipient": " ", "rail": "evm", "evm": { "rpc": "https://rpc.testnet.chain.robinhood.com", "chain_id": 46630, "token": "0x5B6C7cAF7F99f99154fD8375ec935Fcf03F326f5", "decimals": 6, // the token's decimals, 0 to 18; USDG and USDC have 6 "recipient": " " }, "upstream": "http://127.0.0.1:8080", "routes": [ { "method": "GET", "path": "/v1/things/:id", "price": "0.01" }, { "method": "POST", "path": "/v1/generate", "price": "0.002" } ] }

Start the gateway:

tab serve \

--spec spec.json \ --announce https://paidwithtab.com

The gateway handles payment negotiation, authorization, settlement, receipts, and proxying. Your application keeps serving normal HTTP.

[Read the seller documentation](docs/sellers.md)

For agent developers

1. Create an agent key.

tab key new --out agent.json

2. Issue it a mandate.

tab mandate issue \

--owner owner.json \ --agent agent.json \ --budget 5.00 \ --window day \ --max-per-call 0.05 \ --allow 'api.example.com' \ --out mandate.json

3. Spend within those limits.

import { TabClient, receiptOf } from 'paidwithtab/client';

const client = new TabClient({ agent, mandate, maxPerCallUsd: '0.05', });

const url = 'https://api.example.com/v1/things/42'; const res = await client.fetch(url); const body = new Uint8Array(await res.arrayBuffer());

console.log(receiptOf(res)?.ref); console.log(await client.verify(url, res, body)); // { ok: true }

Or skip the key handling: npx paidwithtab init does all three steps and claims starter credits on the public gateway.

tab also exposes five MCP tools, so compatible agents can discover and purchase services without ever receiving the owner's private key:

[Read the buyer documentation](docs/buyers.md)

Hooking tab into a particular agent, with the MCP JSON for Cursor, Codex, Windsurf and Claude Desktop, framework tools, Python by subprocess, and where keys live in production: [docs/agents.md](docs/agents.md)

Companies

tab 2.2 runs a company of agents on top of the payment layer: tab company and the dashboard at app.paidwithtab.com. A company has a mission, a budget, agents with roles, and tickets. An agent is Claude, running on the Anthropic API key you add to the company with the five tab tools and nothing else, or