What it is

Daptin is a self-hosted application server built in Go. It lives in the backend-as-a-service and headless CMS ecosystem, and it organizes behavior around schema files that describe records, fields, relationships, validation, and optional flags. Each configured table becomes a permission-aware JSON:API resource at /api/{entity}, and the server attaches identity, files, automation, integrations, realtime delivery, metering, and protocol surfaces around that runtime.

The concrete problem it addresses is defining a data model once and exposing it through multiple backend surfaces without rebuilding each API, permission rule, storage route, or operational control separately. Daptin records much of its capability as ordinary data, with rows in tables such as action, task, smd, cloud_store, site, integration, llm_provider, and api_plan telling the server what to execute or expose.

Key capabilities

• Define resources in YAML or JSON schema files, with 41 column types, relations and joins, composite keys, validation and conformation, translations, audit, state, and metering flags.
• Expose configured tables as JSON:API resources with CRUD operations, relationships, filtering, sorting, and pagination, plus a separate aggregation API, optional GraphQL, OpenAPI, metadata, and JavaScript model discovery routes.
• Manage identity and access through users, groups, ownership, table, row, relation, and action permissions, JWT login flows, OTP, OAuth client connections, and OAuth 2/OIDC provider endpoints with JWKS.
• Configure automation and operations as data by using system tables such as action, task, smd, cloud_store, site, integration, llm_provider, and api_plan for actions, schedules, storage, integrations, mail, and plans.
• Attach realtime, files, storage, feeds, LLM routes, and built-in protocol surfaces around the same resource runtime.

Who uses it and how

• Developers can evaluate Daptin locally with Docker, using the daptin/daptin:latest image and a Compose stack that binds Daptin to 127.0.0.1:6336 while keeping PostgreSQL private.
• Linux users can download the latest release binary, run it on port 6336, open http://localhost:6336, and create the first administrator.
• Kubernetes operators can follow the Kustomize deployment guide.
• Teams can define their model in schema files and use JSON:API, GraphQL, WebSockets, feeds, files, OAuth/OIDC, LLM routes, and built-in protocols from one runtime.

Getting started

Daptin can be run with Docker using the daptin/daptin:latest image, with a Docker Compose stack for PostgreSQL-backed local evaluation, as a Linux binary, or through a Kubernetes Kustomize deployment.

When to use it — and when not to

Daptin suits self-hosters who want one schema to generate multiple API, identity, automation, and protocol surfaces, but it requires operating PostgreSQL, asset storage, mail, and permission configuration rather than relying on a hosted backend. The use of schema files and system tables gives flexibility, but adopters must configure, secure, and maintain those data-driven surfaces. The listed 28 open issues and missing contributor count are facts to consider before production adoption.

docker run --pull=always --rm -p 127.0.0.1:6336:8080 daptin/daptin:latest

cp .env.example .env
docker compose up --wait

curl -L -o daptin https://github.com/daptin/daptin/releases/latest/download/daptin-linux-amd64
chmod +x daptin
./daptin -port=6336

Tables:
  - TableName: product
    Columns:
      - Name: name
        DataType: varchar(200)
        ColumnType: label
        IsIndexed: true
      - Name: price
        DataType: float
        ColumnType: measurement
      - Name: published
        DataType: bool
        ColumnType: truefalse
        DefaultValue: "false"

GET    /api/product
POST   /api/product
PATCH  /api/product/{reference_id}
DELETE /api/product/{reference_id}