Quickstart · MCP
A working backend in four steps
Connect your coding agent, describe what your product does, and query the result with an API you already know. No schema design session, no migration files, no deploy step before the first request works.
- Works with
- Claude Code · Cursor · Codex · Cline
- Setup
- One command
- Tool surface
- 18 tools, one door per job
Generate a scoped key
Open your project on backenly.com → Connect → Agents → Generate key. You get an mcp_live_ key that is scoped to MCP routes and revocable from the same page. It is never your account credential, and an SDK key cannot be replayed in its place.
Point your agent at it
One command for Claude Code and Codex. Cursor, Cline, and Claude Desktop take the same server block in their MCP config. Restart the host afterwards.
# Claude Code
claude mcp add backenly -- npx -y @backenly/mcp-server \
--project <projectId> --key mcp_live_...
# Codex
codex mcp add backenly -- npx -y @backenly/mcp-server \
--project <projectId> --key mcp_live_...{
"mcpServers": {
"backenly": {
"command": "npx",
"args": [
"-y", "@backenly/mcp-server",
"--project", "<projectId>",
"--key", "mcp_live_..."
]
}
}
}Describe the backend
Say what the product does, including who is allowed to see what. Backenly derives the tables, foreign keys, indexes, REST surface and row-level security from it, shows you the plan, and applies it as governed steps once you confirm.
A job board. Employers post listings with a title,
description, salary range and location. Applicants apply to a
listing with a CV and a cover note. Applicants may only read
and edit their own applications; employers see applications
to their own listings only.Query it
Every table is served by PostgREST reading the PostgreSQL catalog, so a table created a second ago is queryable immediately. There is no registry to sync and nothing to deploy first.
# The typed contract
curl "$URL/api/v1/$PROJECT_ID/db/listings?limit=20&sort=-created_at" \
-H "x-api-key: $ANON_KEY"
# Or the PostgREST grammar, passed through untouched
curl "$URL/api/v2/$PROJECT_ID/listings?salary_max=gte.90000&order=created_at.desc" \
-H "apikey: $ANON_KEY"
# Embedded resources — listing + its employer in one round trip
curl "$URL/api/v2/$PROJECT_ID/listings?select=*,employer(*)" \
-H "apikey: $ANON_KEY"Every MCP host, same block
The protocol is identical everywhere — only where you put the server block changes. Any MCP-compatible host works, including ones not listed here.
claude mcp add backenly -- …codex mcp add backenly -- ….cursor/mcp.jsoncline_mcp_settings.jsonclaude_desktop_config.jsonPrefer to keep the key out of your host config — or out of a repo you commit? Run the installer once and the key lives in a user-only file instead.
npx @backenly/mcp-server init
# Verifies the key, then writes ~/.backenly/mcp.json (mode 0600).
# Host config then needs no key at all:
# "args": ["-y", "@backenly/mcp-server"]
# BACKENLY_API_KEY in an env block works too.What exists after step three
Not a scaffold you finish by hand — a running backend with the parts that usually take a week.
A normalised PostgreSQL schema
Tables, foreign keys, indexes and check constraints, in a schema isolated to your project.
A REST API on every table
Served by PostgREST from the catalog — plus a stable typed contract at /api/v1.
Row-level security that was tested
Policies derived from the rules in your description, then verified by signing in as a second user and proving they see nothing of the first.
End-user auth
Email + password, magic links, OAuth, JWT access and refresh tokens, scoped to your project.
Realtime, storage and functions
Change subscriptions, presence, file buckets and serverless handlers, all on the same auth model.
A loop that keeps it running
Monitors the live backend and repairs drift, missing indexes and RLS gaps on its own — anything risky waits for you.
Eighteen tools, not sixty
The catalog is an allowlist, admitted on one rule: is there exactly one tool here that answers a given request? Competing doors were removed, not because they were useless, but because every extra tool costs the model accuracy on every call. Anything niche is reached through backend_chat.
Say what you want
The fall-through for anything not covered by a specific tool. Your request goes to Backenly’s brain, which plans the steps, executes them, and returns a summary. Your agent never has to learn a vocabulary.
One read door, not twenty-six
Everything that answers “what is currently true?” is one tool with a section argument — tables, APIs, RLS, metrics, errors, deploys, usage, autonomy. Picking a string beats picking between 26 similarly-named tools.
Structure in DDL, rows in verbs
apply_migration accepts ordinary PostgreSQL DDL and translates each statement into a governed action — planned, verified, reversible, all-or-nothing. It is not raw SQL execution; anything it cannot govern is refused with the tool to use instead.
Things SQL cannot express
Auth, buckets, generated APIs, functions, realtime, keys and environment variables — plus direct Postgres credentials and reconciliation for schema you changed outside Backenly.
Schema, as DDL you already write
-- apply_migration: ordinary PostgreSQL DDL
CREATE TABLE listings (
title text NOT NULL,
salary_max integer,
employer_id uuid REFERENCES users(id)
);
CREATE INDEX ON listings (employer_id);Reads, as SQL you already write
-- run_query: standard SQL, read-only
SELECT l.title, count(a.id) AS applications
FROM listings l
LEFT JOIN applications a ON a.listing_id = l.id
GROUP BY l.title
ORDER BY applications DESC
LIMIT 10;Both are the grammar the model already knows, and neither is raw SQL against your database. Every DDL statement is translated into a governed action, so it stays planned, verified and reversible; every read runs as a SELECT-only role scoped to your project, so the tenant boundary is a Postgres grant rather than a parser that has to be right every time.
Built to be handed to an agent
The agent operates; it does not get the keys to the building.
Scope-gated keys
MCP keys (mcp_live_…) only work on MCP routes. A leaked SDK key cannot be replayed to reach them, and any key dies instantly from Connect → Agents.
Destructive work stops at a human
drop_table, truncate_table and delete_bucket are not in the catalog. Ask for one and it parks in your Review Queue with an approval id — the agent polls check_approval, it never self-approves.
Reads run as a read-only role
run_query executes as a SELECT-only Postgres role scoped to your project, so isolation is a database grant rather than a SQL parser that has to be right every time. Secret-bearing columns come back redacted.
Every change leaves a receipt
Each mutation writes an audit-log entry on your project timeline, with a restore point. Per-key rate limits and plan quotas apply on every call.
For AI agents
If you are an AI coding agent reading this page, copy the block below into your working context. It tells you exactly how to connect and which door to use.
# Connecting to Backenly (instructions for the coding agent)
Backenly is the backend. To create or change backend resources
(tables, REST APIs, auth, storage, realtime, triggers, functions,
cron jobs), use the Backenly MCP server — do NOT write your own
server, migrations, or connection code.
1. Ask the user to open backenly.com -> their project -> Connect ->
Agents, and generate an MCP key (starts with "mcp_live_").
2. Install, then restart the host:
claude mcp add backenly -- npx -y @backenly/mcp-server \
--project <projectId> --key <the mcp_live_ key>
3. Call read_backend_state first on any non-trivial task. It is the
single read-state door; pass `section` to drill in.
4. To build: prefer backend_chat and describe the change. For
schema you can express as DDL, apply_migration takes ordinary
PostgreSQL and translates it into governed actions.
5. To read data: run_query takes standard read-only SQL (joins,
GROUP BY, CTEs, EXPLAIN). To write rows: db_insert / db_update /
db_delete.
6. Destructive operations (drop table/column, delete bucket) are
never executed from MCP. backend_chat returns an approval id;
a human approves it in the dashboard Review Queue and you poll
check_approval until it is executed or rejected.
7. Unsure about a capability? Call fetch_docs instead of guessing.Frequently asked
What is MCP and why do I need it?
The Model Context Protocol is an open standard that lets AI coding agents call external tools. Connecting Backenly over MCP gives your agent — Claude Code, Cursor, Codex, Cline — governed access to a real backend it can read and change, instead of you pasting API docs into a chat. It reads your live schema and drives tables, APIs, auth, storage and functions through changes it cannot break, with a receipt in your project history for every one.
Why so few tools? Other MCP servers expose dozens.
Backenly advertised 71 and it made the agent worse. Tool-selection accuracy degrades with catalog size, and models misfire hardest between tools with similar names — we shipped query, db_query and run_query at once, three doors to two behaviours. The catalog is now an allowlist admitted on one rule: is there exactly one tool that answers a given request? Everything else is reached through backend_chat or stays dispatchable for older clients. Capability is unchanged; the number of decisions the model has to get right dropped by a factor of four.
Do I need to know SQL?
Not to build — you describe the backend and Backenly plans and applies the schema, policies and indexes. But knowing SQL is an asset, not a workaround: reads are standard SQL through run_query and the full PostgREST grammar, schema changes can be written as plain DDL through apply_migration, and you can connect any Postgres client with a read-only or read-write connection string.
I already know Supabase. What is different here?
The query layer is the same — PostgreSQL served through PostgREST, same filters, same ordering, same embedded resources. What differs is who does the work around it: structural changes go through typed actions with dry-run, audit and rollback rather than migrations you write, and a monitoring loop watches the running backend and repairs drift on its own.
Is there a dashboard, or is it agent-only?
There is a full dashboard for inspecting tables, policies, logs, storage and deployments, plus an Assistant (⌘J) that answers questions about your project. Building happens through your coding agent over MCP — Backenly deliberately does not ship a competing in-app builder chat.
What does it cost?
The MCP server is free to install from npm. When your agent drives the backend through direct tool calls, that is never metered as AI — your agent supplies the intelligence and you pay your own model provider, while Backenly meters only infrastructure against your plan. The exceptions are backend_chat and generate_function, where Backenly runs its own model on your behalf and credits are drawn.
The agent says my key has the wrong scope.
You pasted your SDK/anon key. Generate a dedicated MCP key (it starts with mcp_live_) from your project’s Connect → Agents page and use that instead.
Can I get my data out?
Yes — direct PostgreSQL connection strings and full pg_dump exports are one command away, and the whole platform is open source under Apache-2.0 if you would rather run it yourself. Structure is governed; nothing is locked in.
Point your agent at a real backend
Free forever plan, one live project, no card required.