Application APIs

What these are

The chain's interface is JSON-RPC. Everything on these pages is something an application built for itself and then left reachable: a Postgres index over the sequencer's log spool, a process holding a key, a game loop. They are convenient, they are first-party, and they are not authoritative.

Where they answer

Not one of these services has a hostname of its own. Each is an /api/ mount on a front end's origin, which makes the public base an nginx fact rather than a service fact: a deployment that moves a site moves its API with it, and the path inside stays the same. On a stack you run yourself, the same services answer on loopback instead, on the port each service's own page names.

Authentication

Not one of the four takes a credential, and the difference that matters is what each of them can do without one.

• The explorer, the DEX API and the arcade take none. They are read-only and public. The explorer answers 405 to every POST; the DEX API implements no verb but GET.
• The faucet takes none either, and it writes to the chain. That is the whole reason its quota is strict and is reserved before anything is signed.

Calling one from a browser

CORS is set per service and they do not agree, so the first thing to establish is whether a page on your origin can call the one you want at all.

• The DEX API sends no CORS header and has no OPTIONS handler. A cross-origin fetch from a browser fails outright while the same request from a server succeeds, which is the shape of bug that gets blamed on the network. Proxy it, or call it from a backend.
• The explorer and the faucet keep allowlists. A preflight from an origin that is not on the list is refused 403, which is at least a clear answer.
• The arcade checks the Origin on the upgrade and refuses 403 before the handshake, so the socket never opens rather than opening and going quiet.

Limits and paging

Only the explorer limits request rate. The other three rely on a clamp, a quota or a connection ceiling instead.

Where paging exists it is limit and offset, not a cursor. That means a list that is growing at the head shifts under you between two pages: rows you have already seen reappear, and rows you have not can be skipped. For anything that has to be complete, page by a key you control - a block number, a hash - rather than by offset.

Conventions

// The shape of a careful call against any of these: a timeout, a status check
// before the body, and a big-integer parse of anything that looks like money.
const res = await fetch(`${BASE}/pools`, { signal: AbortSignal.timeout(5000) });
if (!res.ok) throw new Error(`pools: ${res.status}`);          // never the message
const { pools } = await res.json();                              // an object, not an array
const reserve0 = BigInt(pools[0].reserve0);                      // a decimal string

When one is down

Each of the four fails differently, and only one of those failures looks like a failure from the outside.

• The DEX API answers 503 index not ready when the database is unreachable or the indexer has never run, so the tables do not exist. That is the honest case. The dishonest one is an indexer that has STOPPED: every route keeps answering with the state it reached, and only lagBlocks on /health says so.
• The explorer keeps serving the index when the node is unreachable, and the parts of an answer that need a live read - a balance, a name-service record, the fee router's pending balance - come back null or absent rather than erroring. TheindexLag field on /stats is the figure to watch.
• The faucet answers 502 when the node does not respond, and nothing has been signed. A 503 means it is out of funds, or the drip reverted.
• The arcade's /ready answers 503 when its socket to the node is down, or when the last mini-block it APPLIED is more than five seconds old. Measuring arrival instead let a wedged process answer 200 with nothing moving.

What is documented elsewhere

• The node. Chain state, transactions, logs and subscriptions are JSON-RPC and are documented in this reference's own RPC pages, not here.
• Contracts. What the pools, the faucet and the games actually do on chain - their functions, their events and their revert reasons - is the contract reference.
• Prices. Several answers here carry a dollar figure or a price snapshot. Those fields come from a layer this page does not own; read its own reference for what the number means, how old it is and when it is absent.