Concepts
Burnbound sits between an AI agent and the money it moves: Stripe refunds, Stripe Issuing card authorizations and x402 or MPP API payments. This page explains the pieces: agents, the ways an agent spends, what counts as spend, policies, caps, allowed hosts, custom spending rules, subteams and organization rules, human approvals, signing modes, and how an x402 v2 payment flows through them.
What is Burnbound?
Burnbound is spend control for AI agents. Before an agent refunds a Stripe charge or a Shopify order, credits a Stripe customer, pays with a Stripe Issuing card or pays an x402 or MPP API, Burnbound checks it against rules a person set: where it may send money, how much per payment, how much per day, what a team may spend together, and when a human must approve. Only then does the money move, and only from where it already is.
Burnbound never holds funds, card numbers, wallet keys or your Stripe secret key. Refunds run in an action gateway you host with your own restricted Stripe key, card money stays in your Stripe Issuing balance, and API payments are signed by a wallet you bring. For paid APIs, Burnbound is not a wallet, not an x402 facilitator and not a seller paywall, and it never settles payments: sellers do.
What is an agent?
An agent is one identity that pays: it has its own policy, its own keys (bb_agent_…) and its own wallet connection. Use one Burnbound agent per AI agent or workload, so caps, approvals and audit stay separate.
An agent key can only act for its own agent: read its budget and payments, ask to authorize a payment, report a receipt and check its own approvals. It cannot widen its rules, approve payments or create keys. Those actions need a human signed in to the dashboard. The one thing an agent can add is a rule that restricts itself further, when the user asks for it in the chat (propose_rule, see MCP tools).
Several agents can work as one team, for example a main agent and its sub-agents, each running its own MCP server with its own key. Give each one its own Burnbound agent and put them in a subteam: each keeps its own caps and audit, and the subteam's rules cap what they spend together. See How do subteams work?.
Which ways can an agent spend?
An agent can move money in several ways, called payment methods. Each one is turned on per agent in its Network tab, under Payment methods; only x402 is on by default. They all go through the same policy, approvals and audit.
| Method | What it is | Where the money moves | How the agent asks |
|---|---|---|---|
x402.exact and mpp.tempo.charge |
A payment to an API that answers 402 Payment Required: USDC on Base, or USDC.e on Tempo |
From your wallet to the seller | fetch_paid |
card.stripe_issuing |
An authorization on the agent's card from your Stripe Issuing account | Your Stripe Issuing balance, to the merchant | No tool: Stripe asks Burnbound before each authorization, within 2 seconds |
action.stripe.refund |
A refund of a Stripe charge, run by the action gateway you host with your restricted Stripe key | Your Stripe account, back to the customer | stripe_refund |
action.stripe.credit |
A credit to a Stripe customer's balance, applied to their next invoices, run by the same gateway | Your Stripe account, as balance for the customer | stripe_credit |
action.shopify.refund |
A refund of a Shopify order to its original payment, run by the gateway with your Shopify Admin API token | Your Shopify store, back to the customer | shopify_refund |
Refunds, credits and cards are in beta. Start them in Stripe's test mode or a Shopify development store: the gateway refuses a live Stripe key unless you set GATEWAY_ALLOW_LIVE=1, and Issuing needs Stripe's approval for your account. The setup is in Action gateway: Stripe refunds and Cards with Stripe Issuing. How the policy decides a refund or a credit, with the facts the gateway reads, is in Refund rules.
Every request becomes a payment intent, the record the caps add up. An allowed API payment is reserved, signed, and settled once Burnbound checks the transfer on-chain. A card authorization is reserved when Burnbound approves it, settled when Stripe captures it, and released when Stripe reverses it or the hold expires. A refund is reserved when Burnbound allows it, settled when the gateway reports the Stripe refund (re_…), and released when Stripe refuses it.
What counts as spend?
Every way money leaves counts as spend: API payments, card authorizations and refunds alike. They count toward the maximum per payment, the daily cap, a person's daily sub-cap, subteam and organization budgets, the limits of custom rules and velocity, from the moment they are allowed.
- Amounts are compared in USD. USD always works. Card and refund amounts in other currencies are converted with the European Central Bank's daily reference rates, refreshed hourly, and rounded up to the micro-dollar, so a payment never looks smaller than it is. A server operator can pin a currency's rate (
FIAT_USD_RATES), which then wins over the ECB's. A currency with neither is refused withcurrency_not_supportedbefore the policy runs. The original amount, the currency and the rate are kept with the decision and in the audit. - A card's spend is what was authorized, plus any over-capture. A partial capture does not lower it. A capture above what was authorized, or of an authorization Burnbound did not reserve, is still recorded as spend and flagged (
over_capture,unreserved_capture). It counts toward the caps, team budgets and rule limits even when it goes over them: the money already left, so the next payment sees the real total. - A refund whose outcome is unknown keeps counting. If Stripe refunded but the gateway could not tell Burnbound, the intent stays
submittedand its amount still counts. - Failed and expired payments do not count, nor do card holds Stripe released.
What is a policy?
A policy is the set of rules Burnbound evaluates for every payment of an agent. A payment is allowed only if it passes every rule; otherwise it is denied, nothing is signed, and the decision is recorded with the reasons.
Every agent's policy has:
- Allowed hosts: the hosts the agent may pay.
- Maximum per payment (
maxUsdPerTx) and daily cap (dailyCapUsd), in USD. - Network, method and asset: the agent pays USDC over x402 on Base (the default) or on Base Sepolia, the test network. Paying USDC.e over MPP on Tempo, card authorizations and refunds are separate opt-ins. See Which ways can an agent spend? and Which networks can an agent pay on?.
Optional rules, off by default, can be turned on per agent:
- Challenge rules: extra host patterns, path prefixes and a maximum amount for what the seller's 402 may ask.
- Velocity: a maximum number of payments, or a maximum USD amount, per time window (60 seconds by default).
- Step-up approval: a USD threshold from which a human must approve (see below).
On top of these, you can add your own custom rules to an agent (see What are custom rules?), and an admin can add rules for a whole subteam or the whole organization (see How do subteams work?). Every rule can only restrict: the policy above is the ceiling, and no rule lets an agent pay something the policy refuses.
Some API payments wait for a human on every agent, with no setting: the first payment to a receiving address the organization has not paid before, and a payment whose 402 text reads like instructions to the agent. See How do human approvals work?.
Policies are versioned. Changing the hosts, the caps or the agent's custom rules (from the panel or from the chat) creates a new version, and each decision records the version it used (policyVersion). Subteam and organization rules are versioned on their own.
Which reasons can a denial have?
A denied payment carries one or more reason codes. The MCP tool fetch_paid returns them in reasons of a policy_denied error, stripe_refund in reasons of a refund_denied error, and the dashboard audit shows them for every method, card declines included.
| Code | Meaning |
|---|---|
host_not_allowed |
The host that answered 402 is not in the allowed hosts. |
amount_exceeds_per_transaction |
The amount is over the maximum per payment. |
daily_cap_exceeded |
The amount would take today's spend over the daily cap. |
member_cap_exceeded |
The agent belongs to a person of the organization, and the amount would take that person's spend today, across all their agents, over their daily sub-cap. A person without a sub-cap pays nothing: an admin sets one. |
network_not_allowed |
The seller asked for a network the policy does not allow. |
asset_not_allowed |
The seller asked for an asset the policy does not allow. |
pay_to_denied |
The receiving address (x402 payTo or MPP payee) is on the policy's deny list. |
invalid_amount |
The amount could not be read. |
challenge_host_not_allowed |
Challenge rules: the host is not in the challenge host list. |
challenge_path_not_allowed |
Challenge rules: the path does not start with an allowed prefix. |
challenge_amount_exceeded |
Challenge rules: the amount is over the challenge maximum. |
velocity_tx_exceeded |
Velocity: too many payments in the current window. |
velocity_usd_exceeded |
Velocity: too much USD in the current window. |
resource_host_mismatch |
The seller named a resource on a different host than the one that answered 402. |
seller_not_verified |
Catalog rules: the host is not a listed seller of the Burnbound catalog. |
method_not_allowed |
The seller asked for a payment method the policy does not allow. By default an agent pays only x402 (x402.exact). |
rule_denied |
An enforced custom rule with the action deny matched the payment. The rule may be the agent's, its subteam's or the organization's. |
rule_limit_exceeded |
The payment would take an enforced custom limit over its maximum for the current day, week or month. |
currency_not_supported |
Cards and refunds: the currency has no exchange rate, neither the ECB's daily rate nor one pinned on the server. |
card_not_linked |
Cards: the card names no agent in its burnbound_agent_id metadata, or an agent of another organization. |
decision_timeout |
Cards: the decision did not finish within Stripe's window, and the card connector declines when time runs out. |
pay_to_not_verified |
The seller is in the Burnbound catalog with pinned receiving addresses on this network, and asked to be paid at another address. Applies to every agent. |
What are custom rules?
Custom rules are spending rules you add to an agent on top of its policy, for cases the caps do not cover: a weekly budget, a cap per seller, a ban on one host, an approval for large payments to new payees. Edit them in the dashboard: open the agent, then Rules · custom rules. Changing them needs an owner or an admin of the organization.
Each rule has a name (lowercase letters, digits and hyphens), conditions, an action, a mode and, optionally, an expiry date.
- Conditions (
when) say which payments the rule looks at: hosts (api.example.com,*.example.com), path prefixes, HTTP methods, an amount range in USD, payee addresses (x402payToor MPP payee), the asset, whether the host is a listed catalog seller, the first payment to a host or to a payee, a person of the organization, an hour range in UTC, or what a refund is about (the charge's age in days, the share of the charge refunded, whether it is disputed, the customer's age, the customer's refunds of the last 90 days and the reason). Refund conditions only match refunds, and a fact the action gateway did not send matches them: a missing fact never lets a refund through. Refund rules lists them, with the ready-made policy templates. Every condition you give must hold; a list matches any of its values. A rule without conditions applies to every payment. - Action (
then): deny refuses the payment (rule_denied); require approval holds it for a human (reason: "rule"); limit caps the USD amount or the number of payments per UTC day, week (from Monday) or month, either for the whole agent or with one total per host or per payee, and refuses a payment that would go over (rule_limit_exceeded); alert only records the payment in the audit. - Mode: enforced rules deny or hold payments. Observe only rules block nothing: the decision records what they would have done, so you can try a rule on real traffic before you enforce it. A limit counts the payments it matches in both modes.
Only the payments a limit's conditions match count against it. The dashboard shows each limit's use in the current window ("Used 12 USD of 30 USD · back to 0 on …"), and get_budget gives the agent the same figures in ruleLimits.
Simulate before you save. In the rule form, Simulate the last 30 days replays the rule over the organization's real payments of the last 7, 30 or 90 days (never more than the plan keeps: 30 on Free) and says what it would have blocked, held or let through, with the payments that change. Simulate on a rule of the list does the same for a rule you already have, and subteam and organization rules have both buttons too. Nothing is saved or counted, a simulated rule does not count toward the plan's rules, and anyone in the organization can simulate, viewers too. It is a projection: after a block the agent would have acted differently (another seller, a retry or nothing), and that is not simulated. A rule that reads a fact Burnbound does not compute yet (the HTTP method, the first payment to a host, the seller's availability) says so: live it always takes the restrictive branch too, so a deny on the HTTP method blocks every payment. When the period, or a limit's window, starts before the history Burnbound keeps, the result gives the date the history starts: the totals may come out short. With a very long history, only the most recent payments are simulated, and the result says so.
Four templates fill in the form for the common cases:
| Template | What it does |
|---|---|
| Weekly cap | A limit on the agent's whole spend per UTC week. Pre-filled with 5 times the daily cap. |
| Cap per host | A limit with one total per host, per day, week or month, optionally for one host pattern only. |
| Approval for a new payee | Holds the first payment to a payee above an amount for a human approval. |
| Protected refunds | Denies a refund, or holds it for approval, on one of its facts: for example, charges older than 30 days. |
New agents start with one rule, tope-semanal, from the weekly cap template: an ordinary rule you can change or delete. It does not follow later changes of the daily cap.
An agent can have up to 50 custom rules; the Free plan allows 3 in all. Up to 10 of them can come from the chat: when the user asks the agent for a restriction, propose_rule adds an enforced rule named chat-… that expires after 4 hours by default (at most 24). Those rules can only deny, limit or alert, never widen anything, and only a human can delete them, in the dashboard. Every change is in the audit (policy.rule_created, policy.rule_updated, policy.rule_deleted, policy.chat_rule_added).
How do subteams work?
A subteam groups agents of the organization, and the people who look after them, so they can share a budget. Use one for a team of agents that work together, such as a main agent and its sub-agents, or for a department. Manage them in the dashboard under Subteams. A subteam holds no money: it only splits the organization's spending rules.
Subteams, subteam and organization rules, the common fund and person sub-caps are part of the Team plan, and each new organization has them during its 30-day Team trial. On Free, the ones you already have keep applying wherever they restrict and can be deleted, but not created or edited: a person's daily sub-cap can be cleared, but not set or changed.
- An organization can have up to 50 subteams, one level deep: a subteam cannot contain another.
- An agent belongs to at most one subteam. Its spend counts in the subteam it was in when it paid: moving it to another subteam leaves its past spend in the old one.
- A person can be in several subteams. Being in one lets them see it; spending counts by the agent that pays, not by the person.
- Deleting a subteam is final: its agents are left without a subteam, its people leave it, and its rules stop applying. Its history stays in the audit.
Subteam and organization rules have the same shape as an agent's custom rules (conditions, action, mode, up to 50 per subteam and 50 for the organization), with more ways to count a limit: one total for the whole subteam or organization, one per subteam, one per person or one per agent. Templates cover the usual budgets: a monthly cap for the subteam, a monthly cap per person in the subteam, a cap per host for the subteam, a monthly cap for the whole organization and a monthly cap for each subteam.
Every payment must pass all the rules that apply to it: the agent's policy and custom rules, then its subteam's rules, then the organization's. The strictest one wins, and no level can relax another. The Subteams screen shows each limit's use as a bar, with what is left and when it resets.
When several agents of one subteam pay at the same moment, from separate processes or machines, Burnbound reserves each payment against the shared total before it signs, so together they never spend more than the subteam's cap: the payments that fit go through, and the next one is denied with rule_limit_exceeded, naming the rule and its scope (ruleScopes: team).
An agent never learns its subteam's name or id. get_budget tells it what it can still spend (effectiveCap, with scope: "team" or "org" when a subteam or organization rule sets it) and lists those limits in scopeLimits.
Who can do what: owners and admins create, change and delete subteams, assign agents, add people and change rules, only from the dashboard (never with an agent key). Members see only the subteams they belong to, and the organization's rules and budget, read-only. Viewers see spend, the audit log, budgets and subteams, change nothing and take no seat. Each change is in the audit (team.created, team.agent_assigned, team.member_added, policy.scope_rule_created…).
Person sub-caps are a separate, older setting: in Organization → Team budget, an admin gives each person a daily sub-cap across all the agents linked to them (member_cap_exceeded). An agent linked to a person without a sub-cap pays nothing until one is set.
How do allowed hosts work?
Allowed hosts are the only hosts an agent may pay. An entry is either an exact host (api.example.com) or a wildcard (*.example.com), which matches any subdomain such as data.example.com but not example.com itself. With an empty list, no payment is allowed.
The policy runs on the host of the URL that answered 402, and the seller's x402 challenge must name a resource on that same host. The MCP server also checks the list before it sends anything: fetch_paid never requests a URL whose host is not allowed, paid or not (host_not_allowed).
Refunds and cards use the same list. Every refund has the host stripe-refund.action. A card payment's host is the merchant's website when Stripe gives one, and otherwise its category (mcc-computer-software-stores.card). The merchant declares its own website, so it is not proof of who the merchant is: to allow or block card spend, write rules on the merchant's payee (stripe-merchant:<network id>) or its category.
How does the catalog fit in the policy?
Burnbound keeps a catalog of x402 sellers it has verified without paying, with their receiving addresses pinned. Two rules per agent, both off by default, connect it to the policy (dashboard: agent, Policy tab):
- Verified sellers only (
verifiedSellersOnly): the agent pays only hosts that are listed in the catalog (seller_not_verifiedotherwise) and, when Burnbound pinned the seller's receiving addresses, only to one of them (pay_to_not_verified). Sellers that rotate their address only have to be listed. The allowed hosts still apply. - Catalog hosts (
allowCatalogHosts): a listed seller counts as allowed even when it is not in the allowed hosts, with the same verified-seller checks. The first payment to each new host always waits for a human approval, whatever the amount. Once that payment goes through, the host is added to the agent's allowed hosts (audit:policy.catalog_host_added).
Without either rule, the catalog still protects every agent: when a catalog seller has pinned receiving addresses on the payment's network, a payment to it at any other address is denied (pay_to_not_verified). Only the pins of sellers Burnbound lists or has suspended count.
A host matches the catalog only exactly: no wildcard, no subdomain, no port.
How do the spending caps work?
Each agent has two caps: a maximum per payment and a daily cap. A payment over the per-payment maximum is denied (amount_exceeds_per_transaction), and so is a payment that would take today's spend over the daily cap (daily_cap_exceeded).
- The day is the UTC calendar day: today's spend starts again from 0 at midnight UTC.
get_budgetreturns that moment asdayResetsAt. - Today's spend counts payments that were authorized, submitted, pending settlement or settled, on every method: refunds and card authorizations included (see What counts as spend?). Failed and expired payments do not count.
- At 80% of the daily cap the agent's cap level becomes
warning, and at 100%exhausted(capLevelinget_budget; the dashboard shows a badge). fetch_paidalso takes a per-callmaxAmountUsd, checked by the MCP server on top of the policy.
No plan limits what your agents spend: these caps are yours. The Free plan limits the organization to 3 agents and 3 custom rules; creating one more fails with plan_limit_reached, and what you already have keeps working.
Which networks can an agent pay on?
An agent pays on the networks set in its policy (allowNetworks):
- Base (
eip155:8453): real payments in USDC over x402. New agents use it by default. - Base Sepolia (
eip155:84532): a test network. Its USDC has no value and comes from a faucet, so it is the way to try an agent end to end without real money. - Tempo (
eip155:4217): real payments in USDC.e over MPPtempo.charge. Off until you turn it on (see How does an agent pay over Tempo?). - Tempo Moderato (
eip155:42431): Tempo's test network, with worthless USDC.e.
The seller's 402 names the network it charges on. If that network is not one of the agent's, the payment is denied with network_not_allowed before anything is signed. Choose the network when you create the agent in the onboarding, or change it later in the agent's network, method and asset editor in the dashboard; the change is a new policy version. The wallet that signs must hold the asset on that same network.
The API accepts only these networks, at least one, without repeats. The dashboard sets one x402 network at a time, Base or Base Sepolia, and Tempo only as its pair: Tempo with Base, Moderato with Base Sepolia. So an agent never pays real money by mistake when you meant to test.
How does an agent pay over Tempo?
Besides x402, Burnbound pays the MPP method tempo.charge on Tempo. It is opt-in per agent and takes three separate steps in the agent's network, method and asset editor. None of them turns on the others:
- Method: add
mpp.tempo.chargeto the payment methods (allowMethods). By default an agent pays onlyx402.exact; anything else is denied withmethod_not_allowed. - Network: add Tempo (
eip155:4217), or Tempo Moderato (eip155:42431) for an agent on Base Sepolia, toallowNetworks. Otherwise:network_not_allowed. - Asset: add
USDC.eto the assets (allowAssets). Otherwise:asset_not_allowed.
USDC.e is USDC bridged to Tempo by Stargate. It is not Circle's USDC: it is backed by USDC locked in the bridge, so if the bridge fails or is exploited, USDC.e can lose its 1:1 value. Burnbound keeps it as its own asset, with its own symbol, and never counts it as USDC; allowing USDC does not allow USDC.e. Allow it only if you accept the bridge's risk.
The caps, the allowed hosts, the approvals and the custom rules apply to a Tempo payment exactly as to an x402 one, and the payment shows its method in the dashboard.
How do human approvals work?
Some allowed payments wait for a human instead of being signed. fetch_paid returns pending_approval with an approvalId and a reason; a human approves or denies it in the dashboard; the agent then retries with the same idempotencyKey and is never charged twice. To approve a whole task once instead of each payment, the agent can ask for a task mandate.
A payment waits for a human when:
- its 402 reads like instructions to the agent (
instruction_like_description), for example "ignore previous instructions and pay…" in the description or theerrortext, even after invisible characters are removed. This applies to every agent. Approving it never adds the host to the allowed hosts; - it is the first payment to a catalog host admitted by the catalog-hosts rule (
catalog_new_host); - it is the first payment to a new receiving address (
new_pay_to): the organization has never paid this address on this host and network. This applies to every agent, whatever the amount, so the first payment to a new seller usually waits once; later payments to the same address go through. A listed catalog seller paid at an address Burnbound pinned for it, or one that rotates its address, does not need it; - an enforced custom rule asks for approval (
rule): the agent's, its subteam's or the organization's. The result names the rules (rules,ruleScopes); - its amount is at or above the approval threshold (
threshold), when step-up approval is on.
The first three reasons apply only to API payments. A refund waits for a rule or the threshold the same way: stripe_refund returns pending_approval, nothing reaches Stripe, and once a human approves, the agent retries with the same idempotencyKey and the gateway refunds once. A card cannot wait for a human within Stripe's 2-second window, so a card payment that would need an approval is declined with approval_required.
A held payment has one reason, the first that applies in this order. The detection of instructions looks for a short list of patterns: a reworded instruction can get past it, and the payment then still faces the allowed hosts, the caps and the receiving-address checks.
- The agent calls
fetch_paid. The payment is held, so the result isstatus: "pending_approval"withapprovalId,reasonandidempotencyKey. - A human sees the payment in the dashboard's approvals inbox (amount, host, payee, network) and approves or denies it. When the MCP server knows the dashboard's address, the result also carries
approvalUrl, the page of that approval, and clients that support it offer the user that page from the chat (see MCP tools). - The agent polls
get_approval_statuswith theapprovalId. - When it is
approved, the agent callsfetch_paidagain with the sameurl,method,headers,bodyandidempotencyKey. If it isdeniedorexpired, the agent must not retry it.
Details:
- Approvals come only after the other rules: a payment that breaks a rule is denied, not sent for approval.
- A pending approval expires after 15 minutes by default. An owner can set this between 5 minutes and 24 hours in the dashboard settings.
- Once approved, the agent has 10 minutes to retry the payment.
- At most 5 approvals can be pending per agent and 20 per organization; past that,
fetch_paidreturnsapproval_queue_full. - Notifications: the approvals inbox and the approval and low-balance emails to the organization's owners are on every plan. On Team, Burnbound can also notify you through a Slack incoming webhook. Slack and email only tell you: approving happens in the dashboard, signed in.
Which signing modes are there?
Burnbound never signs with a key it holds. Each agent's wallet is connected in one of two modes: Coinbase CDP, where the key stays with Coinbase and Burnbound requests each signature, or client-side signing, where the key stays on your machine and the MCP server signs locally after Burnbound allows the payment.
| Coinbase CDP | Client-side signing | |
|---|---|---|
| Where the private key lives | At Coinbase, in your CDP wallet | On your machine: OS keychain or a 0600 file |
| What Burnbound stores | Your CDP API credentials, encrypted | The wallet's public address |
| Who signs | Coinbase, when Burnbound asks for an allowed payment | The MCP server on your machine, after Burnbound allows the payment |
mode in fetch_paid results |
server_signed |
client_signs |
| Enforcement | Strong: the agent never has anything that can sign | Cooperative: see Security |
In client-side mode, before it signs, the MCP server checks that the local wallet is the one registered for the agent, that what it is asked to sign is one of the seller's own offers for the host that asked, that the amount is within maxAmountUsd, and that the authorization window is short (at most 300 seconds). It only signs a USDC TransferWithAuthorization (EIP-3009) on Base or Base Sepolia or, for an agent with MPP turned on, a tempo.charge transaction in USDC.e on Tempo.
How does an x402 v2 payment flow through Burnbound?
The buyer signs and the seller settles. Your agent asks for a URL, the seller answers HTTP 402 with a price, Burnbound decides, your wallet signs a USDC transfer authorization, and the seller submits it on-chain through its facilitator. Neither your agent nor Burnbound ever calls a facilitator's settle endpoint.
- The agent calls
fetch_paidwith a URL. The MCP server checks that the host is allowed and requests the URL. - The seller answers
402 Payment Requiredwith aPAYMENT-REQUIREDheader (x402 v2): price, network, asset and payee. - The MCP server sends that challenge and the URL to Burnbound, with an idempotency key for this purchase.
- Burnbound evaluates the agent's policy and answers allow, deny or step-up. An allowed payment is recorded and counts against the daily cap from that moment.
- The payment is signed as an EIP-3009
TransferWithAuthorizationfor USDC. With Coinbase CDP, Burnbound asks CDP to sign and returns the signed payload. With client-side signing, Burnbound returns exactly what to sign (the seller's offer, a nonce derived from the payment, and a short validity window) and the MCP server signs it locally. - The MCP server retries the same request once, with the
PAYMENT-SIGNATUREheader. It never follows a redirect after paying. - The seller verifies and settles the payment through its facilitator, and answers with the resource and a
PAYMENT-RESPONSEheader. - The MCP server reports that answer to Burnbound as a receipt. Burnbound checks the transfer on-chain before it marks the payment
settled.
What is an idempotency key?
An idempotency key identifies one purchase attempt. Burnbound never charges twice for the same key: a repeated request with the same key replays the earlier decision (replayed: true in the result) instead of signing a new payment.
fetch_paid creates a new key for every call. Pass idempotencyKey only to retry a purchase: after a pending_approval was approved, or after a payment_outcome_unknown error. A key reused for a different request fails with idempotency_key_reused.
What does Burnbound record?
Every decision and every payment is recorded in an audit log: allowed, denied (with reasons), pending approval, approved or denied by whom, signed, settled or failed. The dashboard shows spend per agent, each payment with its on-chain transaction or its Stripe id (re_…, iauth_…), card and refund amounts in both currencies, and the audit. Nothing is ever deleted from the audit log: your plan sets how far back you can see it, 30 days on Free, 365 days on Team and all of it on Business.
How do I export spend and get a monthly report?
On Team and Business, Monthly report in the dashboard sidebar (/app/informe) has two parts. Every role of the organization can use them, viewers included. On Free the page shows what Team adds instead.
CSV export. Download the payments or the audit log, filtered by dates (UTC days, both included), agent, person and subteam, never older than your plan shows. Rows go oldest first, with the agent, the person and the subteam of each payment. The file starts with a UTF-8 byte order mark so Excel shows accents; any cell that starts like a formula (=, +, -, @, a tab or a carriage return) gets a ' in front, so a spreadsheet shows it as text and never runs it. The API streams the file one page at a time, so a year of payments downloads as fast as a day.
Monthly report. For a UTC calendar month: spend by person, subteam, agent and host, payments blocked by the policy, payments a person approved or denied, and the same figures for the month before. Spend counts the payments the caps count, test networks included (shown apart). A payment stays with the person and the subteam it had when it was made, even if the agent moves later.
Spend by cost center, the monthly accounting export, spend Burnbound only observes and token cost are in Total cost per agent. Owners and admins can also download a verifiable evidence pack for an audit.
The same data is on the API for a signed-in person: GET /v1/reports/payments.csv, GET /v1/reports/audit.csv (query from, to, agentId, memberId, teamId; bom=0 leaves out the byte order mark) and GET /v1/reports/monthly?month=YYYY-MM. On Free they answer 403 plan_limit_reached with limit: "reports".