AxioDB is an embedded NoSQL database for Node.js with MongoDB-style queries. It is a pure JavaScript alternative to SQLite with zero native dependencies, no node-gyp compilation, and no platform-specific binaries. Install with 'npm install axiodb' and you have a database — no mongod process, no server setup. Perfect for Electron apps, CLI tools, and local-first applications.

Is AxioDB a replacement for MongoDB?

No. AxioDB is embedded — it runs inside your app with no server. MongoDB is a client-server database for multi-user production systems. Use AxioDB for desktop apps, CLI tools, and local-first applications with 10K–500K documents. Use MongoDB when you need a shared, networked, multi-user database.

Does AxioDB work with Electron?

Yes — Electron is the primary use case AxioDB was built for. Zero native dependencies means no electron-rebuild, no platform-specific .node files, no node-gyp compilation. Just npm install axiodb and it works on Windows, Mac, and Linux without any rebuild step.

What is the difference between AxioDB and better-sqlite3?

better-sqlite3 uses C native bindings and requires compilation via node-gyp. AxioDB is pure JavaScript — it installs in any Node.js environment without compilation or platform-specific builds. AxioDB also uses NoSQL/JSON document queries instead of SQL strings, includes built-in caching and Worker Threads, and works out of the box in Electron without electron-rebuild.

What is the difference between AxioDB and lowdb?

lowdb stores everything in a single JSON file and becomes slow above 1,000–5,000 records due to full-file reads on every operation. AxioDB uses file-per-document tree storage with InMemoryCache, Worker Threads, and auto-indexing — optimized for 10,000–500,000 documents with O(1) lookups by ID and fast filtered queries.

What is the difference between AxioDB and nedb?

NeDB is abandoned (no active maintenance since 2016) and keeps the entire database in memory. AxioDB is actively maintained, uses file-based storage, supports TypeScript, ACID transactions with savepoints and WAL, Worker Threads, custom field indexing, and AxioDBCloud remote access.

Should I switch from LowDB to AxioDB?

Yes, if your project has grown beyond prototypes. LowDB has no concurrency safety (concurrent writes corrupt data), no ACID transactions (crash = data loss), no built-in caching, and the entire database is loaded into memory. AxioDB provides file-per-document storage, ACID transactions, InMemoryCache, Worker Threads, and is actively maintained.

Is NeDB still safe to use?

No. NeDB has been abandoned since 2016 with no security patches or bug fixes. Users report data loss and file corruption. For new projects, use AxioDB which provides the same MongoDB-like API with active maintenance, ACID transactions, TypeScript support, and modern features like Worker Threads and built-in GUI.

Why not use better-sqlite3 for Electron apps?

better-sqlite3 requires native C compilation via node-gyp and electron-rebuild for every Electron update. This causes platform-specific build failures and NODE_MODULE_VERSION mismatch errors. AxioDB is pure JavaScript — zero native dependencies means no compilation, no electron-rebuild, and no platform-specific binaries. Install with npm install axiodb and it works everywhere.

What is the best embedded database for Electron apps in 2026?

AxioDB is the best choice for Electron apps in 2026. It has zero native dependencies (no electron-rebuild), ACID transactions, built-in InMemoryCache, Worker Threads for multi-core processing, a built-in web GUI dashboard, and TypeScript support. It handles 10K-500K documents with O(1) lookups by ID and fast indexed queries.

How many documents can AxioDB handle?

AxioDB is optimized for 10,000–500,000 documents per collection. For 1M+ documents, migrate to PostgreSQL or MongoDB. AxioDB's InMemoryCache and Worker Threads keep performance fast within this range — documentId lookups take ~1ms and indexed queries take ~2ms even at 100,000 documents.

Does AxioDB support TypeScript?

Yes. Full TypeScript type definitions are included out of the box with the axiodb npm package. No @types/axiodb needed.

Does AxioDB work in the browser?

No. AxioDB requires Node.js (v20+) and uses the filesystem for storage. It is a server-side and desktop embedded database. It does not run in browsers.

AxioDBCloud is AxioDB's own TCP remote-access layer on port 27019 — a protocol and client, not a hosted service. You run the server yourself with new AxioDB({ TCP: true }) or the Docker image, then connect from other processes using the exact same API as embedded AxioDB, with zero code changes. There is no account to create and Nexoral hosts no database for you. Limits: 1,000 total concurrent connections, 100 per IP. Optional shared-RBAC authentication (TCPAuth) and optional TLS.

How do I replace SQLite with AxioDB in a Node.js project?

Install with 'npm install axiodb' and map concepts directly: a SQLite table becomes a collection, a row becomes a JSON document, INTEGER PRIMARY KEY becomes the auto-generated documentId, CREATE INDEX becomes collection.newIndex('field'), and BEGIN/COMMIT/ROLLBACK become collection.beginTransaction()/.commit()/.rollback(). SQL strings become JavaScript objects: SELECT * FROM users WHERE age > 25 becomes users.query({ age: { $gt: 25 } }).exec(). There are no schemas and no migrations. What you give up: JOINs, foreign keys, SQL itself, ORMs like Prisma and Drizzle, and scale beyond roughly 500,000 documents per collection.

Does AxioDB need node-gyp, electron-rebuild, or a build step?

No. AxioDB is pure JavaScript with zero native dependencies — there is no C code, no .node binary, no node-gyp compilation, and no electron-rebuild step. Nothing has to match your OS, CPU architecture, or Node/Electron ABI version, so NODE_MODULE_VERSION mismatch errors are impossible. 'npm install axiodb' is the entire installation on every platform and every Node.js version 20 or newer.

How do I use AxioDB in an Electron app?

Create the AxioDB instance in Electron's main process only, storing data in the per-user data directory: new AxioDB({ RootName: 'AppData', CustomPath: app.getPath('userData'), GUI: false }). Never write inside the app bundle or app.asar — asar is read-only and app contents are replaced on update. Expose database operations to the renderer through ipcMain.handle plus contextBridge rather than enabling nodeIntegration. No electron-rebuild step and no packaging configuration for native modules is required.

Does AxioDB have an MCP server for AI agents?

Yes — 43 MCP tools covering databases, collections, documents, aggregation, indexes, dashboard stats, user/role management, and transactions. Important: the MCP server ships only in the Docker image theankansaha/axiodb, not in the npm package. Enable it with AXIODB_MCP=true and connect over Streamable HTTP at http://localhost:27020/mcp. Every tool except axiodb_login requires a sessionId from logging in, and destructive tools ask the human for confirmation through the MCP client first.

What ports does AxioDB use?

Port 27018 is the web Dashboard and its REST HTTP API, enabled with GUI: true. Port 27019 is the AxioDBCloud TCP server, enabled with TCP: true — it is a custom TCP protocol, not HTTP. Port 27020 is the MCP server, available only in the Docker image with AXIODB_MCP=true. Ports 27018 and 27019 are not configurable in code; remap them at the Docker layer. Only the MCP port can be changed, via AXIODB_MCP_PORT. By default the embedded library opens no ports at all.

Does AxioDB support MongoDB update operators like $inc and $set?

No. AxioDB updates are a flat shallow merge of your data object onto the existing document. Writing .UpdateOne({ $inc: { balance: -100 } }) does not increment anything — it literally stores a field named '$inc'. To change a numeric value, read the document, compute the new value in JavaScript, and write it back. Query operators are a separate thing and are fully supported: $gt, $gte, $lt, $lte, $eq, $ne, $in, $nin, $exists, $regex, $not, $type, $size, $all, $elemMatch, $or, $and, and $nor.

What are AxioDB's limitations?

AxioDB targets 10,000 to 500,000 documents per collection on a single node. It has no JOINs, no foreign keys, no SQL, no replication, no sharding, and no clustering. Transactions are scoped to one collection — there are no cross-collection transactions. Only one AxioDB instance may exist per process. Aggregation supports only $sum and $avg accumulators, and its $match stage accepts fewer operators than query() does. Queries that are not an exact match on an indexed field fall back to a full collection scan. It does not run in browsers.

Production Ready•Developer Friendly

👋Hello, Developer!Welcome to AxioDB

AxioDB

The Embedded Database for Node.js

Replaces SQLite, LowDB, NeDB & raw JSON files with a real database. MongoDB-style queries, ACID transactions, zero native dependencies. No more node-gyp failures. No more electron-rebuild. Just npm install. Runs on Node.js 20+ and Bun— one codebase, same data files, no runtime lock-in.

Runs on

Node.js ≥ v20 · officially supported

Bun verified on v1.4.0

Verified test cases:CRUD (insert / find / update / delete)Indexed queriesACID transactionsAggregationWorker threads — ≥100 filesWorker threads — ≥10,000 docs

All 12 engine test suites — CRUD, transactions, reads, indexed queries & searches, auth, TCP/TLS, HTTP API, and crash recovery — pass on the machine's Node (v26.8.1) and Bun (v1.4.0), including the worker-thread data paths (reads of ≥100-file collections, searches over ≥10,000 documents). Node 20+ is the supported baseline; Bun is verified on the installed v1.4.0 only. Deno passes 9/12 — worker threads are pending there.

AI SKILLUse AxioDB with Any AI Agent

Load the AxioDB Agent Skill into ChatGPT, Claude, Cursor, Copilot, or any AI coding assistant to get expert guidance on queries, schema design, transactions, and best practices.

Paste into any AI chat

NEWAxioDB MCP Server

Spin up AxioDB on a cloud container and let your AI agent (Claude, or any MCP-compatible client) talk to that database directly — 43 tools, real login, the exact same RBAC as the web GUI.

NEWAxioDB CLI

CLI tool for AxioDB — interactive REPL with MongoDB shell syntax, all 32 TCP commands, TLS support, and installers for 12 platforms.

NEWAxioDB Desktop GUI

Native desktop app (Electron) with a card-based document viewer, bouncy-ball splash loader, connection management, and all-in-one database tooling for Linux, macOS, and Windows.

Linux · macOS · Windows

ACID Compliant✓ Transactions

Full Transaction Support with Commit, Rollback & Write-Ahead Logging Recovery

Performance Benchmark|Tested: September 2026

AMD Ryzen 5 5500U (6C/12T)•7.1 GB RAM•Ubuntu Linux 6.8.0•Node.js v26.8.1•100,000 documents dataset

Insert Operations

~31ms

Insert Single

~365ms

InsertMany (500)

<1ms

Validation

Read/Query Operations (100K docs)

~1ms

Indexed

~1ms

documentId

<1ms

findOne

~1.1s

$gt

~533ms

$in (5)

~2.0s

Regex

Update Operations

~35ms

UpdateOne

~326ms

UpdateMany

~2ms

Verify

Delete Operations

~28ms

DeleteOne

~144ms

DeleteMany

~53ms

Verify

Transaction Operations

~38ms

TX Insert

~32ms

TX Update

~44ms

TX Delete

~46ms

TX Mixed

~8ms

Rollback

~24ms

Savepoint

~21ms

withTX

~20ms

Index Sync

Test Suite Overview (100K docs - 13/13 Passing)

CRUD

3.7 s

30 tests

Transactions

625 ms

22 tests

Read / Query

146.8 s

40 tests

Aggregation

458 ms

50 tests

Auth & RBAC

6.0 s

32 tests

HTTP API

1.5 s

38 tests

TCP Auth

2.7 s

20 tests

TCP No-Auth

627 ms

6 tests

TCP TX

1.4 s

17 tests

TCP TLS

641 ms

3 tests

Crash Recovery

5.7 s

3 tests

MCP Confirm

40 ms

11 tests

MCP Functional

1.7 s

6 tests

View full performance report

terminal

$ npm install axiodb

+ axiodb@latest # No native dependencies, no compilation

$ node app.js

✓ AxioDB initialized

✓ Database ready at ./AxioDB

✓ GUI available on localhost:27018

💡 Think SQLite, but NoSQL with JavaScript queries

🎯 Perfect for: Desktop apps • CLI tools • Node.js backends

$Your embedded database is ready...|

🚀 Quick StartGet running in 30 seconds

Hello World with AxioDB

ℹ️Node.js & Bun supported:AxioDB runs on Node.js ≥20 or Bun (v1.4.0) servers, not in browsers

javascript

1// npm install axiodb
2const { AxioDB } = require('axiodb');
3
4// Create AxioDB instance with built-in GUI
5const db = new AxioDB({ GUI: true }); // Enable GUI at localhost:27018
6
7// Create database and collection
8const myDB = await db.createDB('HelloWorldDB');
9const collection = await myDB.createCollection('greetings');
10
11// Insert and retrieve data - Hello World!
12await collection.insert({ message: 'Hello, Developer!' });
13const result = await collection.query({}).exec();
14console.log(result.data.documents[0].message); // Hello, Developer!

Install Now View Examples

NEW FEATURE

Introducing AxioDBCloud

Deploy AxioDB in Docker or Cloud. Connect from anywhere with TCP protocol. Same API, zero code changes!

Fast TCP Protocol

1000+ Connections

Auto-Reconnect

Explore AxioDBCloud Docker Setup

Built-in GUI

Database Visualization Built In

Start AxioDB with new AxioDB({ GUI: true }) to enable the built-in web GUI on localhost:27018. Perfect for Electron apps—give your users a database inspector without extra dependencies.

View GUI Documentation

📖Our Story

Born from SQLite Pain. Built to Be Better.

It started with a simple error: node-gyp ERR! — again.

We were building an Electron app. Needed a database. Tried better-sqlite3 — node-gyp compilation failed. Tried LowDB — data corrupted on concurrent writes. Tried NeDB — abandoned since 2016.

So we built AxioDB.

✓

Zero native dependencies

No node-gyp, no electron-rebuild, no platform headaches

✓

ACID transactions

Crash recovery, savepoints, write-ahead logging

✓

MongoDB-style queries

JavaScript objects, not SQL strings

✓

Built-in caching & GUI

InMemoryCache + web dashboard included

🤔

Still Using LowDB, NeDB, or better-sqlite3?

Here's what developers actually deal with every day:

📄LowDB

Stale

22.6k GitHub stars

✗No concurrency — concurrent writes corrupt data
✗No ACID transactions — crash = data loss
✗No built-in caching — full file rewrite every time
✗Single JSON file — entire DB loaded into memory
✗Last updated 3 years ago

💀NeDB

ABANDONED

13.5k GitHub stars

✗No longer maintained since 2016
✗Data loss issues reported by users
✗File corruption on concurrent access
✗No TypeScript support
✗Security vulnerabilities unpatched

🔧better-sqlite3

Active (but painful)

11k+ GitHub stars

✗Requires native C bindings compilation
✗node-gyp headaches on every platform
✗electron-rebuild required for Electron apps
✗SQL strings instead of JavaScript objects
✗Platform-specific builds (Windows ≠ Mac)

AxioDB solves all of these problems:

✓ ACID Transactions✓ Zero Native Deps✓ Active Maintenance✓ InMemoryCache✓ TypeScript 6.0✓ Built-in GUI

See Full Comparison

Why AxioDB?

SQLite requires native C bindings that cause deployment headaches. JSON files have no querying or caching. MongoDB needs a separate server. AxioDB combines the best of all: embedded like SQLite, NoSQL queries like MongoDB, intelligent caching built-in.

Pure JavaScript

Zero native dependencies. No compilation, no platform-specific binaries, no node-gyp headaches. Works everywhere Node.js runs.

Intelligent Caching

Built-in InMemoryCache with automatic invalidation. Instant query results for frequently-accessed data. Multi-core parallelism with Worker Threads.

MongoDB-Style Queries

JavaScript objects, not SQL strings. Operators like $gt, $regex, aggregation pipelines, schema-less documents.

Node.js Applications

Embedded database for Node.js apps requiring local storage. No external dependencies, no server setup, no compilation. Works on all platforms without native bindings.

Desktop & CLI Tools

Perfect for desktop apps (Electron, Tauri) and CLI tools. Store configuration, cache data, manage local state—all with npm install.

Rapid Prototyping

Skip database setup entirely. Query with JavaScript objects, not SQL strings. Handles 10K-500K documents with intelligent caching. Migrate to PostgreSQL or MongoDB when you scale.

Embedded Systems

Local-first applications, IoT devices, edge computing. Single-instance architecture with file-based storage. Built-in GUI for data inspection during development.

AxioDB is not competing with PostgreSQL or MongoDB. It's for when you need a database embedded in your app—Electron, CLI tools, local-first apps. Sweet spot: 10K-500K documents. No native dependencies, no server setup.

Honest positioning

The Problem With the Usual Options

SQLite:

✗ Requires native C bindings (better-sqlite3, node-sqlite3)
✗ electron-rebuild on every Electron update, platform-specific compilation
✗ SQL strings instead of JavaScript objects
✗ Schema migrations when your data model changes

JSON Files:

✗ Full file read/write for every operation
✗ No built-in querying, indexing, or caching
✗ Linear O(n) search performance

MongoDB (Server):

✗ Requires a separate server process
✗ Overkill for small-to-medium, single-app datasets
✗ Not suitable for embedded/desktop scenarios

AxioDB is pure JavaScript, embedded, with MongoDB-style queries built in:

✓Works everywhere Node.js runs—no rebuild, no native dependencies
✓MongoDB-style queries: {age: {$gt: 25}}
✓Schema-less JSON documents—no migrations

See the full feature-by-feature comparison against SQLite, JSON files, lowdb, nedb, and better-sqlite3.