Filter and sort without writing SQL.
Build them from the column list, or type your own WHERE and ORDER BY. The grid pages through tables of any size.
One docker run or one binary under 3 MB. Postgres and SQLite, nothing else to install.
docker run … -e DATABASE_URL=… workflowjd/zettacurl -fsSL …/zetta/main/install.sh | shSet your database URL, run it, then open the localhost link it prints.
Then open any database with zetta app.db or a postgres:// URL.

1.4MB
To download, under 3 MB unpacked
0deps
Beyond libc, nothing is linked
2engines
Postgres and SQLite, both native
5builds
For macOS, Linux and Windows
The live demo is zetta itself, compiled to WebAssembly and running in this browser tab against a sample shop database. Nothing you do leaves the page.
A one-time download of about 2.6 MB.
How it runs
Your dev database already runs in Compose. Put zetta beside it and every developer on the project gets a database UI with docker compose up.
services: db: image: postgres:17 environment: POSTGRES_PASSWORD: postgres zetta: image: workflowjd/zetta ports: ["127.0.0.1:1993:1993"] environment: ZETTA_TOKEN: ${ZETTA_TOKEN} DATABASE_URL: postgres://postgres:postgres@db:5432/postgres depends_on: [db]
Put a token from openssl rand -hex 16 in .env as ZETTA_TOKEN, then open the link docker compose logs zetta prints.
Every schema, table, view and function, a grid that pages through any table, and a SQL editor that knows your columns. It opens in the browser you already have.
Build them from the column list, or type your own WHERE and ORDER BY. The grid pages through tables of any size.
JSON pretty-printed, foreign keys one keystroke away, and each table's structure, indexes, triggers, DDL and relationships.
Highlighting and completion. Run the statement at the caret, the selection or the whole script. It asks before anything that destroys data.
Send a link and the other person lands on the same table, filter and row. Copy cells and rows as CSV, TSV, JSON or Markdown, or save them as a file.


zetta query prints a table, CSV or JSON. Results go to stdout and diagnostics to stderr, so it pipes cleanly. Every flag has an environment variable, and DATABASE_URL keeps a password out of the process list.
zetta ./app.dbBrowse a SQLite filezetta postgres://me@localhost/app --read-onlyBrowse Postgres without writeszetta query app.db -f csv < report.sql > report.csvScript a reportzetta tables app.dbList schemas and tableszetta completion fishCompletions for bash, zsh and fish~/shop❯zetta query shop.db "select name, city, round(balance, 2) as balance from customers order by balance desc limit 4"
name | city | balance -------------------+-------------+--------- Sara Tesfaye 1081 | Adama | 1265.67 Abebe Kebede 135 | Hawassa | 1265.0 Abebe Kebede 270 | Addis Ababa | 1263.33 Abebe Kebede 405 | Hawassa | 1261.67 (4 rows)
name,city,balance Sara Tesfaye 1081,Adama,1265.67 Abebe Kebede 135,Hawassa,1265.0 Abebe Kebede 270,Addis Ababa,1263.33 Abebe Kebede 405,Hawassa,1261.67
{"columns":[{"name":"name","type":"text"},{"name":"city","type":"text"},{"name":"balance","type":"real"}],"rows":[["Sara Tesfaye 1081","Adama","1265.67"],["Abebe Kebede 135","Hawassa","1265.0"],["Abebe Kebede 270","Addis Ababa","1263.33"],["Abebe Kebede 405","Hawassa","1261.67"]],"rowCount":4,"rowCountExact":true,"truncated":false}An explorer holds the keys to your data, so zetta treats the browser tab as a guest rather than a trusted client.
serve listens on 127.0.0.1 with a new one-time token each run. A non-loopback host is refused unless you pass both --token and --allow-plain-http.
A Host that is not an IP, localhost or on your --allowed-hosts list is refused, and so is any API call from another origin. The page's CSP allows inline code only by hash.
--read-only is enforced inside the database adapter, not the UI. SQLite opens the file read-only; Postgres runs each statement in a read-only transaction and refuses DO and CALL.
Tokens, cookies and passwords never reach a log, and the password in any DSN is redacted before it is printed.
zetta speaks the Postgres wire protocol itself, with TLS from the Zig standard library, and compiles the official SQLite amalgamation in. The binary links libc and nothing else.
one static binarylinks: libcPostgres support
curl -fsSL https://raw.githubusercontent.com/dagimg-dot/zetta/main/install.sh | sh
Picks the build for your system, checks it against the release's SHA256SUMS and installs to /usr/local/bin, or ~/.local/bin when that is not writable. Set ZETTA_VERSION to pin a release.
git clone --depth 1 https://github.com/dagimg-dot/zetta cd zetta/packaging/aur/zetta-bin && makepkg -si
Builds the zetta-bin package from this repository, with bash, zsh and fish completions.
export ZETTA_TOKEN=$(openssl rand -hex 16) docker run --rm -p 127.0.0.1:1993:1993 -e ZETTA_TOKEN \ -e DATABASE_URL=postgres://user:password@db:5432/app workflowjd/zetta
A static binary on scratch for amd64 and arm64, also on ghcr.io/dagimg-dot/zetta. Open http://localhost:1993/?token=$ZETTA_TOKEN.
services:
db:
image: postgres:17
environment:
POSTGRES_PASSWORD: postgres
zetta:
image: workflowjd/zetta
ports: ["127.0.0.1:1993:1993"]
environment:
ZETTA_TOKEN: ${ZETTA_TOKEN}
DATABASE_URL: postgres://postgres:postgres@db:5432/postgres
depends_on: [db]Put ZETTA_TOKEN in .env, run docker compose up, and open the link docker compose logs zetta prints. zetta waits up to 30 seconds for the database to start.
cd web && bun install && cd .. zig build -Doptimize=ReleaseSafe
Needs Zig 0.16.0 and bun. The binary lands in zig-out/bin/zetta.
Anything else, ask in the issue tracker.
zetta is a free, open-source database explorer for Postgres and SQLite. It is one binary under 3 MB that serves its UI to the browser you already have, so you can browse schemas, filter tables, follow foreign keys and run SQL. The same binary also runs queries from the shell.
Postgres and SQLite. zetta speaks the Postgres wire protocol itself, with SCRAM-SHA-256, MD5 and every sslmode, and compiles the official SQLite amalgamation in. A database is a postgres:// URL, a libpq keyword string or a path to a SQLite file.
No. The binary links libc and nothing else. Its Postgres client and TLS are written in Zig, SQLite is compiled in, and the web UI is embedded. There are prebuilt binaries for macOS, Linux and Windows, and a 1.5 MB Docker image.
zetta listens on 127.0.0.1 with a new one-time token each run, and refuses other hosts and origins. With --read-only it refuses writes inside the database adapter, not just in the UI, and passwords never reach a log. For a hard guarantee on Postgres, connect as a read-only role.
There is nothing to install beyond one small binary or one docker run, and every view lives in the URL, so a link opens the same table, filter and row for someone else. It also fits in a docker-compose.yml beside the database your project already runs.
Yes. zetta query prints a table, CSV or JSON to stdout with diagnostics on stderr, and zetta tables lists schemas and tables. Every flag has an environment variable, and DATABASE_URL keeps a password out of the process list.
Yes. zetta is open source under the MIT license, and the live demo on this site runs it in your browser with nothing to install.
Try it in this tab first, then install it in one line. Free and open source under MIT.