JSONPad

Activity counts for a list, item, index or identity over the last days. List stats include how many writes the list's rules refused. 1 request.

What this server's API token may do (its permission rules, without the token value), the plan's limits, and the account's usage this month (requestCount, requestsRemaining, credits, storageBytes, storageAllowance, degraded). Also checks the token works. Call it first when anything fails with an authentication or permission error, and before a large batch of writes. 1 request.

A page of the history of a list, item, index or identity: what happened, when, and at which version, without snapshots (get_event has them). For an item, restorable: true lists only the events restore_item can go back to, including the item-deleted event of a deleted item; this is how to find restore points. 1 request.

A page of the account's identities: the end users of the user's apps, who log in with a name (or email) and password. Email addresses aren't returned to API tokens. 1 request.

A page of a list's indexes, each with its buildStatus and a usage hint. Filter by pathName to find one index. get_list includes every index too. 1 request.

A page of a list's items. Data is left out unless includeData (or path) is set. filters use the list's filtering indexes (get_list shows them), by pathName: string indexes match partially, number indexes take lt:, lte:, gt:, gte: (e.g. "gte:10"), date indexes take before: and after: (e.g. "before:2026-01-01"). order takes createdAt, updatedAt, alias, readonly, activated, or a sorting index's pathName. An index that is still building fails with INDEX_BUILDING. 1 request, plus 1 the first time a list's data is read in a session, to find its guard indexes (unless get_list was called).

A page of the account's lists that this token can see, with their flags, tags and item counts. Schemas and write rules are left out: get_list has them. 1 request.

The last 50 writes the list's write rules refused, newest first: when, which operation, which identity and token, the stage (allow: no rule authorised it, 403; require: a check failed, 400), and the statement and line that refused it. A refusal can take a moment to appear. Replay one with test_list_rules to see why. The token needs update on the list. 1 request.

Deep-merge a value into an item's data, or into the value at pointer: fields you don't mention are left alone, so this is the safe way to change some fields, including on lists with guard indexes. Arrays are concatenated, not replaced (use patch_item_data or replace_item_data at the array's pointer to replace one). Pass the etag you read as ifMatch. 1 request.

Move lists to another schema sync scope, assign unmanaged lists to one, or release them (scope: null), with the indexes the scope manages. Choose lists by id or pathName, or every list of fromScope (e.g. to rename a scope). All or nothing. dryRun defaults to true: show the user the plan, then call again with dryRun: false. Needs the sync-schema permission. 1 request.

Apply JSON Patch (RFC 6902) operations to an item's data, or to the value at pointer (operation paths are then relative to it). Best for surgical edits: replacing an array element, removing a field, appending with path "/list/-". All operations apply, or none. Operations that write over a guarded value (or one of its parents) are refused unless overwriteGuarded is set, and the API refuses test, copy and move from guarded values. Pass the etag you read as ifMatch. 1 request.

What applying a schema sync document would do, without changing anything: each list, index and flow it would create, update, adopt, delete or leave alone, field by field, with warnings and errors, and blockedBy if it would be refused. Always call this before apply_schema_sync, and show the user the plan. The document is checked against the sync document schema locally first, at no cost. Needs the sync-schema permission. 1 request.

Start a new build of an index whose last build failed, once the cause is fixed (failed builds are never retried by themselves). An index that isn't failed is refused with INDEX_BUILD_NOT_FAILED. With wait: true this polls until it's built, 1 request per poll. 1 request, plus the polls.

Replace an item's whole data, or the value at pointer. On a list with guard indexes, a replace that covers a guarded value would delete it (this token can't see it), so it's refused unless overwriteGuarded is set: use merge_item_data, patch_item_data or a narrower pointer instead. Pass the etag you read as ifMatch. 1 request (plus 1 to find the list's guard indexes, the first time).

Put an item back as it was at an event (item-created, item-updated, item-restored or item-deleted; find them with list_events and restorable: true), as a new version: its data, description, tags, readonly and activated. A deleted item is re-created with its original id (give it by id). Needs the token's restore permission; checked against the list's current schema and its write rules. Restoring twice makes two versions; restoring to the current version fails with ITEM_UNABLE_TO_RESTORE. 1 request.

Call one of the account's endpoint flows, e.g. flow "deal" for /flows/deal, and return its status, body, headers and runId. A flow can do anything its owner can: it can write to any list (bypassing write rules unless it opts in to them) and send webhooks, so treat every call as a real action, and only run flows the user asked for. Everything a run writes is kept together or not at all; a failed run returns the flow's code, node and message, and the runId that finds it in the dashboard's run log. The token needs the run permission for the flow (run-with-identity when acting as an identity). Cos…

Full-text search (BM25) over the values of a list's searching indexes; at most 10 results, best first. A list without a searching index always finds nothing. Tags aren't searched: filter by tag with list_items. 1 request.

A dry run of one write against a list's write rules (or candidate rules), using the list's live data: whether it would be allowed, which statement decided, and what every statement evaluated to. Nothing is written. Describe the write with itemId (the existing item, for update, delete and restore) and new, patch or merge. The token needs update on the list. 1 request, plus 1 per item the rules look up. To check syntax and the stored tests without live data, the JSONPad docs server's check_write_rules costs nothing.

Change an identity; fields left out are left as they are. Setting a password logs the identity out on every device. 1 request.

Change an index; fields left out are left as they are. A new pointer or valueType starts a rebuild (the index is unusable until it finishes). Turning alias on is refused if values aren't unique or are too long. Turning guard on hides existing values from token reads at once. 1 request.

Change an item's metadata (description, tags, version, readonly, activated) and, with data, replace all of its data. To change only some of the data, use merge_item_data or patch_item_data. On a list with guard indexes, replacing the whole data would delete the values this token can't see, so it's refused unless overwriteGuarded is set. Pass the etag you read as ifMatch. 1 request (plus 1 to find the list's guard indexes, the first time).

Change a list's fields; fields left out are left as they are. A new schema doesn't re-check existing items, but applies to later writes and restores. New rules apply from the next write, and the stored tests must pass first; rules: null removes them. readonly: true blocks writes to the list, its items and its indexes. 1 request.

Poll an index until its build is ready or has failed. Every poll is a metered request (starting 1 second apart, slowing to 10 seconds); the result says how many were made. A failed build is an error; running out of time returns timedOut: true with buildStatus "building".