Skip to content

Structured data, API-first

The data layer for your apps, agents, website, catalog, docs and flows

Model your data once, then use it however you like: in an editor, through the API and SDKs, from CI or through your agents. Search and history built in.

The history of the post 'The Accordion, a month on': six revisions, each with who made it, the client it came through and the change note, from people in the editor, an SDK and a CLI key.

Click, code or hand it off. Same data, same rules.

Work in the editor, build on the API, script it from CI or let an agent do it. Every path checks the same permissions, runs the same validation and lands in the same history.

  • Use the editor. Forms generated from your schema, with drafts, publishing, assets and search. No code needed.

  • Skip the UI. Everything the editor does, the API does. Your schema can live in a file next to your code.

  • Build it into your product. Typed SDKs or any HTTP client, and webhooks that tell your systems when something changes.

  • Automate it. Imports, syncs and scheduled jobs through the CLI, with JSON output and retries that never apply twice.

  • Hand it to an agent. A key of its own, a map of the API, and guardrails that keep every change attributed and reversible.

Editor

An editor your team will actually like

Your schema becomes an admin panel nobody had to build, for articles, products, listings or anything with a shape. Editors work in drafts, publish when ready, and act on many records at once.

  • Rich text, relations, assets and lists, each with an input made for it
  • Drafts and publishing, one record or many at once
  • Search and filters across every collection
An article in the editor: a form built from the schema, with its title, slug, summary and a rich text body.

History

Who changed what, and why

Each edit is a revision: who made it, through which client, and why. People, scripts and agents all leave the same trail.

  • Compare any two revisions, field by field
  • Revert in one click; the revert is a revision too
  • Redact values that should never have been saved

Built for AI agents.
Guardrails included.

Coding agents, CI jobs and the agents in your own product use the same API as your team. You decide what each key can touch, and history shows every change it made and why.

Everything for agents
terminalan agent, with guardrails
# Say why, and refuse to overwrite anything newer than revision 3
$ nohead records update rec_01M3MSCJ… \
    --set title="Hello, world!" \
    --if-revision 3 --note "Fix typo"
  Error: Record has changed since revision 3
    - Current revision is 4

# Preview a revert before it happens
$ nohead records revert rec_01M3MSCJ… 3 --dry-run
  Dry run: reverting to revision 3 would change:
  reading_time (changed): 5 → 4

# Deleting is soft; restore within 30 days
$ nohead records delete rec_01M3MSCJ…
$ nohead records restore rec_01M3MSCJ…
  • A key of its own, with only the scopes it needs, or published-only so it never sees drafts. Revoke it, and the agent stops.
  • Any agent, any client: coding agents use the CLI and /llms.txt, chat apps connect over MCP, and your own agents use the API.
  • Undo for anything: notes say why, revision checks stop overwrites, and every change can be reverted.

Secure by default. You decide who gets in.

Every request is checked the same way, whether it comes from a person in the editor, a script or an agent. Access is something you grant, scope and revoke.

More on security
  • Roles for people. Owners, admins, developers, editors and viewers. Everyone sees and changes only what their role allows.

  • Keys scoped to their job. Scripts and agents get a key for one project, with only the scopes you grant. Keys can expire, and revoking one takes effect at once.

  • Tenant isolation, tested. Every API operation is tested in CI against other organizations' IDs, missing scopes and the wrong role.

  • No passwords to leak. People sign in with a code sent by email. Sessions live in httpOnly cookies, with no tokens in the browser.

Also in the box. Migrations, assets and webhooks.

The pieces other tools leave to a plugin or a second vendor come with every project, on every plan.

Schema changes without the fear

Change a field's type, make it required or tighten its rules as an explicit migration. Every record is checked first, and nothing is written until you say so.

Images by URL

Upload straight to storage, then write any size, crop or format into the image URL. Renditions are made on first request and cached on a CDN for a year; Next.js, Astro and Nuxt's image components use them with one line of config, and image loads aren't metered.

Webhooks that tell the truth

Signed events for records, assets and schema changes, retried with backoff for over a day, with delivery logs and one-click retry.

Any data with a shape. Shared by people, apps and agents.

Collections, relations, files, search, webhooks and history: build a CMS on them, or the shared data of something bigger. Keep your app's high-volume data in its own database; put what people and systems share here.

Websites and docs

Pages, posts, docs and knowledge bases your team edits without a deploy, searchable by your site, your support tools and your agents.

Catalogs and listings

Products with typed prices, variants and photos, or listings and directories, filtered and searched by your storefront, your tools and your agents.

User submissions

Reviews, comments or posts your backend sends in, kept unpublished until someone approves them in the editor.

Data your agents maintain

Records that agents, imports and sync jobs create and update, every change attributed and reversible.

Back offices

The data your apps read, managed by your team in an admin panel generated from your schema, with drafts, bulk actions and every change attributed.

Reference data and settings

Locations, categories, price lists and the settings your apps fetch at runtime: what several systems read and someone has to keep right.

Simple pricing.
Generous limits.

The whole product on every plan, Free included. Plans differ in their limits and in how long history is kept.

Free

For side projects and trying things out.

$0 / month

  • 2 projects
  • 1,000 records
  • 100K API requests a month
  • 2 team members
  • 30 days of history

Pro

For products and small teams.

$29 / month

  • 5 projects
  • 100K records
  • 2M API requests a month
  • 10 team members
  • 1 year of history

Business

For companies with many projects, teams and integrations.

$99 / month

  • 10 projects
  • 500K records
  • 10M API requests a month
  • 50 team members
  • Unlimited history

Prices in US dollars, plus applicable tax. Yearly billing is two months free. Need more than Business? Enterprise has custom limits and retention.

Questions, answered.

The short version. The editor, developers, agents, security and pricing pages each answer more.

Ask us directly







Your first collection is two minutes away.

Start from a template or a blank collection, invite your team, and read it all back from the API before the coffee gets cold.