Docs

API

Everything the panel shows comes from one HTTP API over the chain. Read your budgets and payments from your own tools, or follow them live.

Base URL

https://api.breaker.to

JSON in, JSON out. Reads need no key: they return what is already public on chain, arranged by panel and budget. Amounts are strings of base units, addresses are base58, and times are ISO 8601 in UTC. Every read carries asOf, the time its figures were true.

Config

GET /v1/config

What the deployment is running, read from the chain.

FieldWhat it is
statusready once the program and its Config are on chain.
cluster, x402NetworkThe Solana cluster, and its network id as x402 names it.
programIdThe Breaker program’s address.
feeBpsThe funding fee, as the program’s Config holds it.
mints, defaultMintThe mints a budget can be opened in, each with its symbol, decimals and token program.
periods, defaultPeriodThe periods on offer, each with its length in seconds.
sdkThe SDK’s package name and the API URL it reports to.

Reads

RequestReturns
GET /v1/wallets/:ownerA wallet’s SOL, its balance in each mint, and its panel’s address if it has one.
GET /v1/panels/by-owner/:ownerThe wallet’s panel: every budget, the totals, the members and, for a vault-owned panel, its multisig.
GET /v1/keys/:key/panelsEvery panel a wallet can act on: panel, owner, as (owner, vault for a key of the owning multisig, or member), roles and vault.
GET /v1/panels/:panelThe same, by the panel’s address.
GET /v1/panels/:panel/activityPayments and sessions across the panel, with totals by service and by budget.
GET /v1/budgets/:budgetOne budget with its latest payments, its sessions, its services, its past periods and its SDK snippet.
GET /v1/budgets/:budget/paymentsThe budget’s payments, newest first.
GET /v1/budgets/:budget/servicesWhat the budget has paid each service.
GET /v1/budgets/:budget/periodsThe budget’s closed periods, each with its spend.

A budget

{
  "address":         "<the budget>",
  "panel":           "<its panel>",
  "owner":           "<the owner's wallet>",
  "tokenAccount":    "<the account that holds the money>",
  "label":           "research",
  "agentKey":        "<the key now approved>",
  "mint":            "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
  "limit":           "50000000",
  "period":          { "id": "day", "label": "Day", "seconds": 86400 },
  "periodStart":     "2026-11-15T14:20:00.000Z",
  "periodEnd":       "2026-11-16T14:20:00.000Z",
  "spentThisPeriod": "2015000",
  "lifetimeSpent":   "310420000",
  "remaining":       "47985000",
  "balance":         "189580000",
  "funded":          "500000000",
  "expiry":          null,
  "state":           "live",
  "on":              true,
  "draws":           false,
  "channels":        { "open": 1, "held": "7000000" },
  "lines":           [],
  "asOf":            "2026-11-15T18:02:11.000Z"
}

state is one of live, tripped, off, expired and closed, as on the Budgets page. funded is everything that has reached the budget, after fees. draws says whether it fills from the reserve. channels counts the payment channels it has open, and held is what their deposits still hold: counted in spentThisPeriod already, and partly coming back if the service is not paid all of it.

Lines

lines is empty on a budget that is not on lines. On one that is, the key holds no allowance, so remaining is the limit less this period’s spend since the last reset while the budget is on and not expired, and state follows from it, as in the SDK’s status(). Each entry in lines is a service it pays:

FieldWhat it is
recipientThe service’s payout address, its payTo.
capThe most it may take in one period.
spentThisPeriodWhat it has taken this period.
originThe service’s origin, where a payment in the ledger shows it; null otherwise.

A payment

{
  "id":          "<signature>:<position in the transaction>",
  "signature":   "<the transaction>",
  "budget":      "<the budget>",
  "agentKey":    "<the key that signed>",
  "mint":        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
  "amount":      "5000",
  "destination": "<the service's token account>",
  "payTo":       "<the service's wallet>",
  "feePayer":    "<the facilitator>",
  "slot":        "381204551",
  "blockTime":   "2026-11-15T18:01:58.000Z",
  "periodStart": "2026-11-15T14:20:00.000Z",
  "origin":      "https://api.example.com",
  "service":     "api.example.com"
}

origin comes from the SDK’s report. A payment made without one has origin: null and is named by its payTo.

A session

A payment channel the budget opened to one service, as on the Budgets page. A budget’s read carries its 24 newest in sessions, and the panel’s activity carries the panel’s.

FieldWhat it is
channel, budget, mintThe channel, the budget that pays into it, and the mint.
kindsession when the agent key signs the vouchers (batch-settlement), metered when the service does (upto).
payTo, serviceThe service’s wallet the channel pays out to, and its name.
depositEverything put into the channel.
settledWhat the service has been paid from it so far.
returnedWhat came back to the budget account when it closed.
stateopen, closing once a close was asked for, or closed.
periodStartThe period its deposit counts against.
openedAt, updatedAt, closedAtWhen it opened, last changed and closed; closedAt is null while it is open.
openSignatureThe transaction that opened it.

Paging and filters

QueryOnWhat it does
limitEvery list1 to 100 items a page. 24 without it.
cursorEvery listThe cursor a page returned, for the next page.
servicePayments, activityOnly payments to one service.
periodStartPayments, activityOnly payments of the period that started then.
from, toPayments, activityOnly payments between two times.
budgetActivityOnly one budget’s payments.
const res = await fetch('https://api.breaker.to/v1/budgets/' + budget + '/payments?limit=50')
const { items } = await res.json()
const spent = items.reduce((n, p) => n + BigInt(p.amount), 0n)

Live events

GET /v1/panels/:panel/events

A server-sent event stream of one panel. It is what moves the meters and the ledger in the app as payments land.

EventSent whenCarries
readyThe stream opens.The panel’s address.
paymentA budget pays.The payment, and the budget as it stands after it.
budgetA budget changes.The budget and the action: an owner’s instruction, roll, or trip.
sessionA channel of a budget opens, is topped up, pays out, is asked to close or closes.The session, the budget after it, and the action: open, top_up, distribute, request_close or close.
memberA member is added, given new roles or removed.The member’s key, the member after it (null once removed) and the action: add_member, set_roles or remove_member.
reserveThe reserve changes.The reserve’s new balance, the action (fund_reserve, withdraw_reserve or draw) and, on a draw, the budget.
resyncThe stream reconnected or fell behind.Read the panel again; then go on listening.
const events = new EventSource('https://api.breaker.to/v1/panels/' + panel + '/events')

events.addEventListener('payment', (e) => {
  const { payment, budget } = JSON.parse(e.data)
  console.log(budget.label, 'paid', payment.amount, 'to', payment.service)
})
events.addEventListener('budget', (e) => {
  const { budget, action } = JSON.parse(e.data)
  if (action === 'trip') notify(budget.label + ' tripped')
})

Owner transactions

The app never holds a key. For each control it asks the API to build the transaction, shows you the review, and hands it to your wallet to sign. The same routes are open to your own tooling.

RequestBodyBuilds
POST /v1/panels/buildowneropen_panel
POST /v1/budgets/buildowner, label, agentKey, mint, limit, period, expiry, funding, drawopen_budget, with open_panel first if the wallet has none; with draw, also draw_on and draw, and funding may be 0
POST /v1/budgets/:budget/change/buildowner, limit, period, expiryset_limit
POST /v1/budgets/:budget/fund/buildowner, amountfund
POST /v1/budgets/:budget/withdraw/buildowner, amountwithdraw
POST /v1/budgets/:budget/reset/buildownerreset
POST /v1/budgets/:budget/switch-off/buildownerswitch_off, with request_channel_close for each open channel
POST /v1/budgets/:budget/switch-on/buildownerswitch_on
POST /v1/budgets/:budget/rotate-key/buildowner, agentKeyrotate_key
POST /v1/budgets/:budget/close/buildownerclose_budget, with the budget’s Channels address and a remove_line for each line first; refused with CHANNELS_OPEN while a channel is open
POST /v1/panels/:panel/switch-all-off/buildownerOne switch_off for every budget that is on, each with its channels’ request_channel_close
POST /v1/panels/:panel/reserve/fund/buildowner, mint, amountfund_reserve
POST /v1/panels/:panel/reserve/withdraw/buildowner, mint, amountwithdraw_reserve
POST /v1/budgets/:budget/draw/buildowner, drawdraw_on or draw_off
POST /v1/budgets/:budget/lines/buildowner, recipient, capset_line; the first line is refused with CHANNELS_OPEN while a channel is open
POST /v1/budgets/:budget/lines/remove/buildowner, recipientremove_line; LINE_NOT_FOUND for a service with no line

Every body takes an optional signer beside owner: the wallet that signs when it is not the owner, a member with the action’s role or a key of the owning multisig. The API refuses a signer the action’s role does not allow, as the program would. Each returns { build, review }. build.transactionBase64 is the unsigned transaction. review states what it does in figures: the funding, the fee, what reaches the budget or the reserve, what is drawn, the limit, the period, and a sentence on what the agent key will be able to do.

Team

RequestBodyBuilds
POST /v1/panels/:panel/members/buildowner, key, rolesadd_member; roles is ["switch"], ["limits"] or both
POST /v1/panels/:panel/members/:key/roles/buildowner, rolesset_roles
POST /v1/panels/:panel/members/:key/remove/buildownerremove_member
POST /v1/vaults/:multisig/proposals/:index/approve/buildsignerA Squads approval of the proposal, by a key of the multisig
POST /v1/vaults/:multisig/proposals/:index/execute/buildsignerThe Squads execution of an approved proposal

On a panel owned by a Squads vault, every owner build, signed by a key of the multisig, returns a transaction that creates the vault transaction and its proposal and approves it with that key; its review.proposal names the multisig, the proposal’s index, the action, the threshold and the approvals so far. A panel’s vault lists the multisig, its vault, threshold, keys and proposals, each with its state: active, approved, executed, rejected or cancelled. The panel’s members lists each member’s key, roles and addedAt.

Submit and follow

// 1. build
const { build, review } = await post('/v1/budgets/' + budget + '/fund/build', { owner, amount: '25000000' })

// 2. sign with the owner's wallet
const signed = await wallet.signTransaction(decode(build.transactionBase64))

// 3. submit, then follow
const { id } = await post('/v1/transactions/submit', {
  mode: 'relay',
  buildId: build.id,
  signedTransactionBase64: encode(signed),
  idempotencyKey: crypto.randomUUID(),
})
const status = await get('/v1/transactions/' + id) // submitted, confirmed, finalized, failed or expired

A transaction reads confirmed once the indexer has applied it, so the next read of the budget already shows its effect.

Agent reports

The two routes the SDK posts to. Each body is signed by the agent key, and the API accepts it only from the key that signed the payment or the budget’s current agent key.

RequestHolds
POST /v1/reports/originThe budget, the payment’s signature, and the origin it was for.
POST /v1/reports/refusedThe budget, the price that was above what remained, and the origin.

Errors

A failed request answers with its HTTP status and a body of { error: { code, message, retryable } }. When a program refused a transaction, error.programError names the program and the error.

Every code, with its status and what it means, is on the Errors page.

What runs behind it

PartWhat it does
The indexerFollows the program’s events and every budget account’s outgoing transfers, and writes the panels, budgets, periods and payments the reads return.
The keeperSends roll for each budget at the earlier of its period end and its expiry, timed by the chain’s clock, and pays that transaction’s network fee. For a budget that is off or expired it asks each open channel to close, and seals and distributes it once its grace has passed.
The facilitatorBreaker’s x402 facilitator at https://facilitator.breaker.to: settles exact, upto and batch-settlement payments, a budget’s channel opens among them, as the x402 page says.
The APIServes the reads and the stream, builds owner transactions, relays them once signed, and checks the SDK’s reports.

None of them holds a key that can move a budget’s money. The chain is the record; the API is a faster way to read it.