tabula-mcp
OfficialProvides credit-line payments for AI agents on Robinhood Chain, enabling them to pay x402 sellers from a Tabula credit line, check credit status and available sellers, repay loans in USDG, and manage autopay and sub-agent budgets.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@tabula-mcpCheck my credit status and list available sellers"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
tabula-mcp
Credit for AI agents on Robinhood Chain and Base, as an MCP server. Your agent pays x402 (HTTP 402) sellers from a credit line: Tabula pays the seller at once, the charges go on the agent's tab, and the tab becomes a loan the agent repays in the chain's dollar (USDG on Robinhood Chain, USDC on Base) with one signature and no ETH.
What you need
An agent with an ERC-8004 identity on Robinhood Chain or Base, owned by a key you hold (an ordinary account, not a contract wallet). If you signed in to Tabula's web app with a passkey, your account is a Safe: make your agent a sub-key there (below) and repay from the app.
A credit line. On Robinhood Chain
tabula-mcp joinopens a $1 line while seats are free, for an agent with a repayment record on the chain's other agent lender (at least three loans repaid and none defaulted). On Base the first $1 lines go to agents on a list: write to team@tabula.credit. On either chain a line backed by collateral opens from Tabula's web app.The chain's dollar in the owner's wallet when a loan is to be repaid.
Node 20.19 or later.
Related MCP server: Agent Commerce Suite
Set it up
Add the server to your MCP client's configuration:
{
"mcpServers": {
"tabula": {
"command": "npx",
"args": ["-y", "tabula-mcp"],
"env": {
"TABULA_GATEWAY_URL": "https://api.tabula.credit",
"TABULA_AGENT_ID": "<your agent's ERC-8004 id>",
"TABULA_AGENT_KEY": "<the key that owns the identity>"
}
}
}
}The gateway names the chain: https://api.tabula.credit for Robinhood Chain, https://api-base.tabula.credit for Base.
Open the line once, from a terminal with the same variables:
npx tabula-mcp join
npx tabula-mcp statusThen ask the agent to fetch a paid resource from one of the sellers that list_sellers shows.
Agent frameworks
Any framework that runs MCP servers runs this one: the command npx with the arguments -y tabula-mcp, and the
variables above in its environment. Give a framework a sub-agent's key (TABULA_SUBKEY, below) rather than the key
that owns the identity.
ElizaOS (@elizaos/plugin-mcp), in the character file:
{
"plugins": ["@elizaos/plugin-mcp"],
"settings": {
"mcp": {
"servers": {
"tabula": {
"type": "stdio",
"command": "npx",
"args": ["-y", "tabula-mcp"],
"env": { "TABULA_GATEWAY_URL": "https://api.tabula.credit", "TABULA_SUBKEY": "<the sub-agent's key>" }
}
}
}
}
}Hermes Agent, in ~/.hermes/config.yaml (Hermes hands a server only the variables under env):
mcp_servers:
tabula:
command: "npx"
args: ["-y", "tabula-mcp"]
env:
TABULA_GATEWAY_URL: "https://api.tabula.credit"
TABULA_SUBKEY: "<the sub-agent's key>"OpenClaw: the server goes under mcp.servers in ~/.openclaw/openclaw.json (or openclaw mcp set) with the same
command, arguments and variables, and the skill in skills/tabula-credit tells the model how to use the tools.
AgentKit and other LangChain agents: load the server through LangChain's MCP adapters and give its tools to the agent beside AgentKit's own.
Tools
Tool | What it does |
| The line: its limit, what is available, the open tab, and each loan with what it owes now and when it is due. |
| Pays for an x402 resource from the line, at most |
| The sellers on the list, with their prices. |
| Repays one loan in full from the owner's wallet. |
| Repays every open loan with one signature. It signs for what the loans will owe an hour from now, and what is not needed comes back at once. |
| Waits for $TABULA's launch. Spends the chain's dollar on $TABULA through the bond zap and bonds it behind the agent's line, for a higher limit: |
| While the server runs, repays each loan from 24 hours before it is due, when the wallet holds enough of the chain's dollar. |
repay, repay_all, raise_limit and autopay need the owner's key. A sub-agent's server (below) has the first three tools only.
Sub-agents
One line can serve several agents. The owner makes a key for each sub-agent, with its own budget:
npx tabula-mcp subkey create research 2 0.10 # at most $2 a day (UTC), at most $0.10 a call
npx tabula-mcp subkey list # what each key spent today
npx tabula-mcp subkey revoke 3The key is shown once. The sub-agent runs tabula-mcp with TABULA_GATEWAY_URL and TABULA_SUBKEY and no private
key: it can pay and read the tab, within its budgets, and nothing else. Its charges go on the same tab, and the line's
limit still bounds them all.
What it costs
The fee: 0.75% of the principal per 30 days, charged for the time used, by the hour, and at least one day. A loan runs 7 days.
The payment fee: 0.1% of each loan's principal, whatever the term.
No gas: the repayment is an authorization that Tabula's relayer submits.
The first loan repaid on time gets its fee back, up to $0.10.
These are the numbers at launch. GET /v1/bank on the gateway shows the current ones, and a loan's fee is fixed when
it opens. A loan not repaid by its due date is late; 3 days later it defaults, the line freezes, and the default
stays on the agent's public credit record.
What the server signs
The owner's key never leaves the server's environment. With it, the server signs two things only:
the login to the gateway, which is good for 5 minutes;
authorizations in the chain's dollar to repay the agent's own loans.
Before it signs a repayment, it checks on the chain itself that:
the money goes to Tabula's ledger or its batch repayer;
the token is the dollar of Tabula's ledger, on the right chain;
every loan belongs to this agent;
the amount is no more than those loans can owe.
So a gateway that misbehaves still cannot point a signature anywhere else.
The server knows Tabula's contracts on Robinhood Chain (chain 4663) and Base (8453). For any other deployment
TABULA_LEDGER and TABULA_BATCH_REPAYER name them, and without a trusted ledger the server repays nothing.
A seller's response comes back to the model marked as data from the seller. For an agent that reads content you do not control, give it a sub-key: a sub-key cannot repay, cannot make keys, and has a daily budget.
Environment
Variable | |
| Tabula's gateway: |
| The agent's ERC-8004 id and the key that owns it: the identity's owner. |
| Instead of the two above: a sub-agent's key. |
|
|
| The chain's RPC, which the owner's server reads to check what it signs. The public RPC by default. |
| The contracts to repay to and to bond through, for a deployment the server does not already know. |
License
MIT
Available Tools
3 toolscredit_statusCredit statusBRead-only
Your Tabula credit line: limit, open tab, what you owe and when it is due.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The readOnlyHint annotation already establishes that this is a safe, non-mutating call, so the description needn't restate that. It adds some value by disclosing the shape of the returned information (limit, open tab, owed amount, due date), which is beyond what annotations provide. It does not mention whether figures are live or cached, per-currency handling, or behavior when no credit line exists.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single short sentence with no filler; every phrase contributes a returned field. It reads as a fragment rather than front-loading an action verb, which slightly weakens the opening.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description carries the burden of explaining what comes back, and the field list only partly does that job — no indication of currency, format, or structure. For a simple zero-parameter read tool this is marginal but acceptable; it stops short of being sufficient on its own.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes zero parameters, so schema semantics are moot and the baseline applies. Nothing in the description misleads about inputs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names the resource (Tabula credit line) and enumerates what it returns (limit, open tab, amount owed, due date), so an agent can infer this is a read of account credit state. However, it is a noun phrase with no verb, and it never explicitly contrasts itself with pay_with_credit, which is the adjacent tool an agent might confuse it with.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no when-to-use guidance at all — nothing says to call this before paying with credit, or that pay_with_credit is the alternative action. The agent must infer usage from the field list alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_sellersList sellersARead-only
Sellers you can pay on credit, with prices. A featured seller paid for its place in this list.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations only declare readOnlyHint=true; the description adds two genuinely non-obvious behavioural facts — that results include prices and that at least one entry is a paid placement ('a featured seller paid for its place'), which warns the agent about ranking bias. That paid-placement disclosure is exactly the kind of context structured fields cannot carry.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences, front-loaded with the eligibility constraint and followed by the disclosure that matters most for trusting the ordering. No filler and nothing a reader would want moved earlier.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter read-only list with no output schema, the description covers who appears in the list, that prices are attached, and the sponsored-ordering caveat. It stops short of sketching the per-seller record fields, which is the only remaining gap — minor, since there is no output schema promising that detail elsewhere.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool takes no parameters, so there is nothing for the description to disambiguate. The baseline for a zero-parameter tool applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Names the resource precisely — sellers available for credit payment — and adds that prices are included. It doesn't name or exclude the siblings credit_status / pay_with_credit, so the agent still has to infer the relationship, but the noun phrase is specific enough to distinguish this from a generic seller lookup.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit when-to-use or when-not-to-use statement. The phrase 'sellers you can pay on credit' implies this is the discovery step preceding pay_with_credit, and the absence of parameters implies a full-list read, but the agent must infer all of that rather than being told.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
pay_with_creditPay with creditA
Pay for an x402 (HTTP 402) resource from your credit line. Tabula pays the seller now; the charge goes on your tab, which you repay later.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | The resource's URL. Only sellers on Tabula's list can be paid (list_sellers). | |
| body | No | The request body for the seller. | |
| method | No | The HTTP method; GET if left out. | |
| headers | No | Request headers for the seller. | |
| max_price | Yes | The most you will pay for this call, in US dollars (USDG on Robinhood Chain, USDC on Base), for example 0.05. | |
| idempotency_key | No | Send the same key again to retry a call: one key is never paid twice. A new key is made if you leave it out. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond openWorldHint, it explains that Tabula pays the seller immediately while the user incurs a charge to repay later, making the financial consequence unusually clear. It does not address charge finality or what happens to the tab if the resource request fails.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two compact sentences front-load the operation and then explain settlement and repayment. Nothing is redundant, and the HTTP 402 parenthetical efficiently clarifies the x402 jargon.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Together with the rich schema, the description provides enough context to select and invoke the tool while understanding its credit obligation. Because there is no output schema, the absence of any indication of the returned result or failure behavior leaves a modest completeness gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline of 3 applies. The description adds no parameter-specific details beyond the schema, which already documents seller eligibility, the price cap, HTTP options, and idempotent retries.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a concrete action ("Pay"), resource ("an x402 (HTTP 402) resource"), and funding mechanism ("your credit line"). That specific scope is functionally distinct from credit_status and list_sellers, even though neither sibling is named.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The x402/HTTP 402 and credit-line wording clearly establishes the intended use case. It lacks explicit prerequisites or alternative routing, such as using list_sellers to confirm eligibility or credit_status to inspect the credit line.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
v0.1.0- First observed
credit_status - First observed
list_sellers - First observed
pay_with_credit
TDQS
Scored across 3 tools
Each tool has a clearly distinct role: checking credit status, paying via credit, and listing available sellers. There is no meaningful overlap between them, so an agent can select the right tool without confusion.
The names use three different structures: noun_noun (credit_status), verb_preposition_noun (pay_with_credit), and verb_noun (list_sellers). They remain readable, but the mixed conventions prevent a predictable pattern.
Three tools is a reasonable minimal surface for a focused credit-payment server. It is slightly thin, but each tool earns its place and the scope is coherent.
The surface supports checking credit, listing sellers, and making a credit payment, but there is no tool to repay or settle the tab despite descriptions saying the charge is repaid later. This creates a significant lifecycle gap and a likely dead end for agents.
Maintenance
Related MCP Connectors
Paid MCP tools behind one endpoint. Agents pay per call in USDC on Base via x402.
Pay-per-call MCP tools run by autonomous AI agents, each call paid with x402 in USDC.
MCP for AI agents: financing, skills, lending on Base
28 agent tools via x402: crypto data, tx checks, web fetch. MCP pays Base USDC; HTTP adds 3 rails.
Related MCP Servers
AlicenseNot gradedqualityCmaintenanceEnables MCP clients to use paid tools for secret scanning, agent-config auditing, and OG image rendering, with payments handled over the x402 protocol on Base.MIT- AlicenseNot gradedqualityBmaintenanceProduction-grade suite of monetized tools for autonomous AI agent-to-agent commerce, enabling payments and task execution via x402 protocol and MCP.344 npmMIT
- AlicenseNot gradedqualityCmaintenanceEnables agents to access production-grade paid MCP tools with real on-chain x402 v2 settlement, including EVM wallet risk scoring, payload normalization, and facilitator discovery, all discoverable via Bazaar-compatible metadata.MIT
- FlicenseNot gradedqualityCmaintenanceEnables AI agents to access 11 paid x402 endpoints as standard MCP tools, paying per call in USDC on Base without API keys, covering chat, code, vision, embeddings, crypto prices, weather, geolocation, forex, and WHOIS data.-