MCP tools reference
@burnbound/mcp is the MCP server that lets an agent refund Stripe charges through your action gateway and pay x402 and MPP APIs, under its Burnbound spending policy. It runs over stdio with npx -y @burnbound/mcp@latest, exposes twelve tools (fetch_paid, get_budget, propose_rule, list_payments, get_approval_status, search_paid_apis, diagnose_payment, stripe_refund, and stripe_credit, shopify_refund, request_mandate and get_mandate_status, new in 0.11.0), and includes a wallet CLI for client-side signing and a doctor CLI that explains why a payment fails. Card payments have no tool: Stripe asks Burnbound before each authorization on the agent's card (cards guide), and they still show in get_budget and list_payments. This page documents version 0.11.0.
How do I configure the server?
The server is configured only through environment variables in your MCP client config. BURNBOUND_KEY is the only required one. The server checks the configuration before it starts and exits with a message on stderr if something is missing or unsafe.
| Variable | Required | Meaning |
|---|---|---|
BURNBOUND_KEY |
yes | The agent's key (bb_agent_…). |
BURNBOUND_API |
no | Burnbound API base URL. Default https://app.burnbound.dev. Must be https:// (http:// only for a loopback host). |
BURNBOUND_AGENT_ID |
only with an org key | The agent the tools act for. Ignored with an agent key, which already names its agent. |
BURNBOUND_MAX_RESPONSE_BYTES |
no | Cap on the response body fetch_paid returns. Default 1048576 (1 MiB), maximum 10485760 (10 MiB). Longer bodies are truncated. |
BURNBOUND_FETCH_TIMEOUT_MS |
no | Deadline for the whole exchange with the URL in fetch_paid. Default 30000, from 1000 to 120000. |
BURNBOUND_APP_URL |
no | Origin of the Burnbound dashboard, used to build approvalUrl for a held payment. Default: the BURNBOUND_API origin when it is https://; with a loopback API there is no default and no link. An origin only, without a path. Must be https:// (http:// only for a loopback host). |
BURNBOUND_APPROVAL_WAIT_MS |
no | How long fetch_paid waits for the human's decision after the user opens the approval page from the chat. Default 40000, from 0 to 50000. 0 returns pending_approval without waiting. |
BURNBOUND_BASE_RPC_URL |
no | RPC that diagnose_payment uses to read the paying wallet's USDC balance on Base. Default https://mainnet.base.org. Must be https://; an invalid value only turns off the balance check on that network, with a warning on stderr. |
BURNBOUND_BASE_SEPOLIA_RPC_URL |
no | The same for Base Sepolia. Default https://sepolia.base.org. |
BURNBOUND_GATEWAY_URL |
no | Base URL of your Burnbound action gateway, for stripe_refund, stripe_credit and shopify_refund. https://, or http:// on loopback (the gateway's default). The agent's key is sent there too. Without it, those tools answer gateway_not_configured. |
BURNBOUND_ALLOW_PRIVATE_HOSTS |
no | 1 lets fetch_paid reach loopback and private networks, and http:// on loopback. For local development only. Link-local stays blocked. |
BURNBOUND_WALLET_PROFILE |
no | Local wallet used for client-side signing. Default default. 1 to 32 characters of a-z, 0-9, _ and -. |
BURNBOUND_HOME |
no | Moves the ~/.burnbound directory where file-based wallets are stored. |
The server refuses to start if any BURNBOUND_* variable looks like a private key: wallet keys never go in the MCP config. An organization key still works together with BURNBOUND_AGENT_ID, with a warning on stderr: org keys have admin scope, so use an agent key.
What does fetch_paid do?
fetch_paid requests a URL on one of the agent's allowed hosts and, if the URL answers HTTP 402 with an x402 challenge, or with an MPP tempo.charge challenge on an agent that has MPP turned on, pays it under the agent's policy and returns the paid response. It is one of the tools that can move money (the others are stripe_refund, stripe_credit and shopify_refund), and it is marked to the MCP client as non-read-only and open-world.
| Input | Type | Notes |
|---|---|---|
url |
string, required | https:// URL, up to 2048 characters, on one of the agent's allowed hosts. |
method |
string | GET (default), HEAD, POST, PUT, PATCH or DELETE. |
headers |
object of strings | Up to 32 extra headers. Authorization, payment headers (PAYMENT-SIGNATURE, X-PAYMENT…), x-org-api-key, Host, proxy-* and hop-by-hop headers are refused. |
body |
string | Up to 256 KB. Not allowed with GET or HEAD. |
idempotencyKey |
string | Only to retry a purchase: the key from an earlier pending_approval result or payment_outcome_unknown error. 8 to 128 characters of letters, digits, ., _, : and -. |
maxAmountUsd |
string or number | Refuse to pay more than this many USD for this call, for example "0.05". Your Burnbound policy still applies on top. |
origin |
string | Where the URL came from: user (the person asked for it), catalog (a search_paid_apis result), tool_output (another tool's result) or web (a page the agent read). Any other value is refused. |
origin is only for the audit. Burnbound records it in the audit log and with the approval, but never uses it to decide: a payment declared user faces exactly the same rules as one declared web, and an agent that leaves it out or declares it wrongly gains nothing.
maxAmountUsd is checked against the seller's challenge before anything is authorized, and again against what is signed. It applies to every price Burnbound can pay: exact USDC on Base or Base Sepolia over x402 and, for an agent with MPP turned on, tempo.charge in USDC.e on Tempo, where it counts the amount plus the most the payer may pay in network fees. Offers Burnbound cannot pay are ignored, because they are never paid.
Which results can fetch_paid return?
fetch_paid returns one of three statuses. Anything else (a denial, a limit, a network problem) comes back as a tool error with a code.
status |
Meaning and fields |
|---|---|
ok |
No payment was needed. httpStatus, host, body. |
paid |
Paid. httpStatus, host, intentId, idempotencyKey, replayed (the same purchase was answered again and nothing new was charged), mode (server_signed or client_signs), amountUsd, network, payTo, receipt.state (settled, pending, failed or unknown), receipt.txHash, body. |
pending_approval |
A human must approve first. approvalId, amountUsd, reason (see below), thresholdUsd, host, idempotencyKey and next (what the agent should do). When the server knows the dashboard's address, also approvalUrl and approvalPrompt (see approval from the chat). Poll get_approval_status; once it is approved, call fetch_paid again with the same url, method, headers, body and idempotencyKey. |
body is { untrusted: true, contentType, encoding, bytes, truncated, text }. Binary content types come back base64-encoded. In the tool result the body is a separate text block, fenced and labelled as untrusted third-party content, never mixed with the metadata. Response headers are never returned.
status is paid only when the seller answered the paid request with a 2xx and did not report the settlement as failed. Any other answer after paying (another 402, a redirect, an error) is a tool error, payment_rejected_by_seller or payment_not_completed, never paid. fetch_paid sends a signed payment once per call and never signs again on its own.
receipt.state is unknown when the receipt could not be recorded; the payment itself still happened when status is paid. If the paid response body could not be read, bodyError says why and the payment is still reported.
Why does a payment wait for approval?
reason in a pending_approval result says why a human must approve this payment. A payment that breaks a rule is denied, never sent for approval; these holds come after every rule passed.
reason |
When |
|---|---|
instruction_like_description |
The 402's description or error text reads like instructions to the agent ("ignore previous instructions…"), whatever the amount and even if the address was paid before. Approving it never adds the host to the allowed hosts. |
catalog_new_host |
The first payment to a catalog host admitted by the agent's catalog-hosts rule, whatever the amount. |
new_pay_to |
The first payment of the organization to this receiving address on this host and network, whatever the amount. Not for a listed catalog seller paid at an address Burnbound pinned for it, or one that rotates its address. Later payments go through. |
rule |
An enforced custom rule with the action require approval matched: the agent's, its subteam's or the organization's. rules names them and ruleScopes says whose each one is (agent, team or org). See custom rules. |
threshold |
The amount is at or above the agent's approval threshold, in thresholdUsd. |
A held payment has one reason: the first that applies, in the order of the table. thresholdUsd is null for every reason except threshold. new_pay_to and instruction_like_description apply to every agent and need no setting; the threshold, the catalog-hosts rule and custom rules are set in the dashboard. Versions of @burnbound/mcp before 0.4.0 report new_pay_to and instruction_like_description as threshold.
Can the user approve from the chat?
Partly: the chat can open the approval page, but the decision is always taken in the Burnbound dashboard by a signed-in human.
When the server knows the dashboard's address (BURNBOUND_APP_URL, or the BURNBOUND_API origin when it is https://), a pending_approval result carries approvalUrl, the page of that approval in the dashboard. The link carries only the approval id; without a session of the organization it shows nothing. The agent should give it to the user and never open it itself.
If the MCP client supports URL-mode elicitation (MCP protocol 2025-11-25 or 2026-07-28), fetch_paid also asks the client to offer the user that page, at most once per call:
- The user agrees to open the page. Agreeing only opens it; it approves nothing.
fetch_paidwaits up toBURNBOUND_APPROVAL_WAIT_MS(40 seconds by default), reading the approval every 2 seconds.- If a human approves in time, the same call pays, under the same
idempotencyKeyand after every check again: allowed hosts,maxAmountUsd, the seller's 402 and the wallet. If the human denies it, or it expires, the call ends inapproval_deniedorapproval_expired. - If nobody decides in time, the call returns
pending_approvaland the agent pollsget_approval_statusas usual.
approvalPrompt says what happened to the page:
approvalPrompt |
Meaning |
|---|---|
opened |
The user opened the page and no decision came within the wait. |
declined |
The user did not open it. This is not a denial: the payment is still pending. |
cancelled |
The user or the client closed the request. Not a denial either. |
failed |
The client did not answer the request. |
unsupported |
The client does not support URL-mode elicitation. The agent shows approvalUrl and polls. |
The server never sends a form and never approves or rejects: nothing the client answers can decide a payment, and the agent's key cannot approve. With protocol 2026-07-28 the client retries the call with the same arguments after the page; a retry with other arguments fails with invalid_input (approval_state_mismatch).
Which clients open the page, as of 7 October 2026:
| Client | Opens the approval page from the chat |
|---|---|
| VS Code 1.107 or later, with GitHub Copilot | Yes. |
| Claude Code (CLI) | Not yet: it does not announce URL-mode elicitation, so the result says unsupported. |
| Claude Code extension for VS Code | No: it announces the mode but does not show the page, so the call falls back to pending_approval. |
| Cursor, Claude Desktop | Not confirmed. |
In every client the agent can show approvalUrl to the user and poll get_approval_status. Some clients end a tool call after about a minute, so keep BURNBOUND_APPROVAL_WAIT_MS under your client's limit.
How does fetch_paid handle redirects?
Same-origin redirects before the 402 are followed, up to 3. A redirect to another origin is returned as is with redirectNotFollowed: true. A redirect after paying is not followed either: it ends in a payment_not_completed error with redirectNotFollowed: true. A payment is never sent anywhere other than the URL that asked for it.
What does get_budget return?
get_budget returns the agent's budget for today. It takes no input and is read-only; agents should call it before paying for something.
| Field | Meaning |
|---|---|
agentId |
The agent the key belongs to. |
spentTodayUsd |
USD spent today (UTC day). |
dailyCapUsd |
The daily cap. |
remainingTodayUsd |
What remains today under the daily cap, or under the person's sub-cap when that is lower. |
maxUsdPerTx |
The maximum per payment. |
stepUpThresholdUsd |
Payments at or above this amount wait for a human approval; null when step-up approval is off. |
allowHosts |
The hosts the agent may pay. |
catalogHosts |
Verified catalog hosts outside allowHosts the agent may also pay when the agent's catalog-hosts rule is on: the first payment to each waits for a human approval, then the host joins allowHosts. Empty when the rule is off. |
capLevel |
ok, warning (from 80% of the daily cap) or exhausted. |
network, asset |
The agent's network and asset: eip155:8453 (Base) or eip155:84532 (Base Sepolia), and USDC. |
dayResetsAt |
When today's spend resets to 0: the next midnight UTC, as an ISO 8601 timestamp. |
member |
When the agent belongs to a person of the organization: that person's daily sub-cap across all their agents, as dailyCapUsd, spentTodayUsd and remainingTodayUsd. capSet is false when no admin set a sub-cap yet: the agent cannot pay until one is set. null for an organization agent. |
chatRules |
The rules proposed from the chat with propose_rule that still apply: id, action, hosts, limit, expiresAt and a fixed note. Since 0.5.0. |
effectiveCap |
What the agent can still spend before something refuses a payment: remainingUsd, the smallest of the daily cap, the person's sub-cap and the limit rules that apply to every payment; limitedBy (daily_cap, member_cap or rule), ruleId of that rule, and resetsAt. Since 0.5.0; null with an older API. |
ruleLimits |
Each enforced limit rule of the agent: ruleId, source (panel or chat), appliesTo (all, or matching for a rule with conditions), hosts, limit (for example at most 30 USD per UTC week), remainingUsd or remainingCount in the current window, and resetsAt. A rule with one total per host or payee has no single figure (null). Since 0.5.0. |
Since @burnbound/mcp 0.7.0, an organization can set spending rules for a subteam (a group of its agents, see Concepts) or for the whole organization, and they apply to the agent on top of its own: the most restrictive one wins. effectiveCap then also counts them, and when one sets it, effectiveCap.scope is team or org (limitedBy stays rule). scopeLimits lists those rules in the same shape as ruleLimits, plus scope, with the figures of the bucket the agent's payments fall in (its subteam, its person, itself or the whole scope); it is left out when there are none. The agent never gets the subteam's id or name. Only an owner or an admin of the organization can change a subteam or organization rule, in the panel.
New agents start with one such rule, tope-semanal: the agent's whole spend per UTC week (Monday to Sunday) stays within 5 times its daily cap. It is an ordinary rule a human can change or delete in the panel, and it does not follow later changes of the daily cap.
What does propose_rule do?
propose_rule adds a spending rule that only restricts the agent's own payments, when the user asks for it in the conversation, for example "don't spend more than 2 USD a day on api.dune.com". It is not read-only, but it can never widen what the agent may pay. Available since @burnbound/mcp 0.5.0.
| Input | Notes |
|---|---|
action |
Required. deny blocks matching payments, limit caps them, alert only records them in the audit. |
hosts |
Up to 10 hosts, allowHosts syntax (api.example.com, *.example.com). Left out: every host. |
pathPrefixes |
Up to 10 paths starting with /. |
payeeAddresses |
Up to 10 payTo addresses. |
amountOverUsd |
Only payments of more than this many USD. |
maxUsd, maxCount |
limit only: the most USD (above 0) or payments per window. |
per |
limit only: day, week (from Monday) or month, in UTC. |
groupBy |
limit only: one cap for the whole agent (agentId, default), or one per host or payeeAddress. |
expiresInMinutes |
15 to 1440, default 240. |
The result has ruleId (chat- and 8 hex characters), expiresAt and a fixed message. Burnbound decides everything on its side: the rule is enforced, belongs to this agent only, never asks for an approval, a deny needs a condition, at most 10 rules proposed from the chat apply at once, and an agent may propose 20 per hour. A rule identical to an active one is not added again. There is no way to change, extend or delete a rule from the chat, not even one the agent proposed: only a human can, in the Burnbound panel, and every rule added this way is in the audit (policy.chat_rule_added). Errors are those of any tool, plus rule_rejected (reason, fields) and rule_limit_reached (max).
What does list_payments return?
list_payments returns the agent's most recent payments, newest first. It is read-only.
| Input | Notes |
|---|---|
limit |
1 to 50, default 10. |
status |
Only payments in this status: created, authorized, submitted, settlement_pending, settled, failed or expired. |
The result is { agentId, payments }. Each payment has intentId, status, amountUsd, network, asset, host, transactionHash (once settled) and createdAt. It returns the host that was paid, not the full URL.
What does get_approval_status return?
get_approval_status tells the agent whether a human has decided on a payment that needed approval. It takes the approvalId from a pending_approval result and is read-only.
It returns approvalId, status (pending, approved, denied or expired), intentId (set once the approved payment was made), amountUsd, host, createdAt, decidedAt and expiresAt. An agent key only sees its own agent's approvals; any other id is approval_not_found.
What does search_paid_apis return?
search_paid_apis searches Burnbound's catalog of verified paid APIs (x402 exact in USDC on Base or Base Sepolia, and MPP tempo.charge in USDC.e on Tempo) and says, for each one, whether fetch_paid would pay it under the agent's policy. It is read-only. Available since @burnbound/mcp 0.3.0. People can browse the same catalog at /apis, with one page per API.
| Input | Notes |
|---|---|
query |
Required, 1 to 200 characters: what the API should do, for example crypto prices. |
category |
Only this category, for example search, market-data, onchain-data or scraping. |
network |
Only APIs payable on eip155:8453 (Base) or eip155:84532 (Base Sepolia). |
method |
Only APIs whose last probes measured this payment method or protocol: x402.exact, mpp.tempo.charge, or just x402 or mpp. |
limit |
1 to 10, default 5. |
The result is { agentId, query, total, results }. Each result has:
| Field | Meaning |
|---|---|
id, name, host, category |
The seller. host is the exact host that charges. |
summary |
A short description written by Burnbound. |
url, method, exampleBody |
Burnbound's example request, always on host. Pass them to fetch_paid. |
priceUsd, network, testnet |
The price per call in USDC and the network fetch_paid would pay on: the agent's network when the seller accepts it. |
verifiedAt |
When Burnbound last checked, without paying, that the URL answers a valid x402 challenge it can pay. Results older than 24 hours never show. |
payToMode |
pinned: Burnbound knows the seller's receiving addresses and suspends the seller if they change. rotating: the seller uses a new one each time. |
reliability |
{ sample, successRate }. The success rate of real payments through Burnbound over 30 days, only when at least 5 organizations made at least 20 payments; otherwise sample is insufficient and successRate is null. |
quality |
{ window, probes, availability, price, payTo } from Burnbound's own unpaid probes over 7 days. availability is the share that answered a payable 402 (null below 4 probes). price and payTo are stable, changed (compare before paying), insufficient (too few probes) or, for payTo, rotating. null when the API has none. |
paymentMethods |
Every payment method Burnbound measured in the seller's 402, payable or not: { protocol, method, rail, assetSymbol, payableByBurnbound, lastSeenAt }, for example x402.exact on eip155:8453 in USDC, or mpp.tempo.charge on eip155:4217 in USDC.e. Never a receiving address. |
payable |
Whether one of those methods is allowed by the agent's allowMethods, allowNetworks and assets. false when the API does not say. Caps and approvals are in allowedByPolicy. |
paidDelivery |
Since 0.9.0. Burnbound's own real payment to the seller's example (the paid audit): { verdict, reason, checkedAt, method, network, amountUsd, httpStatus, txHash, explorerUrl }, its transaction checked on chain. verdict: "useful": delivery verified with a real payment, the paid answer served what the example asks for. not_useful (empty body, only an error or an HTML page) and not_delivered (no 2xx) mean the seller charged and did not deliver: prefer another one. explorerUrl is the transaction on BaseScan, built by the MCP from network. null when Burnbound never audited the seller. |
allowedByPolicy, requiresApproval, policyBlockers |
Whether the agent's policy lets fetch_paid pay it, whether a human must approve it first, and the policy codes that block it (host_not_allowed, network_not_allowed, amount_exceeds_per_transaction…). |
sellerDescription |
{ untrusted: true } when the seller describes itself. The text is only in a separate block, fenced and labelled as untrusted. |
The catalog never widens what an agent may pay on its own. An agent without a policy still gets results, each with policyBlockers: ["no_policy"]: it cannot pay anyone until its policy is set in the dashboard. A result with host_not_allowed stays blocked in fetch_paid until a human adds the host to the agent's allowed hosts, or turns on the agent's catalog-hosts rule (allowCatalogHosts): then a listed seller is allowed with requiresApproval: true, because its first payment always waits for a human. With the verified-sellers-only rule (verifiedSellersOnly), policyBlockers also carries seller_not_verified or pay_to_not_verified (see Concepts). Ranking uses only Burnbound's own text, the agent's policy, measured reliability, freshness and price; there are no paid placements.
What does diagnose_payment return?
diagnose_payment explains why paying a URL fails: one sentence with the cause and what to do, the error fetch_paid would return, and a report a human can paste into a bug report. It never signs or pays, does not touch the agent's budget, and is marked to the MCP client as read-only. Available since @burnbound/mcp 0.4.0. The agent should call it after fetch_paid fails with invalid_payment_required, no_payable_entry, resource_mismatch, insufficient_funds or payment_rejected_by_seller.
| Input | Notes |
|---|---|
url |
Required. The https:// URL whose payment fails. It does not have to be on the agent's allowed hosts, because nothing is paid. |
method |
GET (default), POST, PUT, PATCH or DELETE. Some sellers charge only on POST. |
wallet |
The paying wallet's address, to check its USDC balance. Default: the agent's registered wallet, else the local wallet, if there is one. |
intentId |
Since 0.8.0. The intentId of a fetch_paid that failed with payment_rejected_by_seller or payment_not_completed. For an MPP tempo.charge payment the seller did not serve, the cause is mpp_tx_withheld and the reason says whether it may still settle (may_still_settle), settled without the service (settled_without_service) or expired without a charge (expired_unsettled). The payment read is in paidIntent. Read-only: one read of the agent's payments. |
It requests the URL once, without a payment header and with the same guards as fetch_paid (https:// only, private addresses blocked, same-origin redirects only). It reads the 402 and, when a wallet is known, the wallet's USDC balance from the RPC of the payment's network (BURNBOUND_BASE_RPC_URL, BURNBOUND_BASE_SEPOLIA_RPC_URL). The URL goes only to the seller and the wallet address only to the RPC. The Burnbound API is only asked for the agent's registered wallet and its rules (one read of its budget), and is never told the URL.
The checks run in the order fetch_paid applies them, so the cause is the first error a real attempt would hit:
cause.code |
cause.fetchPaidError |
Cause |
|---|---|---|
invalid_402 |
invalid_payment_required |
The 402 has no accepts list, or it cannot be read. |
x402_version_mismatch |
invalid_payment_required or no_payable_entry |
The seller mixes x402 v1 and v2 fields, or speaks only v1. |
unsupported_payment_option |
no_payable_entry |
No option is exact USDC on Base or Base Sepolia; accepts[].reasons says why per option. |
insufficient_balance |
insufficient_funds |
The wallet holds less USDC than the price on that network. |
resource_host_mismatch |
resource_mismatch |
The 402 asks to be paid for a resource on another host, or redirects to another origin. |
seller_unreachable, seller_error, served_free, not_402 |
seller_unreachable, seller_timeout or null |
The seller is down or failing, serves the URL for free, or does not answer 402. |
no_payable_offer |
no_payable_offer |
After 0.5.0: the 402 offers only MPP (WWW-Authenticate: Payment) and no x402 option, and none of its offers is one Burnbound pays (since 0.6.0, tempo.charge in pull mode, enabled for the agent). otherOffers lists them. |
mpp_tx_withheld |
payment_rejected_by_seller |
Since 0.8.0, only with intentId: an MPP tempo.charge payment the seller did not serve. reasons: may_still_settle, settled_without_service or expired_unsettled. |
The result has status (problem or no_problem_found), summary (the cause and what to do), explanation, action, cause (code, reasons, fetchPaidError; null when no problem was found), warnings, request (method, URL without the query string, HTTP status, x402 version), resourceHost, accepts (each payment option and whether Burnbound can pay it), wallet (address, where it came from, balance, amount needed, RPC host), chatRules (rules proposed from the chat that can block or cap a payment to that host), ruleBlocks (since 0.5.0: the agent's limit rules that would refuse this payment now, because they leave less than its price or no payment; each named by ruleId with limit, what it leaves and resetsAt) and issueReport, a Markdown report without the query string and with the wallet shortened. A rule in ruleBlocks makes status problem even when the 402 itself is fine, and doctor then exits 2.
warnings never block a payment: no_wallet, balance_not_checked, instruction_like_text (the 402's text reads like instructions to an agent), mixed_mainnet_testnet, x402_version_mismatch and some_entries_unpayable.
No seller text comes back: the 402's description and error are dropped, and any seller field that is not a plain token shows as [unreadable]. Errors are those of any tool, plus invalid_input (https_required, invalid_url, contains_credential, invalid_wallet) and private_address_blocked.
What does stripe_refund do?
stripe_refund refunds a Stripe charge under the agent's spending policy. It needs the action gateway: a small service you run with your own restricted Stripe key (setup guide). The server only talks to the gateway at BURNBOUND_GATEWAY_URL, with the agent's key, and never sees the Stripe key. Without BURNBOUND_GATEWAY_URL the tool answers gateway_not_configured and refunds nothing. It moves real money, so it is marked as destructive to the MCP client.
| Field | Required | Meaning |
|---|---|---|
chargeId |
this or paymentIntentId |
The Stripe charge to refund (ch_…). |
paymentIntentId |
this or chargeId |
A Stripe payment intent (pi_…): its latest charge is refunded. |
amountMinor |
no | Amount in the currency's minor unit (cents for EUR or USD), for a partial refund. Default: all that is still refundable. |
reason |
no | Stripe's refund reason: duplicate, fraudulent or requested_by_customer. |
idempotencyKey |
no | Only to retry a refund, with the key of the earlier result. Without it, it is derived from the arguments: the same refund asked twice is refunded once. |
The gateway reads the currency, the customer and what is still refundable from Stripe, never from the agent, and refuses an amount over what is refundable. Burnbound then decides with the agent's policy: the method action.stripe.refund must be allowed (it is off by default), stripe-refund.action must be in the allowed hosts, and the refund counts as spend toward the agent's caps, in USD. Only on allow does the gateway create the refund, under Stripe's idempotency key bb_<intentId>.
Which results can stripe_refund return?
refunded: done.refundId(re_…),intentId,amountMinor,currency,chargeId,idempotencyKeyandreported.reported: falsemeans Stripe made the refund but the gateway could not tell Burnbound: the payment stayssubmittedin Burnbound and keeps counting as spend.replayed: truemeans this key's refund had already been made and nothing new was refunded.pending_approval: the refund is at or above the agent's approval threshold, or a rule holds it, and nothing reached Stripe. It carriesapprovalId,amountUsd,reason,thresholdUsd,idempotencyKey,nextand, when the dashboard origin is known,approvalUrl. As withfetch_paid, a client that supports it offers the user the approval page and the call waits briefly for the decision, then refunds once approved. Otherwise pollget_approval_statuswithapprovalIdand, once it isapproved, callstripe_refundagain with the same arguments andidempotencyKey. A denied or expired approval isrefund_approval_deniedorrefund_approval_expired; do not retry it.
Denials and failures come back as tool errors: see the stripe_refund codes.
What do stripe_credit and shopify_refund do?
Two more actions through the same action gateway as stripe_refund (BURNBOUND_GATEWAY_URL), since 0.11.0. They work like stripe_refund: the gateway reads the real figures from the provider, never from the agent, Burnbound decides with the agent's policy, and the action runs only on allow. Each needs its method turned on for the agent (action.stripe.credit, action.shopify.refund, off by default), counts as spend, is held by the same rules and approvals, and runs once per idempotencyKey. Both are marked as destructive to the MCP client. How the policy decides them is in Refund rules.
stripe_credit adds a credit to a Stripe customer's balance, applied to their next invoices, for example a goodwill credit.
| Field | Required | Meaning |
|---|---|---|
customerId |
yes | The Stripe customer to credit (cus_…). |
amountMinor |
yes | Amount in the currency's minor unit as Stripe counts it: cents for EUR or USD, whole yen for JPY. |
currency |
no | ISO 4217 code. Default: the customer's balance currency, which the gateway reads from Stripe. Needed only for a customer without one. |
idempotencyKey |
no | Only to retry a credit, with the key of the earlier result. Without it, it is derived from the arguments: the same credit asked twice is made once. |
context |
no | Facts about why, for example {"ticket": "OPS-1423"}, shown to whoever approves as declared by the agent and unverified. Never part of the idempotency key. |
It returns credited with creditId, intentId, amountMinor and currency, or pending_approval as stripe_refund does.
shopify_refund refunds money of a Shopify order to its original payment, without restocking. The gateway reads the order, its customer, its currency and what is left to refund from the store with its own Admin API token.
| Field | Required | Meaning |
|---|---|---|
orderId |
yes | The order's numeric id: the number in the Shopify admin URL, not the order name like #1001. |
amountMinor |
no | Amount in the order currency's minor unit, for a partial refund. Default: all that is still refundable. |
idempotencyKey |
no | Only to retry a refund, with the key of the earlier result. Without it, it is derived from the arguments: the same refund asked twice is refunded once. |
context |
no | As in stripe_credit. |
It returns refunded with refundId, intentId, amountMinor and currency, or pending_approval. A gateway without a Stripe key answers stripe_credit with action_not_configured, and one without a Shopify store does the same for shopify_refund.
What does request_mandate do?
request_mandate asks a human, once, to approve a budget for one task the user gave the agent, instead of an approval per payment. For example: "buy 3 licences of the search API, at most 300 USD, within 2 hours". It is available since 0.11.0. The whole model is in Task mandates.
| Field | Required | Meaning |
|---|---|---|
purpose |
yes | What the task is, in the user's words (up to 200 characters). Shown to whoever approves. |
methods |
yes | The payment methods it covers, among those turned on for the agent: x402.exact, mpp.tempo.charge, card.stripe_issuing, action.stripe.refund, action.stripe.credit, action.shopify.refund. |
hosts |
no | Seller hosts it covers. Omitted: any host the policy allows. |
merchantCategories, merchantCountries |
no | For cards: the Stripe merchant categories and merchant countries (ISO 3166-1 alpha-2) it covers. |
payees |
no | Payees it covers. Omitted: any. |
maxUsd |
yes | The most the task may spend in total, in USD. At most the daily cap for each day it lasts. |
maxPayments |
no | The most payments it covers, up to 1000. |
durationMinutes |
yes | How long it lasts once approved, in minutes, at most 7 days. |
context |
no | Facts about the task, shown to whoever approves as declared by the agent and unverified. |
It returns mandateId, status (pending until an owner or admin approves it), mandateUrl, remainingUsd and expiresAt. Only a signed-in owner or admin approves, rejects or revokes it, in the Burnbound panel. mandateUrl is offered from the chat like a held payment, and the agent's key cannot decide it.
While it is active, the payments of that task that would only wait for the approval threshold or an approval rule pass without asking again, up to maxUsd in total (and maxPayments), on the methods and hosts in scope. fetch_paid and stripe_refund return the mandateId that covered a payment. A mandate never lifts a cap, a deny, a security hold (a new payee, a new API, a 402 that reads like instructions) or the organization's decision webhook. A payment that fails gives its amount back to the mandate.
get_mandate_status takes mandateId and returns status (pending, active, rejected, expired, exhausted or revoked), spentUsd, remainingUsd and expiresAt.
What errors can a tool return?
Errors come back as an MCP tool error whose content is {"error": {"code", "message", …}}. The code is stable; the message is fixed text written by the server, never copied from the Burnbound API or from the seller. Extra fields are only ids, amounts and codes the server validated, and text the server writes from them (summary). The one exception is sellerReason, the seller's own words, which always comes fenced and labelled as untrusted (as do seller descriptions in search_paid_apis).
{
"error": {
"code": "policy_denied",
"message": "The agent's spending policy denied this payment, so nothing was paid. See reasons.",
"reasons": ["daily_cap_exceeded"],
"policyVersion": 4
}
}
Any tool:
| Code | Meaning |
|---|---|
invalid_input |
The input is invalid. reason says why (see below). |
unauthorized |
The API rejected BURNBOUND_KEY. |
forbidden |
The key is not allowed to do this. |
not_found |
The API did not find the resource. |
agent_not_found |
The configured agent does not exist for this key. |
approval_not_found |
No approval with that id for this agent. |
rate_limited |
The API is rate limiting requests. Retry later. |
api_unavailable, api_unreachable, api_timeout, api_error |
The Burnbound API could not answer. Retry later. |
invalid_response, response_too_large |
The API answer could not be read. |
config_invalid |
The server is misconfigured. |
internal_error |
Unexpected error in the server. |
invalid_input reasons from fetch_paid include https_required, invalid_url, url_credentials, burnbound_api_url (the URL is the Burnbound API itself), contains_credential (the input contains the Burnbound key or a wallet key), body_not_allowed, body_too_large, too_many_headers, invalid_header, reserved_header, invalid_max_amount, and approval_state_mismatch or invalid_approval_state (a retry after the approval page that does not match the held call).
fetch_paid, nothing was sent:
| Code | Meaning |
|---|---|
host_not_allowed |
The URL's host is not in the agent's allowed hosts nor in its catalogHosts. host. |
private_address_blocked |
The URL resolves to a private, loopback or link-local address. |
control_plane_unavailable |
The agent's allowed hosts could not be loaded, so nothing was requested. |
fetch_paid, nothing was paid:
| Code | Meaning |
|---|---|
seller_unreachable, seller_timeout |
The URL could not be reached, or did not answer in time. |
invalid_payment_required |
The URL answered 402 without a readable PAYMENT-REQUIRED header. |
no_payable_offer |
After 0.5.0: the 402 offers only payment options Burnbound does not pay and no x402 option, so nothing was signed. Since 0.6.0 Burnbound pays MPP tempo.charge in USDC.e on Tempo (pull mode, one payee, chain declared) when the agent has it enabled; any other MPP method, or a tempo.charge it cannot pay, ends here. protocols, methods. |
no_payable_entry |
No price in the 402 is exact USDC on Base or Base Sepolia with a whole amount. reason. |
amount_exceeds_max |
The price is over maxAmountUsd. maxAmountUsd, amountUsd. |
resource_mismatch |
The seller asked to be paid for a different host than the one requested. |
policy_denied |
The policy denied the payment. reasons (see Concepts) and policyVersion. reasons can carry pay_to_not_verified for any agent (the seller is in the Burnbound catalog with pinned receiving addresses on this network, and asked to be paid at another one) and, with the verified-sellers-only rule, seller_not_verified (the host is not a listed catalog seller). hint comes when a reason needs a human; see below. Since 0.5.0, rules names the agent's rules that denied it (with rule_denied or rule_limit_exceeded), and chatRules the rules proposed from the chat that can block that host. |
plan_limit_reached |
The organization reached a plan limit. plan, limit (for example agents, custom_rules, team_features or notification_channels), max and current on counted limits, upgradeUrl. |
approval_required |
The payment needs an approval this API cannot track. |
approval_denied |
A human denied the payment. Do not retry it. |
approval_expired |
The approval expired. Call fetch_paid without idempotencyKey to ask again. |
approval_consumed |
That approval was already used for a payment. Check list_payments. |
approval_queue_full |
Too many payments are waiting for approval. Retry later. |
idempotency_key_reused |
That idempotencyKey belongs to a different request. |
intent_not_replayable |
The payment for that idempotencyKey failed or expired. Omit the key to start a new payment. |
payment_in_progress |
Another payment of this agent is in progress. Retry shortly with the same idempotencyKey. Since 0.9.0 also when two requests with that key raced (the API's idempotency_conflict). |
payment_request_rejected |
The API rejected the payment request. apiCode. |
client_signing_unavailable |
The agent uses client-side signing, which this server could not set up. |
insufficient_funds |
The paying wallet holds less of the payment's asset (USDC, or USDC.e on Tempo) than the payment on that network. summary, payer, network, networkName, balanceUsdc, amountUsdc. Nothing was signed. See below. |
hint is fixed text next to reasons, for a denial only a human can resolve. member_cap_exceeded: the agent belongs to a person of the organization, and that person reached their daily sub-cap across all their agents, or has none yet. The agent should not retry today; a human asks an admin of the organization to set or raise the sub-cap. get_budget shows the sub-cap in member. rule_denied and rule_limit_exceeded: a spending rule that applies to the agent, named in rules, refused the payment. Since 0.7.0, ruleScopes says whose each rule is (agent, team for its subteam, or org) when the API names it; a pending_approval held by a rule (reason: "rule") carries the same two fields. get_budget shows what each limit rule leaves (ruleLimits, and scopeLimits for the subteam and the organization) and when it resets; only a human can change a rule, in the panel.
With a catalog rule on, the API reads the catalog before it decides. If it cannot, it decides nothing and answers catalog_unavailable, which fetch_paid reports as catalog_unavailable since 0.9.0 (api_unavailable before): retry in a minute. Without a catalog rule, the API goes on without the catalog when it cannot read it, and a receiving address the organization has not paid before waits for approval (new_pay_to).
insufficient_funds comes from a balance check the Burnbound API runs before it reserves or signs anything, when it has an RPC for the payment's network and knows the paying wallet's address. summary reads, for example, Wallet 0x1234…5678 has 0.00 USDC on Base; this payment needs 0.01 USDC. Nothing was signed or paid. Add USDC to that wallet on that network, then call fetch_paid again. The check is advisory: the balance can change between the check and the seller's settlement, so a payment that passes it can still be refused by the seller. If the RPC fails, the API skips the check and goes on.
fetch_paid, the agent's wallet in Burnbound, nothing was paid (since 0.9.0):
These come with walletUrl, the agent's wallet section in the Burnbound panel (/app?agente=<agentId>#conexion), or null when the server has no panel origin (BURNBOUND_APP_URL). Give the user the link: only a human connects or fixes a wallet.
| Code | Meaning and what to do |
|---|---|
no_wallet_connector |
The agent has no wallet in Burnbound, so nothing was signed. A human connects a wallet to this agent in the panel, then the agent calls fetch_paid again. Before 0.9.0 it came back as api_error. |
signer_unavailable |
Burnbound has no wallet to sign for this agent. A human connects one in the panel. |
connector_unavailable |
Burnbound could not open the agent's wallet. Retry in a minute with the same idempotencyKey; if it keeps failing, a human reconnects the wallet. |
connector_not_supported |
The wallet connected to the agent is of a kind this API cannot use. A human connects a supported one: Coinbase CDP, a signer URL or a wallet on the user's machine. |
wallet_connector_invalid |
The wallet provider refused the connected wallet: Coinbase CDP credentials no longer valid, or the wallet no longer exists. A human reconnects it. |
signer_failed |
The signer URL connected to the agent failed, timed out, redirected or answered something unreadable. A human checks that service and its connection. |
signature_invalid |
The connected wallet returned a signature that does not verify (another key, or other data). A human checks the wallet connected to the agent. |
unsupported_payment_request |
The connected wallet cannot sign this payment: its network, token or kind of signature. Run diagnose_payment; a human can connect a wallet that supports it. |
fetch_paid, the wallet provider refused, nothing was paid (since 0.9.0):
| Code | Meaning and what to do |
|---|---|
wallet_policy_denied |
The wallet provider's own policy (Coinbase CDP) refused to sign. Do not retry: a human checks that wallet's policy in the provider's console. Burnbound cannot change it. Before 0.9.0, forbidden. |
wallet_rate_limited |
The wallet provider is rate limiting signatures. Wait a few seconds and retry with the same idempotencyKey. Before 0.9.0, rate_limited. |
wallet_upstream_error |
The wallet provider failed to sign, or returned a signature that does not match. Retry in a minute with the same idempotencyKey; if it keeps failing, a human checks the wallet with its provider. Before 0.9.0, api_unavailable. |
fetch_paid, Burnbound could not decide safely, nothing was paid (since 0.9.0):
Burnbound fails closed: when it cannot read something it needs to decide, it does not pay. Before 0.9.0 these came back as api_unavailable, payment_request_rejected or api_error.
| Code | Meaning and what to do |
|---|---|
rules_unavailable |
The spending rules of the agent's team or organization could not be read. Retry in a minute with the same idempotencyKey; if it keeps failing, tell a human. |
plan_unavailable |
The organization's spending lock could not be taken. Retry in a minute with the same idempotencyKey; if it keeps failing, tell a human. |
catalog_unavailable |
The catalog of checked sellers, which the agent's policy needs, could not be read. Retry in a minute with the same idempotencyKey; if it keeps failing, tell a human. |
chain_unavailable |
Burnbound could not check on chain whether an earlier signature for this payment was used, so nothing new was signed. Retry in a minute with the same idempotencyKey; it never charges twice. |
authorize_failed |
The Burnbound API failed while deciding. Retry once with the same idempotencyKey; if it fails again, tell a human. |
intent_closed |
The payment expired or was closed while it was being signed. Call fetch_paid again without idempotencyKey to start a new payment. |
signature_reused |
This payment's signature was already used, so nothing was signed again. Call list_payments to see what became of it. |
fetch_paid with MPP tempo.charge, nothing was paid (since 0.6.0):
| Code | Meaning |
|---|---|
payer_unknown |
Burnbound does not know the agent's wallet address. A human runs npx -y @burnbound/mcp wallet prove and registers the address. |
signature_live |
An earlier signature for this payment may still be mined until it expires, so nothing new was signed. Retry with the same idempotencyKey after retryAfterSeconds; it never charges twice. |
challenge_expired |
The seller's MPP challenge expires too soon to be paid. Call fetch_paid again to get a new one. |
challenge_reused |
That MPP challenge was already paid on this host, so nothing was signed again. Call list_payments. |
intent_already_paid |
The chain already shows a payment for this idempotencyKey, so nothing was signed again. Call list_payments. |
fetch_paid with client-side signing, nothing was paid:
| Code | Meaning |
|---|---|
client_wallet_not_initialized |
No local wallet. Run npx -y @burnbound/mcp@latest wallet init and register the address. |
client_wallet_unavailable |
The local wallet could not be opened (reason: keychain unavailable, insecure_permissions…). |
client_wallet_mismatch |
The local wallet is not the one registered for the agent. localAddress, registeredAddress. |
client_sign_refused |
The local signer refused what it was asked to sign. reason, for example agent_key_required with an org key. |
fetch_paid, after paying:
| Code | Meaning |
|---|---|
payment_outcome_unknown |
The signed payment was sent but the seller's answer was lost. intentId, idempotencyKey. Check list_payments; retrying with the same idempotencyKey never charges twice. |
payment_rejected_by_seller |
The seller refused the signed payment: it answered the paid request with another 402, or reported the settlement as failed. The resource was not served. httpStatus, host, intentId, idempotencyKey, mode, amountUsd, network, payTo, receipt, txHash, and sellerReason when the seller gave one. For MPP, also protocol, mayStillSettle and, since 0.8.0, cause: "mpp_tx_withheld" with a hint: charged at most once, do not pay again, wait 30 s and call diagnose_payment with the intentId. Not retried. |
payment_not_completed |
The signed payment was sent, but the seller answered with a status other than 2xx or 402 (a redirect, an error) instead of serving the resource. Same fields as above, plus redirectNotFollowed for a redirect. It may still settle: check list_payments; retrying with the same idempotencyKey never charges twice. |
sellerReason is the seller's own explanation, read from its PAYMENT-RESPONSE or PAYMENT-REQUIRED header or its JSON error body, for example Facilitator validation failed: Invalid payment. It is third-party text: in the tool result it comes in a separate block fenced and labelled as untrusted, never in message, and structuredContent carries it as sellerReason: { untrusted: true, text }. In both cases fetch_paid reports the receipt to Burnbound as failed, with the seller's status and reason, so the payment's record and the audit log keep what went wrong. A failed receipt does not free the daily cap: the payment counts until it expires unsettled.
stripe_refund, nothing was refunded unless the row says otherwise:
| Code | Meaning |
|---|---|
gateway_not_configured |
BURNBOUND_GATEWAY_URL is not set. A human must run the action gateway and set it. |
gateway_unreachable |
The gateway at BURNBOUND_GATEWAY_URL could not be reached. |
gateway_timeout |
The gateway did not answer in time. The refund may or may not have happened: retry with the same idempotencyKey. |
gateway_error |
The gateway gave an unexpected answer. Retry with the same idempotencyKey, or check the gateway's logs. |
refund_denied |
The policy denied the refund. reasons (for example method_not_allowed, amount_exceeds_per_transaction), policyVersion. |
refund_approval_denied |
A human denied the refund. Do not retry it. |
refund_approval_expired |
The approval expired. Call stripe_refund with a new idempotencyKey to ask again. |
refund_amount_exceeds_refundable |
The amount is over what is still refundable. refundableMinor, currency. |
refund_not_refundable |
The charge did not succeed or is fully refunded already. |
refund_charge_not_found |
Stripe does not know that charge or payment intent. |
refund_idempotency_conflict |
That idempotencyKey belongs to a different refund. |
refund_failed |
Burnbound allowed the refund but Stripe refused it. stripeCode, intentId. |
stripe_unavailable |
The gateway could not read the charge from Stripe. Retry later. |
stripe_credit and shopify_refund, nothing was done unless the row says otherwise:
The gateway's own failures (gateway_not_configured, gateway_unreachable, gateway_timeout, gateway_error) are the same as for stripe_refund. shopify_refund shares refund_denied, refund_approval_denied, refund_amount_exceeds_refundable, refund_not_refundable and refund_idempotency_conflict with it.
| Code | Meaning |
|---|---|
gateway_not_trusted |
Burnbound does not trust this gateway for the agent's organization. A human must create it in the panel and set its id and secret on the gateway. |
action_not_configured |
The gateway has no Stripe key (stripe_credit) or no Shopify store (shopify_refund). A human must configure it on the gateway. |
credit_denied |
The policy denied the credit. reasons says why. Do not retry it. |
credit_approval_denied |
A human denied the credit. Do not retry it. |
credit_approval_expired, shopify_refund_approval_expired |
The approval expired. Call the tool again with a new idempotencyKey to ask again. |
credit_customer_not_found |
Stripe does not know that customer, or it was deleted. |
credit_currency_mismatch |
The customer's balance is in another currency (currency). Ask again in that currency or without currency. |
credit_currency_required |
The customer has no balance currency yet. Pass currency. |
credit_idempotency_conflict |
That idempotencyKey belongs to a different credit. Repeat the original request exactly or use a new key. |
credit_failed, shopify_refund_failed |
Burnbound allowed it, but the provider refused it (stripeCode or shopifyCode). |
credit_outcome_unknown, shopify_refund_outcome_unknown |
The provider did not say whether it ran. Call the tool again with the same idempotencyKey: it never runs twice and settles this one. |
shopify_order_not_found |
Shopify does not know that order. |
shopify_live_not_allowed |
The store is not a development store and the gateway does not allow real money (GATEWAY_ALLOW_LIVE). Only a human can change that, on the gateway. |
shopify_unavailable |
The gateway could not read the order from Shopify. Retry later. |
request_mandate and get_mandate_status, nothing was asked:
| Code | Meaning |
|---|---|
mandate_exceeds_caps |
maxUsd is over the agent's daily cap times the days the task lasts. Ask for less or for a longer task. |
mandate_queue_full |
The agent already has 5 mandates waiting for a human. Wait for them to be decided. |
mandate_rejected_request |
The Burnbound API refused the request (reason). |
mandate_rejected |
A human rejected the mandate. Its payments wait for an approval each, as before. |
mandate_expired |
It expired before a human approved it. Ask again only if the user still wants it. |
mandate_not_found |
No mandate of this agent has that id. |
Which wallet commands are there?
The wallet CLI manages the local wallet used for client-side signing. Run it with npx -y @burnbound/mcp@latest wallet <command>; it never starts the MCP server. The private key is stored in the macOS keychain, the Linux Secret Service (GNOME Keyring, KWallet) when a session bus is available, or otherwise a file in ~/.burnbound/wallets/ (directory 0700, file 0600).
| Command | What it does |
|---|---|
wallet init |
Creates a wallet and prints its address. Refuses if the profile already has one. |
wallet address [--all] |
Prints the address (--all: also retired ones). Does not unlock the key. |
wallet import [--from-env VAR] |
Stores an existing key, read from stdin (hidden on a terminal) or once from the variable VAR. Remove the variable afterwards. |
wallet export [--address ADDR] |
Prints the key, only on an interactive terminal (never to a pipe or a file), after you type export <address> to confirm. |
wallet rotate |
Switches to a new key and keeps the old one so you can move its funds (wallet export --address <old>). Register the new address. |
wallet prove "<challenge>" |
Signs the one-line ownership challenge the dashboard shows when you register the address, and prints the signature. It signs nothing else, and no funds move. |
Options:
--profile <name>: wallet profile. DefaultBURNBOUND_WALLET_PROFILE, elsedefault. Use one profile per agent.--backend <kind>: forinitandimport, the storage:macos-keychain,secret-serviceorfile. The storage is chosen once, atinit; later runs never fall back to another one. On Windows onlyfileis available, and it is experimental.
npx -y @burnbound/mcp@latest wallet init
npx -y @burnbound/mcp@latest wallet address
How do I check a failing payment from a terminal?
doctor runs the same checks as diagnose_payment from a terminal. It needs no Burnbound account, no key and no MCP client, never calls the Burnbound API (except --intent), and never signs or pays.
npx -y @burnbound/mcp@latest doctor https://api.example.com/paid --wallet 0xYourWallet
It prints the cause, what to do, any warnings and a report to paste into an issue, without the query string and with the wallet shortened.
| Option | Meaning |
|---|---|
--wallet <address> |
Wallet whose USDC balance to check. Default: the local wallet's address, if there is one. Its key is never loaded. |
-X, --method <M> |
GET (default), POST, PUT, PATCH or DELETE. |
--profile <name> |
Local wallet profile. Default BURNBOUND_WALLET_PROFILE, else default. |
--base-rpc <url> |
RPC for Base. Default BURNBOUND_BASE_RPC_URL, else https://mainnet.base.org. |
--base-sepolia-rpc <url> |
RPC for Base Sepolia. Default BURNBOUND_BASE_SEPOLIA_RPC_URL, else https://sepolia.base.org. |
--intent <intentId> |
Since 0.8.0. A payment fetch_paid sent that the seller did not serve, as intentId in diagnose_payment. Needs BURNBOUND_KEY: it reads the agent's payments. |
--json |
Print the whole report as JSON, with the fields of diagnose_payment. |
-h, --help |
Show the help. |
| Exit code | Meaning |
|---|---|
0 |
No problem found. |
2 |
A problem was found; the output says which. |
1 |
The check could not run: bad arguments, an invalid RPC URL or a private address. |