AxioDB is an embedded NoSQL database for Node.js with advanced 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 official Desktop 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 standalone desktop GUI, 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') }). 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 — 45 MCP tools covering databases, collections, documents, aggregation, indexes, dashboard stats, user/role management, and transactions. The MCP server can be initiated directly in TypeScript/JavaScript via new AxioDB({ MCP: true }) or in Docker with AXIODB_MCP=true, exposing 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 REST HTTP API, enabled with HTTP: 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, enabled in core with MCP: true or in Docker 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.

Hello, Developer! Welcome to AxioDB

Embedded NoSQL Database
for TypeScript & AI Agents

A fast, zero-setup embedded database for when you need reliable storage without running a separate server. Built for TypeScript apps and AI agents to safely persist and query dynamic JSON state. Just npm install axiodb and start querying with pure JavaScript objects.

Get AxioDB See the scopewhen another database fits better

javascript

1// npm install axiodb
2const { AxioDB } = require('axiodb');
3
4// Create AxioDB instance (embedded mode)
5const db = new AxioDB();
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!

Runs on

Node.js ≥ v22 · officially supported

Bun officially supported

Deno officially supported

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

All 14 test suites — CRUD, transactions, reads, aggregation, auth, HTTP API, TCP (auth/no-auth/transaction/TLS), crash recovery, MCP, and cache options — pass across Node.js, Bun, and Deno, including the worker-thread data paths (reads of ≥100-file collections, searches over ≥10,000 documents). Node.js ≥ 22, Bun, and Deno are officially supported runtimes.

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

Native Model Context Protocol (MCP) server built directly into AxioDB core — 45 tools on port 27020 for AI agents (Claude Code, Cursor, Windsurf, Codex, Antigravity). Start directly in TypeScript with new AxioDB({ MCP: true }) or run in Docker.

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

NEWAxioDB Agent Skill Package

Progressive-disclosure skill package for AI coding agents — 100% verified query syntax, zero context bloat, and automated operational scripts.

$npx skills add nexoral/AxioDB --skill skill

Verified Performance100K Docs

Sub-millisecond indexed reads (<1ms), ~31ms single inserts, and ACID transactions verified across 14/14 automated test suites.

View full performance report

terminal

$ npm install axiodb

+ axiodb@latest # No native dependencies, no compilation

# Or in Deno (zero-install via URL):

import { AxioDB } from 'https://esm.sh/axiodb';

$ node app.js

✓ AxioDB initialized

✓ Database ready at ./AxioDB

✓ GUI available on localhost:27018

💡 Think SQLite, but pure TypeScript NoSQL with rich queries

🎯 Perfect for: AI Agents • TypeScript Apps • Desktop & CLI Tools • Local-First Systems

$Your embedded database is ready...|

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

Official Desktop GUI

Database Visualization Built In

Manage your databases visually with our standalone Desktop GUI app (AxioDB Control). Connect over TCP or start the HTTP API with new AxioDB({ HTTP: true }) on localhost:27018.

Install Desktop GUI

📖Our Story

Born from Embedded Database Pain. Built for Modern TypeScript & AI Agents.

It started with a recurring headache: node-gyp ERR! — followed by rigid SQL migrations for dynamic JSON and corrupted state under concurrency.

Whether persisting state for autonomous AI agents, building cross-platform desktop applications, or shipping zero-config CLI tools, developers were trapped: Tried better-sqlite3 — native C++ compilation errors and rigid table schemas for nested JSON. Tried LowDB — corrupted files on concurrent writes with zero ACID safety. Tried NeDB — abandoned since 2016 with unpatched CVEs and no TypeScript.

So we built AxioDB — an embedded document database designed for modern JavaScript runtimes and AI workflows.

✓

Zero native dependencies

Pure JS/TS. No node-gyp, no Python/C++ build tools, verified on Node.js & Bun

✓

ACID transactions & WAL

Write-ahead logging, savepoints, atomic commits, and automatic crash recovery

✓

Native JSON for AI & Modern Apps

Dynamic document store with MongoDB-style operators ($gt, $regex, $in) and deep queries

✓

Dual-Write In-Memory Cache & Desktop GUI

InMemoryCache with TTL jitter, Worker Threads, and official Desktop GUI

🤔

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 or crash recovery = data loss
✗No built-in caching — full file rewrite on every mutation
✗Single JSON file — entire DB loaded into memory
✗No indexing or query operators ($gt, $regex, $in)

💀NeDB

ABANDONED

13.5k GitHub stars

✗No longer maintained since 2016 with unpatched CVEs
✗File corruption on concurrent agent or process access
✗No TypeScript types or modern ESM/CJS exports
✗No ACID guarantees, savepoints, or crash recovery
✗Fails on modern Node.js and Bun runtimes

🔧better-sqlite3

Active (but painful)

11k+ GitHub stars

✗Requires native C++ bindings compilation (node-gyp)
✗Fragile across multi-platform Docker & CI/CD builds
✗Rigid tables — painful schema migrations for dynamic JSON
✗SQL string queries instead of native JavaScript objects
✗Platform-specific binaries (Windows ≠ macOS ≠ Linux)

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 break in cross-platform deployments. Flat JSON files lack ACID transactions, indexing, and concurrency. MongoDB requires running a heavy external server daemon. AxioDB unifies the best of all: embedded zero-setup like SQLite, native document queries like MongoDB, in-memory caching built-in, and true ACID crash resilience.

Pure TypeScript & Zero Native Deps

Zero native C++ bindings, zero compilation, and no node-gyp headaches. Verified across Node.js and Bun with zero external binaries.

Dual-Write In-Memory Cache

Built-in InMemoryCache with randomized TTL jitter and dual-write index synchronization. Sub-millisecond reads for hot documents and multi-core Worker Thread parallelization.

Native JSON & Rich Queries

Manipulate JavaScript objects directly instead of writing SQL strings. Operators like $gt, $regex, aggregation pipelines, and schema-less documents for dynamic agent state.

ACID Transactions & WAL

Commit, rollback, and savepoints backed by a write-ahead log (WAL) with automatic startup crash recovery — enterprise reliability built in from day one.

AI Agents & State Persistence

Persist conversation logs, tool execution traces, in-flight agent state, and structured task queues locally without spinning up a cloud database or wrestling with SQL migrations.

TypeScript & Node.js Apps

Zero native dependencies, no server setup, no compilation. Verified across Node.js and Bun without native bindings or node-gyp headaches.

Desktop Software & CLI Tools

Ideal for Electron apps and CLI developer tools. Store configuration, cache data, manage local state—all with a single npm install.

Local-First & Edge Systems

Local-first applications, microservices, and edge computing. Full ACID transactions with WAL crash resilience, dual-write indexing, and an in-memory cache.

AxioDB is not competing with cloud databases like PostgreSQL or MongoDB Atlas. It's for when you need a fast, zero-native document database embedded directly inside your TypeScript app, AI agent workflow, or desktop software. Sweet spot: 10K-500K documents.

Honest positioning

What's New

AdminPassword — set the admin password at startup

The seeded admin/admin account is flagged mustChangePassword, and only the HTTP API or GUI can clear that flag. Start the server with the GUI disabled and there was no way to choose a password — TCP rejected every login and nothing could recover it. AdminPassword closes that gap.

In your app