MongoDB & DocumentDB · macOS, Windows, Linux

Fathom your data.

A desktop browser for MongoDB and Amazon DocumentDB — full CRUD, real query power, one window.

Browse every collection and read each BSON type as it really is, run mongo-shell queries with Explain and export-to-language, and reach a DocumentDB cluster straight through your SSH bastion — the parts other clients leave hard.

Download

Free · No account · Local-first

FathomDB's connection overview for a local MongoDB server (7.0.40): six databases shown as cards — shop, analytics, fathom_demo and the system databases — each with its collection count, document count, data size and index count, and a per-collection list with document counts.

Every document, as it really is.

A document isn't a blob of text. FathomDB reads it as BSON and shows you the types — an ObjectId is an ObjectId, a Decimal128 keeps its precision, a date is a date — so what you see on screen is what the database actually holds.

Type-aware, three ways to look

List, raw JSON, or a flattened table — the same documents, however you need to read them.

  • Real BSON types — ObjectId, Decimal128, Date, Binary, arrays, nested docs, each labelled
  • List · JSON · Table views, expandable arrays and subdocuments
  • Insert, edit, duplicate, delete — Extended JSON in, Extended JSON out
FathomDB browsing the shop.orders collection in List view: each order shows its _id as an ObjectId, orderNo, userId reference, status, a nested items array, and subtotal / shipping / total as Decimal128, with a type badge on every field.

Open a document in full

Click any row to read the whole document, then edit it in place — nothing truncated, nothing guessed.

  • Full Extended JSON with nested arrays and objects expanded
  • Edit and save a single document without leaving the view
  • Copy it out as canonical EJSON, ready to paste anywhere
FathomDB's document detail modal open on a single order, showing the full document as Extended JSON including the nested items array with productId, sku, name, qty and unitPrice for each line.

Amazon DocumentDB, without the fight.

A DocumentDB cluster lives in a private VPC, speaks TLS with Amazon's CA, and rejects retryWrites. FathomDB handles all of it as a connection mode — and tunnels in through the same bastion you already SSH to, resolving the alias straight from your ~/.ssh/config.

New connection · DocumentDB 
# Paste the cluster URI — FathomDB sets the rest.
mongodb://admin@docdb-prod.cluster-xxxx.us-west-2.docdb.amazonaws.com:27017

tls            on  · Amazon RDS CA bundle, embedded
retryWrites    off · DocumentDB doesn't allow it
ssh bastion    gbanker · resolved from ~/.ssh/config

*   tunnelling 127.0.0.1:27017 → cluster:27017
*   connected · DocumentDB 5.0 · 4 databases

  • TLS & the CA, already bundled

    The Amazon RDS combined CA ships inside the app, so a DocumentDB connection is tls: true and nothing else — no downloading a .pem, no wiring a path.

  • Through your bastion, by alias

    Type a host alias and FathomDB reads your SSH config for the user, key and jump — opens a local forward and points the driver at it. Leave the other fields blank.

  • The same app, either engine

    Browse, query, aggregate and index a DocumentDB cluster with the exact UI you use for MongoDB. retryWrites and the replica-set quirks are handled for you.

FathomDB's welcome screen: saved connections shown as one-click cards — a local MongoDB with a green Mongo pill and a production Amazon DocumentDB with a purple DocDB pill — beside the headline 'Take a sounding of your data.'
Both engines sit side by side in the sidebar — a green Mongo pill, a purple DocDB pill — and open into the same workspace. Connect read-only and browse anything; flip one switch when you mean to write.

Query in the shell you already speak.

Filters are mongo-shell syntax, not a form — unquoted keys, ObjectId(), regexes, the lot. Then see the plan the server actually ran, and lift the whole query out as code in the language you need.

Explain · the real plan
FathomDB's Explain modal for the filter { status: 'shipped' } on shop.orders: an index scan using status_1, with documents returned, documents and keys examined, execution time, and the full queryPlanner JSON.
The filter { status: "shipped" } ran as an index scan on status_1 — documents returned and examined, keys examined and execution time, with the full queryPlanner underneath. The difference between a fast query and a slow one, in plain sight.

  • mongo-shell filters

    Type { status: "shipped" } or a full find with projection, sort, collation, maxTimeMS and hint. Save the ones you reuse; the last runs stay in history.

  • Explain, without ceremony

    One click turns any filter into its execution plan — which index answered it, how many documents it had to look at, how long it took.

  • Export to nine languages

    Turn the query into mongosh, Node, Python, Java, C#, Go, Ruby, PHP or Rust — ready to paste into the code that will run it for real.

FathomDB's export-query-to-language modal with Python selected, showing generated pymongo code for a find with the shipped-orders filter, and a row of language chips: mongosh, Node, Python, Java, C#, Go, Ruby, PHP, Rust.
FathomDB running the filter { status: 'shipped' } against shop.orders and showing the 57 matching shipped orders in the document list.

Aggregations, indexes, schema, validation.

A collection is more than its documents. Build a pipeline and see the output, list and reason about the indexes, learn the shape of the data, and read the validation rules — each a tab away, not a second tool.

Aggregation pipelines

Write a pipeline on the left, read the results on the right — stages formatted, output live.

  • $group, $match, $sort and the rest, with the output beside the stages
  • Revenue per status in a few lines — real numbers, not a mock
FathomDB's Aggregations tab: a multi-stage pipeline grouping shop.orders by status and summing the total on the left, and the grouped results — count and revenue per status — on the right.

Indexes & validation

Every index laid out, and the collection's JSON-schema rules where you can actually read them.

  • Index list — keys, direction, unique flags, at a glance
  • $jsonSchema validators — required fields, types, enums, level and action
  • Schema view — inferred field types with their distribution
FathomDB's Validation tab on shop.products showing the collection's $jsonSchema: required fields, property bsonTypes, a category enum, with validation level moderate and action warn.

  • Indexes, listed

    Every index on the collection — _id_, compound keys, unique constraints — with the keys and their direction.

  • Schema, inferred

    Sample the collection and see each field's types and how often they appear — the real shape, mixed types and nulls included.

  • Validation, editable

    Read the $jsonSchema the collection enforces, and change the rules with collMod — gated behind write mode.

Read-only until you mean it.

A production browser you can't accidentally write to. FathomDB opens read-only — browse, query, aggregate and explain anything — and every write is refused until you flip the switch in the title bar. It's enforced in the main process, not just hidden in the UI.

  • Off by default

    Launch, connect, explore — nothing you do can change a document until you choose to. The safe state is the one you start in.

  • Enforced where it counts

    The toggle gates writes in the process that holds the driver, so a disabled button is backed by a real refusal — not a hope that you didn't find another way.

  • Local-first, no account

    Your connections live in a file on your disk. No sign-in, no sync, no cloud in the path between you and your database.

Take a sounding of the deep end.

MongoDB and Amazon DocumentDB, browsed properly. Free, no account, on every desktop.

Download

macOS, Windows & Linux on the download page. Opens read-only — flip one switch to write.