Enables software agents to discover, authorize, and pay for HTTP services using signed mandates and budget rules.
Also known as paidwithtab/tab, paidwithtab
- Stars
- 0
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- 3.0.0
- Last commit
- Nov 12, 2026
- License
- MIT
What is tab MCP?
tab enables software agents to discover, authorize, and pay for HTTP services using signed mandates and budget rules.
Summary generated from the project's README
About tab MCP server
Enabling software agents to discover and pay for HTTP services without human intervention is what tab accomplishes. It allows developers to provide agents with a wallet governed by specific rules rather than full access to personal funds. By using signed mandates, owners can set constraints such as total budgets, maximum prices per request, allowed sellers, and expiration dates to ensure controlled spending.
Users set up the server locally using Node.js 22.13 or newer. For example, Claude Code users can integrate it with a single command to automatically generate owner and agent keys, a starter mandate, and initial credits. The protocol uses standard HTTP semantics where a 402 Payment Required response triggers the agent to sign a credential against its mandate. This process is verified by a gateway that settles payments in USDG, ensuring that money is only moved when a service call succeeds.
What you can do with it
- 1Automated API service procurementAn AI agent can discover a paid HTTP service, check the price, and authorize a purchase based on pre-set budget rules.
- 2Secure agent budget managementDevelopers can restrict an agent's spending by defining a maximum price per individual request or a total lifetime cap.
- 3Monetizing MCP server toolsSellers can turn their existing MCP server tools into paid routes that agents can access via a gateway.
- 4Verifying transaction integrityUsers can audit every purchase by checking a signed receipt that binds the mandate, the request, and the response body.
Written from the project's README. Every use case is checked against a quote from it.
How to install tab MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall tab MCP in Claude Code
$ claude mcp add tab -- npx -y paidwithtabInstall tab MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"tab": {
"command": "npx",
"args": [
"-y",
"paidwithtab"
]
}
}
}Install tab MCP in VS Code
.vscode/mcp.json
{
"servers": {
"tab": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"paidwithtab"
]
}
}
}Install tab MCP in VS Code CLI
$ code --add-mcp '{"name":"tab","type":"stdio","command":"npx","args":["-y","paidwithtab"]}'Install tab MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"tab": {
"command": "npx",
"args": [
"-y",
"paidwithtab"
]
}
}
}Install tab MCP in Codex
$ codex mcp add tab -- npx -y paidwithtabInstall tab MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.tab] command = "npx" args = ["-y", "paidwithtab"]
Install tab MCP in Gemini CLI
$ gemini mcp add -s user tab npx -- -y paidwithtabInstall tab MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"tab": {
"command": "npx",
"args": [
"-y",
"paidwithtab"
]
}
}
}Configuration
TAB_AGENTAgent key file. Default ~/.tab/agent.json, which `npx paidwithtab init` creates with a mandate and starter credits.
TAB_CATALOGCatalog to search. Default https://paidwithtab.com.
TAB_MANDATEOwner-signed mandate file. Default ~/.tab/mandate.json.
TAB_MAX_PER_CALLRefuse any single call priced above this many dollars, e.g. 0.05.
| Name | Description | |
|---|---|---|
| TAB_AGENT | Agent key file. Default ~/.tab/agent.json, which `npx paidwithtab init` creates with a mandate and starter credits. | |
| TAB_CATALOG | Catalog to search. Default https://paidwithtab.com. | |
| TAB_MANDATE | Owner-signed mandate file. Default ~/.tab/mandate.json. | |
| TAB_MAX_PER_CALL | Refuse any single call priced above this many dollars, e.g. 0.05. |
Automated checks
Ran Nov 14, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablepaidwithtab/tab is public and reachablegithub.com/paidwithtab/tab ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-12github.com/paidwithtab/tab ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNo popular package one edit away from paidwithtabPass
- No critical advisory in the package or its dependenciesthe package checked; no critical advisoryosv.dev ↗Pass
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubContents
What is tab · Why tab · Mandates · New in 3.1 · 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:
| Constraint | Purpose |
|---|---|
| Total budget | Caps lifetime spend |
| Maximum price per request | Blocks a single expensive call |
| Allowed sellers | Restricts where money can go |
| Spending window | Resets the budget each UTC day, or keeps one lifetime total |
| Expiration | Ends the authority automatically |
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.
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.
| Field | Example |
|---|---|
| Agent | 7f2c... |
| Budget | $25.00 |
| Maximum per call | $0.05 |
| Allowed sellers | api.example.com |
| Expires | 2026-10-01 |
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.2
tab inside the x402 market that already exists, money saved you can see, more reasons to sell, and every charge publicly checkable.
| Upgrade | What it does | From the CLI |
|---|---|---|
| x402 sellers in search | The catalog reads the public x402 discovery list, about 33,000 routes from 3,200 sellers that take USDC on Base, beside tab's own. Agents pay them from their own address within the same mandate. | tab catalog serve --x402-list bazaar, tab catalog add-x402 <origin> |
| A cache of paid results | The same GET within ten minutes is answered from the first purchase's proof, for nothing, and still verifies. POST answers only when the seller marks them reusable. | TAB_CACHE_TTL, tab_fetch with fresh: true |
| Cost per task | Every paid call is tagged with the task, or the git branch, and summed with what the cache saved. tab_estimate prices a plan first. |
tab cost --by task |
| The cheapest seller that works | Gateways publish each route's 7-day reliability; search ranks working sellers first, and a failed call comes back with alternatives. | tab_search with sort: "cheapest" |
| Rules in the mandate | Which routes, and which hours, signed into the mandate and enforced by gateways and the client. In tab OS, per agent. | tab mandate issue --paths "/search*" --hours "mon-fri 9-17" |
| A public receipt log | Every receipt goes into a Merkle tree with a signed head. tab verify checks a receipt is in it; tab log check proves the log only grew. |
tab log check |
| For sellers | Free calls per buyer per day, a notice on the first sale and daily earnings, signed earnings stats, routes priced by the kilobyte. | tab sell ... --free 3 --notify-ntfy, tab sell stats |
| Card top-ups and referrals | Stripe Checkout credits a ledger wallet once its signed webhook arrives; a referrer earns 10% of a referred buyer's card-funded spend. | tab topup 5, tab serve --stripe --referrals |
| One command per tool | Cursor, Windsurf, VS Code and Codex, beside Claude Code. | tab setup cursor |
| Base | A gateway spec for USDC on Base, and the client's Base signing domain checked against the chain. | examples/spec-base.json |
SPEC.md draft 0.9 has the wire format: rules in §2.3, free calls and metering in §5.6, the log in §5.9. docs/integrations.md covers every agent tool and framework.
New in 3.1
Five upgrades that make tab useful in the first minute, for buyers, sellers and owners.
| Upgrade | What it does | From the CLI |
|---|---|---|
| One line to start | The MCP server sets itself up on first launch: keys, a $1.00 a day mandate and $1.00 of starter credits. No init, no signup. |
claude mcp add --scope user tab -- npx -y paidwithtab mcp |
| Proof of purchase | Every paid response is kept as a folder: the body, the gateway's signed receipt, the request and the mandate. One command checks the gateway's signature and published key, the body hash, the request, the agent's own signature on the payment, and the owner's signature on the mandate. | tab verify ~/.tab/receipts/<folder>, tab receipts |
| Sell without a server | Sign a listing for your API and post it to a hosted gateway. It is served under /s/<name>/, shows in the catalog, and every call pays your own wallet (your 0x address on a chain gateway). |
tab sell https://api.example.com --price 0.01 --route "GET /forecast" |
| Charge for an MCP server | List an MCP server and each tool becomes a paid route; the gateway makes the tool call, and a tool that fails is not charged. Buyers add it to Claude Code as tools of their own. A stdio server goes on HTTP with one command. | tab sell https://mcp.example.com/mcp --mcp --price 0.005, tab mcp connect <listing url>, tab mcp http -- <command> |
| Spend alerts | The owner signs a subscription at a gateway: a webhook (an ntfy.sh topic puts it on a phone with no account), budget percentages, and a daily statement. | tab alerts set --ntfy --at 50,90,100 --daily |
Hosted listings and alerts are opt-in for an operator (tab serve --listings --alerts), and both only reach public https addresses: no private networks, no redirects, checked again when connecting. SPEC.md sections 5.7 and 5.8 are the wire format.
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.
| Feature | What it does | From the CLI |
|---|---|---|
| Instant revoke | The owner signs a revocation; gateways refuse the mandate, and every sub-mandate under it, within seconds. Gateways pass revocations to each other. | tab mandate revoke --key owner.json --mandate m.json --gateway https://pay.example.com |
| Sub-mandates | An agent hands a narrower slice of its mandate to another agent key. Every limit stays inside the parent's, spend counts against every level, chains stop at three delegations. | tab mandate delegate --agent-key agent.json --mandate m.json --to helper.json --budget 0.25 |
| Approval above a threshold | approve_above on the mandate: a bigger payment waits for a fresh approval the owner signs for exactly that call. The agent retries and it pays once. |
tab mandate issue ... --approve-above 0.50, then tab mandate approve --owner owner.json --request req.json --gateway ... |
| Pay on delivery | On routes that offer it, the buyer's payment is held until the seller delivers a result, then released with a receipt that binds the request to the result. Undelivered by the deadline, it comes back. | tab fetch --escrow --wait 300 -X POST -d '{...}' https://pay.example.com/jobs/essay |
| Payment channels | One deposit, then a signed voucher per call with no transaction per call, settled once at close. Metered routes charge per token, second or unit, a fraction of a cent at a time. | tab channel open --gateway https://pay.example.com --deposit 1.00, then tab fetch --channel ... |
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:
| Step | Action |
|---|---|
| 1 | Verify the challenge |
| 2 | Verify the mandate |
| 3 | Verify the agent |
| 4 | Verify the exact request |
| 5 | Reserve the budget |
| 6 | Call the upstream service |
| 7 | Settle only after a successful response |
| 8 | Return a signed receipt |
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 Claude Code a tab in one line:
claude mcp add --scope user tab -- npx -y paidwithtab mcp
On its first launch it 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. Then ask Claude for something it needs to pay for, for example "find the weather in Lisbon through tab". From a shell, npx paidwithtab init does the same setup and prints what it made.
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. Prove what it bought.
npx paidwithtab receipts
npx paidwithtab verify ~/.tab/receipts/<folder>
Every paid call is kept with its signed receipt. verify checks the gateway's signature against the key it publishes, that the body is the one it signed for, and that the agent itself signed the payment under the owner's mandate. Change one byte and it fails.
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
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": "<wallet>",
"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": "<your 0x payout address>"
},
"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.
No server to run? List your API on the hosted gateway instead. It is paid to your own wallet, and it shows in the catalog:
npx paidwithtab sell https://api.example.com --price 0.01 --route "GET /forecast" --route "GET /cities/:id"
npx paidwithtab sell https://mcp.example.com/mcp --mcp --price 0.005 # an MCP server: one paid route per tool
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:
| Tool | Purpose |
|---|---|
tab_search |
Find services in a catalog |
tab_discover |
Inspect a service and its pricing |
tab_fetch |
Make a paid request |
tab_balance |
Check remaining budget |
tab_limits |
Read the active mandate constraints |
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
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 any HTTP endpoint you point at (a self-hosted server can also run Claude Code). The difference from a plain agent orchestrator is where the money lives:
- Every run gets its own mandate, signed by the company's owner key and capped at the smallest of the company's remaining budget, the agent's per-run budget and the ticket's cap. The gateway enforces it; the agent cannot exceed it.
- What a run spent is what the gateways booked against that mandate, attributed to the run, the ticket and the company, receipt by receipt. Model cost is booked too. The company warns at 80 percent and pauses at 100.
- Nothing closes without evidence: a receipt id, a URL, a file, the literal output. "Done" without it goes to review.
- Hire, budget, approve, pause and publish are board actions signed with the owner key and verified on every read. Export the key and sign them offline.
- A company can earn: publish the gateway it sells through and its receipts show up as earnings.
The first run takes under a minute and needs no key: sign up and press Start, or run tab company quickstart. A starter agent pays $0.002 for two Wikipedia lookups and hands back the answer with both signed receipts.
tab company serve --host app.example.com # one process, SQLite, no dependencies
tab company signup --email you@example.com --password ...
tab company quickstart # a $1 company; its starter agent pays and answers at once
tab company new --template examples/companies/research.json
tab company model-key --key sk-ant-... # your Anthropic key, sealed at rest; your agents run on it
tab company fund && tab company status
docs/company.md has the packet an agent receives, the result it must return, the adapters, the board log and the server's trust boundary.
Settlement
tab settles in USDG on Robinhood Chain mainnet and test USDC on its testnet, or in any ERC-20 a gateway chooses to charge in (its prices, challenges and receipts then name that token in currency), following a delivery first model. The gateway does not settle a payment until the upstream service has responded successfully.
authorize
│
▼
reserve
│
▼
call API
│
├── failure ──► void
│
▼
success
│
▼
settle
│
▼
receipt
x402
tab speaks x402, the HTTP 402 payment standard that Coinbase started and Cloudflare, Visa and Mastercard build on, in both directions.
x402 buyers can pay a tab gateway. On the evm rail, every 402 carries x402 requirements (a PAYMENT-REQUIRED header) next to tab's own challenge. An x402 client signs an EIP-3009 transfer of exactly the price to the seller, sends it as PAYMENT-SIGNATURE, and gets the response with PAYMENT-RESPONSE and a signed tab receipt. The gateway checks the signature, the amount, the recipient and the time window, dry-runs the transfer, calls the upstream, and only then settles the transfer on chain from a small gas wallet of its own (--x402-settler). If it does not settle, the response is withheld. The public mainnet gateway takes x402 payments in USDG on Robinhood Chain (eip155:4663) today, so all of its routes are open to any x402 agent with no tab software at all.
tab agents can pay x402 sites. When a site answers 402 with only x402 requirements, the tab client pays it within the owner's mandate: realm (the site's hostname), per-call cap, budget and expiry, in a token it knows (USDG on Robinhood Chain, USDC on Base). x402 has the payer sign the transfer itself, so the owner funds the agent's own address with a small amount (tab evm fund --amount 5.00 --token 0x...), and that balance is a hard ceiling on top of the mandate. The client counts what it signs against the mandate in x402-spent.json next to the agent's keys, since an x402 site keeps no tab budget.
A gateway that speaks both is paid the tab way by a tab client, so owners keep custody and the mandate is enforced on both sides.
Security model
tab is built around bounded authority.
| Property | Guarantee |
|---|---|
| Owner keys stay offline | The owner signs the mandate. The agent never receives the owner's private key. |
| Agents have explicit limits | Compromising an agent exposes only the authority its mandate granted. |
| Requests are cryptographically bound | Credentials commit to the exact request, including query string and body digest. |
| Payments cannot be replayed | Challenges are single use, and chain settlement adds a nonce boundary. |
| Gateways hold no buyer keys | The gateway verifies and broadcasts what the agent authorized. It cannot create payments on its own. |
Security issues involving payment invariants should be reported privately through SECURITY.md.
tab MCP questions
How do I add tab MCP to Claude Code?
Run claude mcp add tab -- npx -y paidwithtab in your terminal. Add --scope user to make it available in every project.
How do I add tab MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What happens if an API call fails?
The payment is voided if the upstream service fails, ensuring you only pay for successful responses.
How can I prove a purchase was legitimate?
Every paid response includes a signed receipt that binds the mandate, the request, the response body hash, and the payment together.