RxDB

What RxDB actually is

RxDB is a local-first NoSQL database that runs inside your JavaScript application — the browser, Node.js, Electron, React Native, Deno — rather than behind a network socket. That distinction matters for where it sits in our listings: we file it under database hosting because teams evaluating it are usually deciding "embedded database versus hosted database", but nothing here is hosted. You install a package, you own the data, and there is no vendor operating a cluster on your behalf.

The name stands for Reactive Database, and the reactivity is the core idea. Every query returns an RxJS observable, so subscribing to a result set gives you live updates as documents change — no polling, no cache invalidation code threaded through your UI layer. On top of that sits a replication engine with a documented protocol and ready-made plugins for CouchDB, GraphQL, Websocket, WebRTC (peer-to-peer), Supabase, Firestore, NATS and Google Drive. You can run entirely without a backend and add sync later, which is the local-first promise stated plainly.

The project is long-lived by JavaScript standards. The repository was created in December 2016 and is maintained primarily by Daniel Meyer (pubkey), with more than 15,000 commits and an Apache 2.0 license on the core. It is genuinely open source, not "open core with the useful part locked" — with one caveat we cover under pricing.

Pricing: what you really pay

The core is free at $0 forever under Apache 2.0: schemas, queries, hooks, replication, realtime sync, the default storages (Dexie, memory, LokiJS in older versions), schema validation and migration. The published constraint is a cap of up to 13 open collections in parallel, and support is community-only via GitHub and Discord.

Everything above that is a paid license, published openly on the RxDB site. Pro starts at $99 per month billed annually and adds the production storage engines — OPFS, IndexedDB, SQLite for Electron/React Native/Capacitor, filesystem storage for Node — plus WebCrypto encryption and fulltext search. Pro Plus starts at $239 per month billed annually and adds the performance plugins: worker and shared-worker storages, sharding, memory-mapped storage, a query optimizer, logger integration and the Fastify/Koa server adapters. Enterprise is custom contracts and SLA terms; there is no free trial for premium, and premium licenses are annual only, processed through a signed agreement and invoice. Payment runs through Stripe.

Our read: the pricing is transparent — every tier and price is on one page, which we value — but the jump from $0 to $99/month (annual, unlimited developers) is a cliff rather than a ramp. A solo developer who needs SQLite persistence on Electron either lives with the trial storage (documented as limited to 500 non-deleted documents, no indexes, evaluation only) or pays for Pro. There is no small paid tier in between, and the "billed annually" wording means the real commitment is roughly $1,188 up front for Pro.

Schemas are JSON Schema based, which is a deliberate compatibility choice: validation happens on write, migrations are versioned against the schema, and TypeScript types can be derived from the same definition. For teams that already describe their data with JSON Schema, that removes a whole class of drift between client and server. MongoDB-style queries cover the usual find/where/sort surface, and there is a query optimizer in the Pro Plus tier for heavier read paths. Attachments (binary blobs alongside documents) are supported and, at protocol level, can be replicated too.

Performance & infrastructure

There is no infrastructure to benchmark here in the our benchmarks sense — no VMs, no network, no datacenter. What we can assess is the storage architecture, and it is the strongest part of the project. RxDB sits on a pluggable storage interface (RxStorage), so the same application code runs on Dexie/IndexedDB, OPFS, SQLite, filesystem, memory, a web worker, FoundationDB or DenoKV by swapping a setting. For teams shipping a web app, an Electron desktop build and a React Native app from one codebase, that abstraction earns its keep.

Version 15 rewrote large parts of the storage layer: the IndexedDB storage gained write-ahead logging (roughly 4x faster writes in the project's own numbers), and the memory storage rewrite reported 3x faster writes and 2x faster find-by-id. Those are the maintainers' figures, not ours — we have not run RxDB through our own test suite — but the changelog is unusually detailed and specific, which is a better transparency signal than most projects offer. The migration plugin was also rebuilt to run through the replication protocol, so an interrupted schema migration resumes instead of restarting.

On data safety, document-level encryption ships via WebCrypto (premium), schema validation enforces JSON schemas on write, and conflict handling is explicit: revisions plus configurable conflict handlers rather than last-write-wins surprises. Replication checkpoints are migrated alongside data, and attachment replication is supported at protocol level.

Where it falls short

The free tier's 13-collection cap is the first wall, and the trial SQLite storage's 500-document limit is the second. Both are documented honestly, but they mean "evaluate freely, then pay properly" rather than "run free forever" for anything serious. The absence of a mid-tier plan pushes small commercial projects into a nine-figure-of-cents annual commitment that may not fit.

The reactive model assumes RxJS fluency. Teams without it describe a real learning curve — observables everywhere is elegant once it clicks and friction until then. The official docs are extensive and well-kept, but the ecosystem is smaller than SQLite-on-everything or Firebase-style managed backends; when you leave the documented paths you are reading source.

Then there is the bus factor. This is, in practice, a one-maintainer project with outside contributors — 15,000 commits of sustained work, but no company behind it with a support desk attached unless you buy Enterprise. For a piece of infrastructure embedded in a product's data layer, that is the risk we would want acknowledged before adoption. And "sync with any backend" means you build and operate the backend: there is no managed sync service here, so cross-device sync is your server, your conflict policy, your uptime.

The fair comparisons are PouchDB, WatermelonDB and a hosted realtime backend. Against PouchDB, RxDB offers stronger typing, modern storage targets and an actively maintained core. Against WatermelonDB, it offers cross-runtime reach beyond React Native and a documented replication protocol instead of a sync you assemble yourself. Against Firebase-style backends, you trade a managed service and an SLA for data ownership, offline behaviour you control, and no per-read billing. None of those is universally better; they answer different questions. What we like about RxDB's answer is that it never pretends to be a hosting provider — the price of that honesty is that your team operates the other half.

One more practical note on upgrades: RxDB moves quickly through major versions, and storage engines rotate in and out of support — the LokiJS storage, for instance, was removed in version 16 in favour of the memory and browser storages. Budget maintenance time for version bumps rather than assuming a write-once dependency. Read the changelog before you pin a version, and re-run your own load tests on each major release, because storage behaviour changes underneath the API.

Who should pick this

Our pick for offline-capable applications where the UI must react instantly to local data: field-service tools, note-taking and productivity apps, point-of-sale terminals, Electron desktop software, and PWAs that must work through connectivity gaps. If your product requirement list includes "works offline" and "updates the UI the moment data changes", RxDB is purpose-built and the replication protocol means you are not locked in — point it at CouchDB, your own HTTP endpoint, or a peer mesh.

We would not pick it for data that must live in one authoritative server-side store with SQL reporting, for teams allergic to RxJS, or for organizations that need a vendor contract and an SLA before adopting a dependency. In those cases a managed Postgres or a hosted realtime database is the more honest fit, whatever the feature matrix says.

Key takeaways

• Local-first embedded NoSQL for JavaScript with observable queries; it runs in the browser, Node, Electron and React Native — no hosted service involved.
• Apache 2.0 core at $0 forever, capped at 13 open collections; Pro from $99/month and Pro Plus from $239/month, both billed annually with no free trial.
• Pluggable storage (IndexedDB, OPFS, SQLite, filesystem, memory, FoundationDB, DenoKV) keeps one codebase across runtimes.
• Replication plugins for CouchDB, GraphQL, Websocket, WebRTC, Supabase, Firestore and NATS; you own and operate the sync backend.
• Mature project (repository since December 2016, 15,000+ commits) but effectively one primary maintainer — plan for that dependency risk.
• Best fit is offline-first, UI-reactive apps; server-authoritative SQL workloads belong elsewhere.

Sources

• https://rxdb.info/premium/
• https://github.com/pubkey/rxdb
• https://rxdb.info/rx-storage-sqlite.html
• https://rxdb.info/releases/15.0.0.html
• https://rxdb.info/articles/alternatives/lokijs-alternative.html
• https://github.com/sarvex/rxdb