Drop a SQLite database
or click to browse — .db / .sqlite / .sqlite3 / .db3 · opened in your browser, never uploaded
Browse tables, run queries, build them visually — your database stays on your machine.
Your files never leave your browser — all processing is local.
Drop a SQLite database
or click to browse — .db / .sqlite / .sqlite3 / .db3 · opened in your browser, never uploaded
Drop a .db, .sqlite or .sqlite3 file and browse it immediately: every table with its row count, views and indexes, the full schema DDL per table, and a paginated data grid with column sorting and quick filters. A database is about the most sensitive file there is — this viewer runs SQLite compiled to WebAssembly inside your browser, so the file is never uploaded anywhere. Pull a database off a phone backup, an app's data folder or a server and inspect it without it touching the network.
Query it two ways. The SQL editor gives you the real thing — syntax highlighting, friendly error messages, query history, read-only by default with an explicit switch to enable writes and export the modified database. The visual query builder needs no SQL at all: pick a table, tick columns, stack filter conditions from dropdowns, choose sorting and a row limit — and watch the generated SQL update live as you build, which doubles as a gentle SQL tutorial. One click moves the built query into the editor for hand-tuning.
Queries you build can be saved (named, stored only in your browser, keyed to the database's schema so they reappear next time you open the same file), and a template library covers the everyday asks: first 100 rows, group-and-count top N, date-range filter, text search across a table, duplicate finder, NULL-ratio check. Results export to CSV or JSON; BLOB columns are type-sniffed and image blobs render as thumbnails. WAL sidecar files, SQLCipher-encrypted databases and corrupt files each get an honest, specific message instead of a crash.
Three views help you understand a database's shape, not just its rows. An auto-generated ER diagram parses the foreign keys and draws every table as a box with its primary- and foreign-key columns, wired together with 1-to-many relationship lines you can pan and zoom — tables with no relationships are shown detached. A schema-diff view lets you drop a second database and see exactly what changed: tables added or removed, columns added, removed or retyped, and index and view differences — ideal for spotting migration drift between two versions of the same app. And because the engine loads the whole file into memory, the size warning is tiered and honest: it distinguishes a merely heavy database from one that is too large to open in memory at all, and explains plainly that true GB-scale browsing needs a streaming, OPFS-backed engine rather than pretending otherwise.
No — and for databases that matters more than for any other file type. SQLite runs as WebAssembly inside your browser; the file is opened in memory on your machine, queries execute locally, and nothing is transmitted. You can disconnect from the internet after loading the page and everything keeps working.
Yes. The visual query builder works entirely with dropdowns and checkboxes: choose a table, pick columns, add filters like status = active, sort, limit — done. The generated SQL is shown live as you click, so you learn the syntax as a side effect, and templates handle common jobs like finding duplicates with two clicks.
The viewer opens read-only by default so you can't damage anything by accident. Flip the "allow writes" switch and you can run UPDATE/INSERT/DELETE, then download the modified database as a new .db file — the original on your disk is never touched in place.
SQLCipher-encrypted databases can't be opened (the encryption isn't part of standard SQLite) — the viewer detects and says so. A -wal sidecar file next to your .db holds recent un-merged writes; if it exists, the viewer warns that the newest rows may be missing and suggests checkpointing the database first.
Yes — the ER diagram tab reads the foreign keys straight from the schema and draws an entity-relationship diagram automatically: each table is a box listing its primary- and foreign-key columns, and 1-to-many lines connect each foreign key to the table it references. You can pan and zoom it, tables with no relationships are shown detached, and a foreign key pointing at a missing table is flagged rather than hidden.
Yes. The schema-diff tab lets you drop a second .db and compares its structure against the open one: tables added or removed, and per table the columns added, removed or changed (type, nullability, primary key, default or foreign key), plus index and view differences. The second database is opened only to read its schema and is then discarded — like everything else here, neither file is uploaded.
The engine (SQLite compiled to WebAssembly) loads the whole file into memory, so a few hundred MB is comfortable on a typical machine. The warning is tiered and honest rather than a single cutoff: heavy files get a RAM note, very large ones a stronger caution, and multi-GB files are flagged as likely to fail before opening — because a single in-memory buffer can't hold them. Browsing GB-scale databases without loading everything needs an engine that reads pages on demand from an origin-private (OPFS) file, which sql.js can't do; the tool feature-detects OPFS support and says so instead of pretending. Within the in-memory limit, the grid uses virtual scrolling and paginated queries, so large tables still browse smoothly.