Fóir as an alternative to Payload

Both give you typed access to content models you define in code. The difference is what sits underneath them, and where each of us enforces what we promise.

Side by side

Price

Fóir
£0.99, £29 or £99 a month
Payload
Free self-hosted, or from $35 a month for Payload Cloud

Content management

Fóir
Standard
Payload
Standard

Tenant isolation

Fóir
Enforced beneath your code
Payload
Application-layer checks

Per-tenant schema

Fóir
Per project or organisation
Payload
One config for every tenant

Personalisation

Fóir
Built in, resolved per request
Payload
Third-party integration

Audience preview

Fóir
Built into the editor
Payload
No personalisation to preview

Agent access

Fóir
Content and control plane
Payload
Record CRUD per collection

Agent safeguards

Fóir
Approval gate, fails closed
Payload
Per-key permissions

Generated API

Fóir
Typed GraphQL from your models
Payload
Typed from your config

Hosted auth

Fóir
Sign-in, roles and tokens included
Payload
Bring your own for end users

Backend beyond content

Fóir
Operations, hooks, schedules, secrets
Payload
Hooks and jobs you write

Data ownership

Fóir
Postgres export, access rules included
Payload
Self-managed database

Running it

Fóir
Managed, no database to run
Payload
You run and patch it

Payload's behaviour is taken from its published documentation, current at August 2026. Where we say a thing is absent we mean absent from core and from official plugins, not impossible to build. Corrections are welcome and we will make them.

Owning your data without running a database

The usual reason to self-host is a worry about lock-in: if the vendor goes away, or the price changes, or the answer to a question is no, you want your content somewhere you control.

Fóir answers that with an exit rather than an obligation. One command produces a database you own: a table per model, references as real foreign keys, and your access rules translated onto it, checked by a test that puts the same customer's claims against both databases and requires the same rows back. You can leave, and the thing that made your data safe leaves with you.

Until you want to, there is no database for you to run, patch, or be woken by.

A check you forget cannot leak a row

Payload separates tenants with access-control functions that add a filter to your query. That holds exactly as long as every collection is registered and every code path goes through it, and their own documentation is direct about the limits.

In Fóir the rules you write are enforced underneath the application, not by it. A read that forgets a check comes back empty rather than complete, and a project that gains somewhere new to store data cannot ship without rules covering it.

The rest of the backend comes with it

Most of what an application needs beyond storing content is already here: scheduled work, lifecycle hooks that fire on publish or change, outbound operations to the systems you integrate with, and a place to keep the API keys those calls need without pasting them into config.

Sign-in comes with it. Your end users get registration, password and one-time-code login, social providers, roles and refresh tokens, on your own domain rather than ours, without you standing up an auth service beside the CMS.

One workspace, every client

Agencies get a project per client, all administered from one workspace. Clients who should share a schema sit as organisations inside one project: the model is defined once, every organisation inherits it, and any of them can add a model of its own where a client needs something the others do not.

Every key is created inside a project and serves that project alone, so a client's key reaches only their own content. Each project has its own sign-in domain and its own branding.

An audience is a model you own

Content in Fóir resolves per request. An audience is defined from your own models, so it is editable, versioned and addressable like anything else, and a variant can replace a whole record or a single field inside it.

That is the piece with no equivalent on the other side. Payload points you at Croct or Statsig, which means a second system, a second bill, and content that lives in two places.

What you would otherwise assemble

A content API is the smallest part of what an application needs. These come with it.

Publishing

Drafts, full version history, revert, publish at a future time, and bulk rollouts when a batch has to go live together.

Model behaviour

Per model: versioning, publishing, variants, or none of them. Records can be plain data, owned by a customer, or public.

Permissions

Roles for your team and roles for your customers, plus per-record visibility and grants to a named person.

Hosted sign-in

Password, one-time code, and social or OIDC providers, on your own domain, with tokens and refresh handled for you.

Media and assets

An asset library with upload, transformations and responsive renditions, and the same access rules over files as records.

API keys

Each key reaches exactly the models and operations you allow, against a schema generated for that project.

Automation

Cron schedules, lifecycle hooks on publish and change, outbound operations, and a vault for the keys they need.

Notifications

Transactional email and push to web, iOS and Android, from the same events your content already emits.

Notes and tasks

Comments anchored to the record they concern rather than to a page, assignable to whoever has to act on them.

Ask Fóir

An assistant that works your content through the same tools and permissions your team has, staging its edits for review.

Work that carries on without you

Assign a task to Fóir and it works while you are away, coming back on the note when it needs an answer or is done.

Extensions

Install apps that add your own tools to the admin, beside the content they operate on.

Search and vectors

Full-text search, and embeddings generated for your records so you can retrieve by meaning rather than by keyword.

Geo

Store coordinates on any model and query by proximity: what is near this point, ordered by distance.

See it against your own models

Create a project, define a model, and read it back over the API.