Point BackendStudio at your PostgreSQL, MySQL, or SQLite database. It reads the schema and serves a REST API with OpenAPI docs from your Mac — no code to write, nothing to deploy. Read-only until you grant write access, one table at a time.
| id | total_orders | life_value | |
|---|---|---|---|
| usr_8fa2 | sarah.k@stripe.com | 14 | $2,480.00 |
| usr_9b1c | alex@indiehackers.net | 8 | $1,120.00 |
| usr_2d7e | d.heinemeier@37signals.com | 6 | $890.00 |
PostgreSQL, MySQL, and SQLite each get the same generated REST API, so the endpoint you call does not change when the database does. Redis and MongoDB are browsable in the app, but deliberately not served over HTTP — see below for why.
Tables and views become REST endpoints, with types preserved: numerics stay numbers, NULL stays null, and NUMERIC never degrades into a float.
Same API surface as Postgres. Connect over TCP or a socket, and the schema BackendStudio reads is the schema it will validate every request against.
Open a file, get an API. The file is opened read-only and is only reopened for writing once you grant a table — so a browse session cannot alter it.
Browse keys, hashes, and sorted sets from the app. There is no REST API for Redis: without tables and columns there is nothing to validate a request against.
Browse collections and nested documents from the app. Like Redis, it stays out of the API: a document store has no fixed schema to check a request against.
Listing rows, filtering, paginating, fetching by id, writing the OpenAPI spec, remembering to parameterize — the same code every project starts with. BackendStudio derives it from your schema instead.
Filter on any column, sort, paginate, or fetch a single row by primary key. Types survive the trip: an integer arrives as a number, a NUMERIC keeps its decimal places, and SQL NULL comes back as null instead of an empty string.
{
"rows": [
{
"id": 1,
"email": "alice@example.com",
"plan": "pro",
"mrr_usd": 49.00,
"canceled_at": null
},
{
"id": 2,
"email": "bob@example.com",
"plan": "free",
"mrr_usd": 0.00,
"canceled_at": null
}
],
"count": 2
}An OpenAPI 3 document is generated from the same schema that serves the data, so it cannot drift from reality. Open the Swagger page and try a call, or hand the spec to a client generator.
"/api/users/{id}": {
"get": {
"parameters": [
{ "name": "id",
"in": "path",
"required": true,
"schema": {
"type": "integer" } }
],
"responses": { "200": … }Granting one table says nothing about the rest. Until you flip a switch, POST, PATCH, and DELETE do not exist — and a PATCH or DELETE with no filter is refused rather than applied to every row.
Require an API key, list the origins allowed to call from a browser, and reach a database behind a bastion over SSH with the host key pinned. Then watch what actually arrives — method, path, status, and duration, with a p95 that only appears once there is data behind it.
Streamline your architectural operations with a workspace built specifically to integrate with your local CLI and Git repositories.
Enter your connection details, or open a SQLite file. BackendStudio reads the schema — tables, views, columns, types, primary keys — and that introspected schema becomes the contract every later request is checked against.
Under the hoodEverything starts read-only. Hide the tables that are none of the caller's business, then grant write access to the few that need it. The API only ever advertises what you actually turned on.
Under the hoodPress Start and the API is live on your local network, with a Swagger page and an OpenAPI spec beside it. Watch requests land in the log with status codes and p95 latency while a frontend is built against it.
Under the hoodA fresh connection serves GET and nothing else. Write access is granted one table at a time, and the API never advertises a write method you have not enabled. With SQLite, the file itself is opened read-only until a table is granted.
There is no endpoint that accepts a query. Every table and column name in a request is checked against the schema BackendStudio read from your database, and every value travels as a bound parameter — never as text pasted into a statement.
Passwords, SSH keys, and connection details live in the macOS Keychain, not in a config file. They are never included in an API response, an error message, or a log line — not even when a connection fails.
Turn on auth without setting a key and requests are refused rather than waved through. API keys are compared in constant time, CORS answers only origins you listed, and an SSH host key that does not match the one you pinned aborts the connection.
Every option is the same app — the only difference is how you pay. The trial is 7 days with nothing held back; after it ends the app still opens and your connections are still there, but serving requires a subscription.
Try it on a real project. Cancel whenever.
7-day free trial
$4.00 a month, paid once a year.
Save 33% — about four months free
One payment. Every future version included.
Nothing renews
Everything you need to know about security, schemas, offline workflows, and licensing.
BackendStudio reads your schema and immediately serves a REST endpoint for every table and view — list, filter, paginate, and fetch by primary key. Alongside it you get an OpenAPI 3 spec and a Swagger UI page, so you can hand a frontend developer a URL instead of writing a backend. Nothing is generated on disk and there is no build step.