JayDB

JayDB is a JSON document database with per-user sign-in, intended to let static apps store user, session, or tenant data without an app-owned backend. Documents sit at slash-separated paths, and the first write creates the namespace. Its REST HTTP data plane supports GET, PUT, DELETE, and prefix listing. Browser apps can authenticate with OIDC using Authorization Code with PKCE, without including a client secret. Listed identity providers include Google, GitHub, Microsoft, generic OIDC, and custom OAuth2; the zero-dependency @jaydb/cloud SDK supports authentication, token refresh, typed document access, and compare-and-swap operations. ETag-based compare-and-swap can reject a write with HTTP 412 if a document changed since it was read. JayDB offers managed cloud service and a self-hostable Go engine under the MIT license, using S3-compatible or local storage options. The free plan includes 1 GB stored, 100,000 reads and 10,000 writes monthly, with a hard stop at those limits. Metered rates include $0.05 per GB-month of storage, $0.20 per million reads, and $0.50 per million writes.

JayDB offers a focused document store with per-user authentication, REST access, and managed or self-hosted deployment. Its free allowances and lack of query and multi-document transaction features are important constraints to weigh.

JayDB is presented for AI-built apps and projects that need user-, session-, or tenant-linked documents shared among multiple users or workers. It may suit developers who want managed or self-hosted deployment and can work within its listed database limits.

JayDB is a document database that pairs per-user sign-in with REST access for apps that need storage without an app-owned backend. It fits best when an app reads and updates individual user, session, or tenant documents through known paths. Its free allowance and self-hosted engine are useful entry points, but the narrow query model puts a firm boundary around the workloads it can handle.

Overview

Documents live at slash-separated paths, and the first write creates the namespace automatically. That keeps setup light for apps with predictable data access. Documents can be stored as JSON, MsgPack, or raw data, up to 5 MB each.

JayDB does not provide secondary indexes, joins, foreign-key constraints, full-text search, aggregation, vector search, or transactions across multiple documents. Apps that need flexible search, linked records, or all-or-nothing updates across documents should choose a database with those capabilities.

Key features

REST access and concurrency

The data plane supports GET, PUT, DELETE, and prefix listing over standard REST HTTP. ETag-based compare-and-swap lets a client reject a write with HTTP 412 if the document changed after it was read. This helps prevent silent overwrites on shared documents, though it does not provide multi-document consistency. A heavily written hot key can also trigger enough retries to pile up.

Authentication and SDK

Each tenant gets an OIDC issuer. Browser apps can use Authorization Code with PKCE, so they do not need to ship a client secret. Google, GitHub, Microsoft, generic OIDC, and custom OAuth2 providers are supported. The zero-dependency @jaydb/cloud SDK handles authentication, token refresh, typed document access, and compare-and-swap operations, giving JavaScript apps a more complete starting point than the raw HTTP interface alone.

Managed storage and self-hosting

The managed engine uses AWS S3 or compatible storage, including Cloudflare R2, MinIO, and Wasabi. The Go engine is MIT-licensed and can run embedded or as a standalone server, with those storage options plus local disk. That gives teams control over deployment, but self-hosting means operating the database and its storage themselves.

Pricing

The free plan costs nothing, billed every month forever. It includes 1 GB of storage, 100,000 reads per month, and 10,000 writes per month; usage stops when an allowance is reached. There is no free trial. This is enough room to begin a small project, but the hard stops make it a poor choice for an app that must continue serving requests after its monthly quota runs out.

Paid usage is metered at $0.05 per GB-month stored, $0.20 per million reads, and $0.50 per million writes. Deletes are free, and egress has no per-GB line item under fair use. The published starting price is $0.05/mo, but the total depends on storage and request volume, so high write traffic or a growing data set can change the bill.

Two one-time prepaid packs reduce the effective usage cost: the $5 prepaid pack costs $5, paid once and prepays $6.50 of metered usage, a 1.3× discount; the $10 prepaid pack costs $10, paid once and prepays $15, a 1.5× discount. Both use the same metered rates. These packs suit users who want a finite usage balance; they do not change the product’s quotas or data model.

Platforms

JayDB supports Android, iOS, web, Linux, macOS, and Windows, alongside API access and self-hosted deployment. That range suits client apps that can use its HTTP API as well as teams choosing to run the Go engine themselves.

Who it's for

JayDB is a sensible fit for static or AI-built apps that need user-specific storage without a separate app-owned backend, and for shared documents tied to users, sessions, or tenants. Its path-based access and per-document concurrency control work best when the application already knows which document it needs. Choose another database if the core workload depends on querying across records, search, vector retrieval, or atomic changes to several documents.

Pros and cons

• Per-tenant OIDC and PKCE: browser apps can authenticate without embedding a client secret, with several common identity providers supported.
• Standard REST operations and compare-and-swap: clients can work over HTTP and detect document changes before overwriting shared data.
• Managed or self-hosted deployment: teams can use S3-compatible storage or run the MIT-licensed Go engine, including with local disk.
• Hard free-plan caps: hitting a monthly storage or request allowance stops usage, which limits the plan for services that must stay available as they grow.
• No query and transaction features: missing indexes, search, joins, aggregation, and multi-document transactions rule out workloads that rely on those operations.
• Hot-key contention: sustained concurrent writes to one document can lead to accumulating retries.

Alternatives

• Document Databases is the broader category to browse when JayDB’s path-based, document-level model does not match the workload.
• Firestore is another freemium option with a free trial and Android, iOS, web, and API support; consider it when those platform and trial terms better suit your project.
• restdb.io offers a free Development plan with 3 devs, editors, or users, 2,500 records, and capped API calls; it may fit a small team that wants those explicit development allowances.
• JasDB is a free option with Linux, macOS, Windows, API, and self-hosted support; consider it if that platform range is the deciding factor.
• LiteDB is free for everyone, including commercial use, and supports API and self-hosted deployment; choose it when those terms matter more than JayDB’s per-user authentication model.
• PouchDB is free and open source, with web and self-hosted support; it is an alternative for readers prioritizing those terms.
• Couchbase Lite is a paid alternative whose listed Couchbase Mobile plan includes SQL++, full-text and vector search, and peer-to-peer syncing; consider it when those capabilities are required.
• Azure Cosmos DB for NoSQL has a free tier with 1,000 RU/s and 25 GB of storage, plus a free trial; consider it when those stated allowances are a better fit.
• MarkLogic offers a free Developer plan for noncommercial use with up to 1 TB of data; consider it for that use case.

Verdict

Choose JayDB for an app that needs straightforward per-user document storage, browser-friendly authentication, and a choice between managed and self-hosted deployment. Its REST API and compare-and-swap support make the focused model practical for individual documents. Look elsewhere when the app needs query flexibility, search, or transactions across multiple documents, or when hard monthly free-plan caps are unacceptable.