# API reference

Every endpoint, with a playground on each one. The requests go to the live network, so what you see is what your own code will get.

Base URL `https://peal.network`. Everything is JSON. Nothing here needs a key or an account, and every endpoint below can be run from this page. The switch below turns on [metered mode](https://peal.network/developers/x402), which sends each run through a paid twin of the same endpoint; leave it off and the API is free, which is the default it ships as.

Ids carry forward: run **Open a round** and the round id fills itself into the endpoints that need one, so you can work down the page without copying anything.

**Pay per call with x402** Off. Every endpoint on this page is free and needs no wallet.

## Rounds

3 endpoints

### Open a round

POST `/v1/rounds`

Name a moment. Nothing is encrypted yet: this only says when the round opens, and gives you the id everything else hangs off.

#### Body

`opens_in` integer

Seconds from now. Positive.

`opens_at` string | integer

Instead of opens\_in: RFC 3339 with an offset, or unix seconds. A time with no offset is refused.

`opens_at_block` object

Instead of a clock: { chain\_id, height } on a chain the network watches.

`tag` string

Your app label. Up to 32 characters of a-z 0-9 : \_ -. How you list your own rounds later.

`title` string

Public from creation, unlike anything sealed to the round. Up to 120 characters.

`description` string

Public. Up to 2000 characters.

`image_url` string

Public. https only, up to 500 characters.

#### Headers

`Idempotency-Key` string

Send one and a retry returns the same round with 200 rather than creating a second. Reusing a key with a different body is a mistake, not a retry, and answers 422 idempotency\_key\_reused.

Returns 201 with a Location header. Agents retry on timeouts, so send an Idempotency-Key: a duplicate round is a split auction.

Try it

`opens_in`  `opens_at`  `opens_at_block`  `tag`  `title`  `description`  `image_url`  `Idempotency-Key`  

Request

```
curl -X POST \
  'https://peal.network/v1/rounds' \
  -H 'content-type: application/json' \
  -d '{
    "opens_in": 3600,
    "tag": "my-app",
    "title": "Signed tour poster"
  }'
```

Response

```
{
  "id": "cond_…",
  "status": "open",
  "opens_at": "2027-01-15T18:00:00Z",
  "opens_at_unix": 1800036000,
  "seals": null,                    // null until the round opens
  "slots_including_decoys": null,
  "tag": "my-app",
  "title": "Signed tour poster"
}
```

### List rounds

GET `/v1/rounds`

Your rounds, newest first. This is the query tags exist for.

#### Query parameters

`tag` string

Only rounds with this label.

`status` string

One of open, closing, opened, stalled.

`limit` integer

1 to 200. Defaults to 25.

`cursor` string

From a previous response’s next\_cursor.

The cursor orders on (created\_at, id). Without the tie-break, rounds created in the same second get skipped or repeated as you page.

Try it

`tag`  `status`  `limit`  `cursor`  

Request

```
curl \
  'https://peal.network/v1/rounds?tag=my-app&limit=5'
```

Response

```
{
  "data": [ { "id": "cond_…", "status": "open", … } ],
  "next_cursor": "MTc4…",
  "has_more": true
}
```

### Read a round

GET `/v1/rounds/{id}`

One URL, every stage, always 200. There is no 404 standing in for "not open yet".

#### Path parameters

`id` string required

The round id.

#### Headers

`If-None-Match` string

The ETag from a previous read. An unchanged round answers 304 with no body.

Carries an ETag over the fields that actually move, so polling a deadline costs a 304 until something happens.

Try it

`id`_required_  

Request

```
curl \
  'https://peal.network/v1/rounds/{id}'
```

Response

```
{
  "id": "cond_…",
  "status": "open",          // open | closing | opened | stalled
  "seals": null,             // null until opened, then the count
  "slots_including_decoys": null,
  "opens_at": "2027-01-15T18:00:00Z",
  "opens_at_unix": 1800036000,
  "opened_at": null
}
```

## Seals

5 endpoints

### Seal a payload to a round

POST `/v1/rounds/{id}/seals`

Hand over a ciphertext. The encryption happened on your machine, with batched threshold encryption (BTE) under the committee's public parameters; this endpoint has never accepted a plaintext and never will.

#### Path parameters

`id` string required

The round to seal to.

#### Body

`ciphertext_b64` string required

The sealed payload, base64. Parsed, on curve and subgroup checked before it is stored.

The id is the hash of the ciphertext, so the same submission twice is the same seal and needs no idempotency key. 409 once the round has closed.

Try it

`id`_required_  `ciphertext_b64`_required_ 

A ciphertext cannot be typed. This encrypts a sample payload in your browser and fills the field.

 

Request

```
# The ciphertext is made on your machine; peal.js does it (Node 20+).
curl -fsSL -o peal.js https://peal.network/peal.js
CIPHERTEXT=$(node --input-type=module -e "import { peal } from './peal.js'; console.log(await peal.encrypt('my sealed payload'))")

curl -X POST \
  'https://peal.network/v1/rounds/{id}/seals' \
  -H 'content-type: application/json' \
  -d '{
    "ciphertext_b64": "'"$CIPHERTEXT"'"
  }'
```

Response

```
{
  "id": "4f858dc3…",         // sha256 of the ciphertext
  "round_id": "cond_…",
  "status": "sealed"
}
```

### List a round’s seals

GET `/v1/rounds/{id}/seals`

Withheld while the round is open (data is null, with available\_at and a note), so a live round does not announce how many sealed to it. Once it opens: every seal with its position and payload\_b64.

#### Path parameters

`id` string required

The round id.

Nothing can leak early here: before the reveal the coordinator does not hold a payload to leak.

Try it

`id`_required_  

Request

```
curl \
  'https://peal.network/v1/rounds/{id}/seals'
```

Response

```
{
  "data": [
    { "id": "4f858dc3…", "position": 3, "status": "opened",
      "payload_b64": "…" }
  ],
  "round": { "id": "cond_…", "status": "opened" }
}
```

### Seal until a time

POST `/v1/seals`

One payload, one deadline, one call. Creates a round holding just this seal and hands back a proof URL.

#### Body

`ciphertext_b64` string required

The sealed payload, base64.

`unlock_in` integer

Seconds from now.

`unlock_at` string | integer

Instead of unlock\_in: RFC 3339 with an offset, or unix seconds.

`tag` string

Your app label.

`title` string

Public from creation.

With the client, which does the encryption: peal.sealUntil(payload, unlockAt) returns { id, proof\_url }, and peal.getProof(id) reads the proof. How it works explains what the proof proves.

Try it

`ciphertext_b64`_required_  `unlock_in`  `unlock_at`  `tag`  `title` 

A ciphertext cannot be typed. This encrypts a sample payload in your browser and fills the field.

 

Request

```
# The ciphertext is made on your machine; peal.js does it (Node 20+).
curl -fsSL -o peal.js https://peal.network/peal.js
CIPHERTEXT=$(node --input-type=module -e "import { peal } from './peal.js'; console.log(await peal.encrypt('my sealed payload'))")

curl -X POST \
  'https://peal.network/v1/seals' \
  -H 'content-type: application/json' \
  -d '{
    "ciphertext_b64": "'"$CIPHERTEXT"'",
    "unlock_in": 3600,
    "tag": "my-app"
  }'
```

Response

```
{
  "id": "4f858dc3…",
  "round_id": "cond_…",
  "unlock_at": "2027-01-15T18:00:00Z",
  "proof_url": "/v1/seals/4f858dc3…/proof"
}
```

### Read a seal

GET `/v1/seals/{id}`

One seal, with its payload once the round has opened.

#### Path parameters

`id` string required

The seal id, which is the sha256 of its ciphertext.

Try it

`id`_required_  

Request

```
curl \
  'https://peal.network/v1/seals/{id}'
```

Response

```
{
  "id": "4f858dc3…",
  "round_id": "cond_…",
  "position": 3,
  "status": "sealed",
  "round": { "id": "cond_…", "status": "open" }
}
```

### Read a seal’s proof

GET `/v1/seals/{id}/proof`

What can actually be checked, and nothing that cannot.

#### Path parameters

`id` string required

The seal id.

The load-bearing field is ordering\_committed\_at. The batch ordering is written at freeze, before any operator is handed work, so a commitment earlier than the reveal is evidence the set was fixed before anybody could read it. Null rather than false before the round opens.

Try it

`id`_required_  

Request

```
curl \
  'https://peal.network/v1/seals/{id}/proof'
```

Response

```
{
  "seal_id": "4f858dc3…",
  "position": 3,
  "ordering_root": "0x…",
  "ordering_committed_at": 1788490917,
  "merkle_root": "0x…",
  "revealed_at": 1788494517,
  "commitment_precedes_reveal": true
}
```

## Auctions

4 endpoints

### Open an auction

POST `/v1/auctions`

A round with the rules that decide what a bid means. Every bid is sealed with batched threshold encryption and opens only when the round fires. Rules that cannot be satisfied are refused here rather than at the close.

#### Body

`closes_in` integer

Seconds from now.

`closes_at` string | integer

Instead of closes\_in: RFC 3339 with an offset, or unix seconds.

`currency` string

A code from /v1/currencies. Its decimals come with it.

`decimals` integer

0 to 4. Only needed for a code the table does not know.

`reserve_minor` integer

Integer MINOR units. Nothing below this can win.

`maximum_minor` integer

Integer minor units. Nothing above this can win. Set one: it is what stops a joke bid taking the auction.

`title` string

Public from creation.

`description` string

Public. Up to 2000 characters.

`image_url` string

Public. https only.

`contact_public_key` string

The seller’s PUBLIC key, when bidders may attach contact details. Never send the private half.

`tag` string

Your app label.

bid\_url is a hosted page where somebody can read the terms and bid, so an auction works before you have built an interface. check\_code is eight speakable characters a seller reads out and a bidder compares.

Try it

`closes_in`  `closes_at`  `currency`  `decimals`  `reserve_minor`  `maximum_minor`  `title`  `description`  `image_url`  `contact_public_key`  `tag`  

Request

```
curl -X POST \
  'https://peal.network/v1/auctions' \
  -H 'content-type: application/json' \
  -d '{
    "closes_in": 3600,
    "currency": "USD",
    "reserve_minor": 1000,
    "maximum_minor": 50000,
    "title": "Signed tour poster",
    "tag": "my-shop"
  }'
```

Response

```
{
  "id": "cond_…",
  "status": "open",
  "closes_at": "2027-01-15T18:00:00Z",
  "currency": "USD",
  "decimals": 2,
  "reserve_minor": 1000,
  "maximum_minor": 50000,
  "bid_url": "https://peal.network/#/live/…",
  "check_code": "1C8J T47V",
  "terms_hash": "0x…"
}
```

### Read an auction

GET `/v1/auctions/{id}`

The rules as stored, the bid count, and the links.

#### Path parameters

`id` string required

The auction id.

Try it

`id`_required_  

Request

```
curl \
  'https://peal.network/v1/auctions/{id}'
```

Response

```
{
  "id": "cond_…",
  "status": "open",
  "bids": null,              // null until the auction opens, then the count
  "closes_at": "2027-01-15T18:00:00Z",
  "currency": "USD",
  "reserve_minor": 1000,
  "results_url": "/v1/auctions/cond_…/results"
}
```

### Place a bid

POST `/v1/auctions/{id}/bids`

A bid is a seal holding the fixed width bid record. Same validation and the same closed check as any other seal.

#### Path parameters

`id` string required

The auction id.

#### Body

`ciphertext_b64` string required

The encrypted bid record: 320 bytes before encryption, whatever the amount inside it.

Every bid is the same size on the wire. Without that the ciphertext length ranks the auction for anyone watching, before a single bid opens.

Try it

`id`_required_  `ciphertext_b64`_required_ 

A ciphertext cannot be typed. This encrypts a sample payload in your browser and fills the field.

 

Request

```
# The ciphertext is made on your machine; peal.js does it (Node 20+).
curl -fsSL -o peal.js https://peal.network/peal.js
CIPHERTEXT=$(node --input-type=module -e "import { peal } from './peal.js'; console.log(await peal.encryptBid('{id}', { amountMinor: 12500, name: 'ana' }))")

curl -X POST \
  'https://peal.network/v1/auctions/{id}/bids' \
  -H 'content-type: application/json' \
  -d '{
    "ciphertext_b64": "'"$CIPHERTEXT"'"
  }'
```

Response

```
{
  "id": "4f858dc3…",
  "round_id": "cond_…",
  "status": "sealed"
}
```

### Read the board

GET `/v1/auctions/{id}/results`

Every readable bid ranked, the queue the rules allow to win, the winner, and anything discarded with the reason.

#### Path parameters

`id` string required

The auction id.

Before the close, bids is null rather than an empty list, so "not open yet" cannot be read as "nobody bid".

Try it

`id`_required_  

Request

```
curl \
  'https://peal.network/v1/auctions/{id}/results'
```

Response

```
{
  "status": "opened",
  "bids":   [ { "name": "ana", "amount_minor": 12500,
                "meets_reserve": true, "within_maximum": true } ],
  "queue":  [ … ],           // only those the rules allow to win
  "winner": { "name": "ana", "amount_minor": 12500 },
  "decoys": 60,
  "discarded": []
}
```

## Reference

5 endpoints

### Service description

GET `/v1`

What this deployment accepts. Read it rather than hard-coding limits from prose.

Try it

No parameters. Press run.

Request

```
curl \
  'https://peal.network/v1'
```

Response

```
{
  "service": "peal",
  "version": "v1",
  "limits": {
    "max_payload_bytes": 5242880,
    "max_page_size": 200,
    "requests_per_second": 20,
    "burst": 100
  },
  "rate_limits": {
    "read":   { "per_second": 20, "burst": 100 },
    "create": { "per_second": 1,  "burst": 10 },
    "create_per_day": 1000,
    "upload": { "per_second": 10, "burst": 50 },
    "upload_bytes_per_minute": 50000000,
    "page":   { "per_second": 30, "burst": 60 },
    "paid_multiplier": 5
  }
}
```

### Your rate limits

GET `/v1/limits`

Your standing in every budget, and the client address you are counted as. Spends one read.

Budgets are per client IP, IPv6 grouped by /64. A refused request answers 429 with Retry-After and a rate\_limited problem naming the budget that ran out.

Try it

No parameters. Press run.

Request

```
curl \
  'https://peal.network/v1/limits'
```

Response

```
{
  "client": "203.0.113.7",
  "budgets": {
    "read":   { "per_second": 20, "burst": 100, "remaining": 99 },
    "create": { "per_second": 1,  "burst": 10,  "remaining": 10 },
    "upload": { "per_second": 10, "burst": 50,  "remaining": 50 },
    "page":   { "per_second": 30, "burst": 60,  "remaining": 60 }
  },
  "creates_per_day": { "limit": 1000, "used": 0 },
  "upload_bytes_per_minute": 50000000
}
```

### Public parameters

GET `/v1/parameters`

The key material you encrypt against, with the digest a client checks before using it.

The client verifies the digest against the bytes it was served, so a coordinator handing out inconsistent parameters fails loudly rather than producing ciphertexts nobody can open.

Try it

No parameters. Press run.

Request

```
curl \
  'https://peal.network/v1/parameters'
```

Response

```
{
  "id": "ed707ad8…",
  "digest": "ed707ad8…",
  "parameters_b64": "…",
  "operators": 5,
  "threshold": 3,
  "batch_size": 64
}
```

### Currencies

GET `/v1/currencies`

The 56 currencies the API knows, with the decimals each uses. Searchable by code, name or symbol.

#### Query parameters

`q` string

Search by code, name or symbol. "rupee", "INR" and "₹" all find the same one.

`limit` integer

1 to 200. Defaults to 200.

Pass a known code when you create an auction and the decimals come with it. The yen has none and the Kuwaiti dinar has three.

Try it

`q`  `limit`  

Request

```
curl \
  'https://peal.network/v1/currencies?q=rupee&limit=5'
```

Response

```
{
  "data": [
    { "code": "INR", "name": "Indian rupee", "decimals": 2, "symbol": "₹" }
  ],
  "total": 56
}
```

### Check a short link

GET `/v1/names/{name}`

Whether a name is free, and where it points if it is not.

#### Path parameters

`name` string required

3 to 32 characters of a-z 0-9 and hyphens, not starting or ending with one.

Checking only. Claiming is a permanent onchain write that can never be undone or repointed, so it happens from your own key rather than from a server acting on your behalf.

Try it

`name`_required_  

Request

```
curl \
  'https://peal.network/v1/names/shoonya'
```

Response

```
{
  "name": "shoonya",
  "valid": true,
  "available": false,
  "url": "https://peal.network/shoonya",
  "permanent": true
}
```

## Private Links

7 endpoints

The public half of the Peal Private Links node: the ledger every proof is about, and the reads a payer or a wallet makes. None of these need a session. The writes carry a zero-knowledge proof or an account signature; today the hosted app makes them, and a published client for them is coming. [Private Links API](https://peal.network/developers/links-api) has every route; [Peal Private Links](https://peal.network/developers/links) is the picture.

### Read the node

GET `/links/v1/status`

Everything a client needs to configure itself: the namespaces (an asset on a chain, with token, decimals, gateway and confirmations), the circuit id the proving keys must match, and the settlement signers.

Running this fills the namespace id into the endpoints below. The signer mode on the hosted node is a single-process fixture: two of three keys in one process, which is the trust model stated on every Private Links page.

Try it

No parameters. Press run.

Request

```
curl \
  'https://peal.network/links/v1/status'
```

Response

```
{
  "ok": true,
  "circuit_id": "d308e51f…",
  "ledger_mode": "single-node",
  "signers": ["0x1d9c…", "0x238f…", "0xd140…"],
  "signer_threshold": 2,
  "namespaces": [{
    "id": "79c4f2a9…",
    "label": "sepolia/USDC",
    "chain_id": 11155111,
    "token_address": "0x1c7d…7238",
    "decimals": 6,
    "gateway": "0xc141…c1fc",
    "confirmations": 2,
    "available": true
  }],
  "ledgers": [{ "namespace": "79c4f2a9…", "seq": 0, "receipt_count": 0, "state_root": "…", "receipt_root": "…" }]
}
```

### Read a ledger

GET `/links/v1/ledger/{ns}`

One namespace: its sequence number, how many receipts the log holds, and the current state and receipt roots. This is all the ledger publishes about balances: nothing.

#### Path parameters

`ns` hex required

The namespace id: 64 lowercase hex characters, SHA-256 of the namespace label under a domain tag.

Try it

`ns`_required_  

Request

```
curl \
  'https://peal.network/links/v1/ledger/79c4f2a9ebab783dc37773ff576cb5f7ce720b1bbf4507e4239decf7bac88d37'
```

Response

```
{
  "namespace": "79c4f2a9…",
  "seq": 18,
  "receipt_count": 14,
  "state_root": "5725b1ff…",
  "receipt_root": "3d4745e5…",
  "recent_roots": ["…"],
  "minted_total": "3000000"
}
```

### Read the records

GET `/links/v1/ledger/{ns}/history`

The operations in order. Look at what an op record carries: an account, an old and a new commitment, one receipt, a root and a 128-byte proof. No amount, no counterparty, and no way to tell a send from a receive.

#### Path parameters

`ns` hex required

The namespace id.

#### Query parameters

`from` integer

First sequence number to return. Defaults to 1.

`limit` integer

How many. Defaults to 100.

A mint is a deposit credited by the chain watcher; its amount is public because the deposit was. Everything after it is an op.

Try it

`ns`_required_  `from`  `limit`  

Request

```
curl \
  'https://peal.network/links/v1/ledger/79c4f2a9ebab783dc37773ff576cb5f7ce720b1bbf4507e4239decf7bac88d37/history?from=1&limit=5'
```

Response

```
{
  "ops": [
    { "seq": 1, "kind": "register", "position": null, "envelope": { "namespace": "…", "pubkey": "…", "randomness": "…", "signature": "…" } },
    { "seq": 3, "kind": "mint", "position": 0, "envelope": { "deposit_id": "11155111:0x…", "intent": { "amount": 1000000, "receipt": "…", "proof": "…" } } },
    { "seq": 4, "kind": "op", "position": 1, "envelope": { "account": "…", "com": "…", "com_new": "…", "receipt": "…", "root": "…", "proof": "…", "pubkey": "…", "signature": "…" } }
  ]
}
```

### Read the books

GET `/links/v1/ledger/{ns}/accounting`

What the gateway must hold for this namespace, as public numbers: everything minted, everything withdrawn, and the difference, which is the outstanding liability.

#### Path parameters

`ns` hex required

The namespace id.

Amounts are strings of integer base units. 3000000 is 3.00 USDC.

Try it

`ns`_required_  

Request

```
curl \
  'https://peal.network/links/v1/ledger/79c4f2a9ebab783dc37773ff576cb5f7ce720b1bbf4507e4239decf7bac88d37/accounting'
```

Response

```
{
  "namespace": "79c4f2a9…",
  "minted_total": "3000000",
  "withdrawn_total": "1000000",
  "outstanding_liability": "2000000",
  "receipt_count": 14
}
```

### Read an account

GET `/links/v1/ledger/{ns}/accounts/{acct}`

What the ledger knows about one account: a 32-byte commitment and the sequence number that last changed it. The balance is inside the commitment and only the owner can open it.

#### Path parameters

`ns` hex required

The namespace id.

`acct` hex required

An account id, 64 hex characters. Take one from an op record in the history above.

Try it

`ns`_required_  `acct`_required_  

Request

```
curl \
  'https://peal.network/links/v1/ledger/79c4f2a9ebab783dc37773ff576cb5f7ce720b1bbf4507e4239decf7bac88d37/accounts/{acct}'
```

Response

```
{
  "account": "a5d085a2…",
  "com": "b6f780ec…",
  "updated_seq": 4
}
```

### Read the proving keys index

GET `/links/v1/params`

The circuit id and the four key files a prover downloads by digest: the operation proving and verifying keys, and the deposit pair. A client refuses to prove if the circuit id here does not match its keys.

"setup": "local-dev" is honest: the keys come from a per-process setup, not a ceremony. GET /links/v1/params/{name} serves the bytes with an immutable cache header and the digest as the ETag.

Try it

No parameters. Press run.

Request

```
curl \
  'https://peal.network/links/v1/params'
```

Response

```
{
  "circuit_id": "d308e51f…",
  "setup": "local-dev",
  "files": {
    "op.pk": { "digest": "…", "size": 15000000 },
    "op.vk": { "digest": "…", "size": 716 },
    "deposit.pk": { "digest": "…", "size": 940348 },
    "deposit.vk": { "digest": "…", "size": 716 }
  }
}
```

### Read a payment request

GET `/links/v1/requests/{id}`

What a payer reads when they open a pay link: the signed manifest (amount, title, receiver account and key, receiver wallet), its status, and whether another payer currently holds it.

#### Path parameters

`id` string required

The request id: the last segment of a pay link, 24 characters of a-z and 2-7. Create one in the app and paste it here.

#### Query parameters

`intent` string

Your own payer intent id, so your own reservation reports as free.

The hosted app verifies the manifest signature against the receiver account, and the receiver profile against the wallet address, before paying. It does not take this response on trust, and neither should your client.

Try it

`id`_required_  `intent`  

Request

```
curl \
  'https://peal.network/links/v1/requests/{id}'
```

Response

```
{
  "manifest": {
    "version": 2,
    "request_id": "…",
    "namespace": "79c4f2a9…",
    "receiver_account": "…",
    "receiver_enc_key": "…",
    "amount": "12500000",
    "title": "Logo files",
    "display_name": "Bob",
    "receiver_address": "0x…",
    "reference": "INV-7",
    "expires_at": null,
    "created_at": 1789408800,
    "signer_pubkey": "…",
    "signature": "…"
  },
  "status": "active",
  "fulfilled_at": null,
  "reserved": false
}
```

## Errors

Every failure is [RFC 9457](https://www.rfc-editor.org/rfc/rfc9457) problem+json with a stable `code` to branch on and a `field` when one input is at fault. `detail` is for people and its wording is not part of the contract.

```
{
  "type":   "https://peal.network/#/developers#invalid_maximum",
  "title":  "invalid request",
  "status": 400,
  "code":   "invalid_maximum",
  "detail": "the maximum cannot be below the reserve",
  "field":  "maximum_minor"
}
```

## Rate limits

Each client IP (IPv6 by /64) has separate budgets, so polling never uses up the budget for writing, and a large upload costs what it weighs.

budget

what counts

limit per client

read

every `GET`

20 a second, bursting to 100

create

`POST /v1/rounds`, `POST /v1/auctions`

60 a minute, bursting to 10, and 1,000 a day

upload

seals and bids

10 a second, bursting to 50, and 50 MB a minute

page

short links and pages

30 a second, bursting to 60

Calls to the paid twin at `/v1/x402` get five times every budget. Every response carries `RateLimit-Limit`, `RateLimit-Remaining`, `RateLimit-Reset` and `RateLimit-Policy` (which budget it spent), so you never have to be refused to learn your budget. A refusal is a 429 with `Retry-After` and a `rate_limited` problem whose `budget` field names what ran out. `GET /v1/limits` shows your standing in every budget, and `GET /v1` lists them all under `rate_limits`.

---
Source: https://peal.network/developers/api
