A serverless database that lives in your GitHub account
RepoGrid gives every database its own private repository. Run SQL over HTTP, keep JSON documents next to it, and let every write land as a commit you can diff, read or roll back.
SQLite · JSON documents · commits as versions · bearer-token API · nothing to host
curl "https://api-repogrid.vercel.app/api/dbs/db_c1c00d9e8fcb9c15/sql" \
-H "Authorization: Bearer db_your_key_here" \
-H "Content-Type: application/json" \
-d '{"sql":"SELECT id, email FROM users WHERE active = true LIMIT 20"}'How it works
Three steps from sign-in to a queryable database
- 1
Authorize RepoGrid
Sign in with GitHub and grant the repo and delete_repo scopes. RepoGrid can then create, read, write and remove the repository behind each database.
- 2
Create a database
Pick relational or JSON. RepoGrid provisions one private repository per database and wires the API to it. The database id in the URL is all you need.
- 3
Ship with commits
Every schema change, query and document write is a commit. Read any past version by sha, diff history like code, and roll back whenever you want.
Why RepoGrid
Built for people who want the data, not another platform
Your data stays yours
The database is a repository in your account. Clone it and you have the schema, the rows and the history, in ordinary files. There is no proprietary format to export before you leave.
History and rollback for free
Every schema change, query and document write is already a commit. Diff it, review it, roll it back, or read any past version, without building a backup pipeline.
No instances to size
There is no server to provision, no connection pool to tune and no cold start to plan around. Requests go to one HTTP endpoint and the storage layer is the one you already pay for.
SQL and documents, one API
Relational tables with real joins and aggregates, JSON collections with filters and projections, and one bearer-token API over both. No SDK to install, no client library to upgrade.
Portable by construction
Grep a row in a commit, script a migration with git, or hand the repository to another engineer. The database is a git repo, so every tool you already use still applies.
Scoped, revocable access
Keys are minted per project, revoked from the dashboard, and shown with their last use. Reads accept a key or a session, writes demand a key, so a stray tab cannot mutate your data.
Instead of
A managed Postgres or MySQL instance
No instance to provision or patch, and no connection string in your config. The schema lives in a file you can read.
Instead of
A document database with its own query dialect
Documents when you want them, plus real SQL when you do. One API for both instead of two clients to maintain.
Instead of
Hand-rolled files in a GitHub repository
The same storage, plus an API, a schema, indexes, a SQL console, a dashboard and per-write history.
Features
A database platform that stays out of your way
SQL over HTTP
POST a statement to /sql and get columns, rows and timing back as JSON. DDL, DML and reads all go through the same endpoint, with bound parameters instead of string concatenation.
JSON documents
Collections hold documents with ids, revisions and filters. Batch inserts, upserts, $unset patches and Mongo-style filters are all first-class.
Git history as versions
Commits are your backup, your audit trail and your rollback. Read a table or collection at any past sha without restoring anything.
Scoped API keys
Issue keys per project, revoke them from the dashboard, and see the last-used timestamp. Reads accept a session or a key; writes always require a key.
Usage and cache insight
Versions, record counts, repository size, cache hits and API rate-limit headroom are on the database page, so you know what the database is doing.
Nothing to host
No cluster, no connection string, no cold starts to plan for. The GitHub API is the durable layer, so the platform scales with your repositories.
API
One bearer token, every operation
curl "https://api-repogrid.vercel.app/api/dbs/db_c1c00d9e8fcb9c15/sql" \
-H "Authorization: Bearer db_your_key_here" \
-H "Content-Type: application/json" \
-d '{"sql":"SELECT id, email FROM users WHERE active = true LIMIT 20"}'const res = await fetch("https://api-repogrid.vercel.app/api/dbs/" + dbId + "/sql", {
method: "POST",
headers: {
Authorization: `Bearer ${process.env.REPOGRID_KEY}`,
"Content-Type": "application/json",
},
body: JSON.stringify({ sql: "SELECT count(*) AS users FROM users" }),
});
const { result } = await res.json(); // /sql wraps everything in "result"
console.log(result.rows[0].users);/api/dbs/:id/sql
Run SQL, get columns and rows back as JSON.
/api/dbs/:id/tables/:t/rows
Page through a relational table.
/api/dbs/:id/collections/:c/docs
Filter, sort and write JSON documents.
/api/dbs/:id/versions
List commits and read any past version.
Full request and response reference, filters, limits and error codes live in the API docs.
FAQ
Questions worth answering before you start
Where is my data actually stored?
In a private GitHub repository under your own account. Schema and data live in that repository, which means your data is portable: clone it, grep it, or delete it whenever you want.
Which SQL dialect do I get?
SQLite, executed in-process through sql.js. Create tables, add indexes, join, aggregate and run DML with bound parameters, all through the same HTTP endpoint.
How do I connect from my app?
With a bearer token. Create an API key in the dashboard, then send Authorization: Bearer db_… with any HTTP client. There is also a JavaScript example and a runnable Node script in the API docs.
What happens to my data if I stop using RepoGrid?
Nothing is held hostage. The repositories are yours: revoke RepoGrid's access, delete a database from the dashboard, or work with the repositories directly on GitHub.
Can I read an older version of my data?
Yes. Every write is a commit, and reads accept a version parameter, so you can query a table or collection at any past sha and compare it with the current state.
Do I need to install anything?
No. The dashboard runs in your browser and the API is plain HTTPS, so a database is reachable from a server, a script, a notebook or a static site.
Your next database is a repository away
Sign in with a fresh GitHub account and query it in under a minute.