CrateDB

A distributed SQL database built on Lucene: every column is indexed and stored column by column, so one cluster answers aggregations, full-text, geo and vector queries over fresh machine data.

What it is: Real-time analytics databases,Search indexes
Used for: Time-series databases,Vector databases
Type: Open source
Made by: Crate.io
License: Apache 2.0 (every feature since 4.5, March 2021); CrateDB Cloud is a paid managed service
Facts checked: 23 October 2026

What it is

CrateDB is a shared-nothing cluster written in Java. Each table is split into shards spread over the nodes, and each shard is a Lucene index made of immutable segments. Every column is indexed by default: text with a plain (whole-value) inverted index, or a full-text one if you give it an analyzer; numbers with BKD trees for range filters. Alongside the indexes it keeps doc values, Lucene’s column-by-column storage, which is on by default and serves sorting, grouping and aggregations without reading whole rows. A write is routed by its primary key (or CLUSTERED BY column) to a primary shard, logged in that shard’s translog, then applied on the replicas in parallel before the client gets an answer. New rows become visible to queries when the shard refreshes, once a second by default while the table is busy, or on REFRESH; lookups by primary key read the translog and see a write at once.

Clients speak SQL over the PostgreSQL wire protocol (port 5432) or an HTTP endpoint (port 4200, which also serves the Admin UI). Rows behave like JSON documents: OBJECT columns can add sub-columns on insert and are queried as payload['firmware']. MATCH runs BM25-ranked full-text search, geo types support shape queries, and FLOAT_VECTOR columns (up to 2,048 dimensions) answer KNN_MATCH nearest-neighbour searches through Lucene’s HNSW index. Tables can be partitioned by a generated column such as date_trunc('month', ts); each partition gets its own shards, filters on the partition column skip whole partitions, and a DELETE that covers a partition drops it. There are no transactions: each row write is atomic, BEGIN and COMMIT are accepted and ignored, and concurrent updates are handled with row version numbers.

All of CrateDB is Apache 2.0. Crate.io offers it as CrateDB OSS, CrateDB Enterprise (self-hosted with support) and CrateDB Cloud, a managed service on AWS, Azure, Google Cloud and STACKIT. Since October 2026 the company and CrateDB are owned by Crate.io AG, a holding company in Vaduz, Liechtenstein. Version 6.5.0 came out on 13 October 2026.

Why teams pick it

Indexes everything by default and stores columns too, so ad-hoc filters and aggregations over billions of rows work without designing indexes first
Search, analytics and documents in one SQL dialect: full-text with BM25 scores, geo shapes, vector kNN and nested OBJECT columns sit next to GROUP BY and joins
Scales out on its own: shards are created (by default max(4, data nodes × 2)), replicated and rebalanced automatically, and time-partitioned tables make old data cheap to drop
PostgreSQL wire protocol, so pgjdbc and tools such as Grafana’s PostgreSQL data source connect without a special driver

Watch out for

No transactions: atomicity is per row, BEGIN/COMMIT are silently ignored, and the PostgreSQL interface reports read uncommitted
Queries see new rows only after a refresh, up to a second later by default; only primary-key lookups are read-after-write
Postgres-compatible on the wire, not in the dialect: no JSON type (use OBJECT), no TIME without time zone, no COPY sub-protocol, and full-text functions differ, so many Postgres tools only partly work
Upgrades can mean rebuilding: tables created before 5.x must be recreated to run on 6.x, and a new shard count only applies to partitions created afterwards

Good for

Specs

Compare with alternatives →

Data model: Relational tables with nested OBJECT columns that can add fields on insert
Query language: SQL (its own dialect, not PostgreSQL’s)
Client protocol: PostgreSQL wire protocol and an HTTP endpoint
Secondary indexes: Every column indexed by default: inverted indexes, BKD trees, HNSW for vectors
Transactions: None; each row write is atomic, and BEGIN/COMMIT are ignored
Consistency: Queries see new rows after a refresh (1 s by default); primary-key reads see them at once
How it scales: Shared-nothing; shards are created, replicated and rebalanced automatically
Replication: Primary shard with replicas, written in parallel before the client is answered
Storage format: Lucene segments per shard, with doc values as a column store
Written in: Java
Ways to run it: Self-hosted (OSS or Enterprise) or CrateDB Cloud on AWS, Azure, Google Cloud and STACKIT

Alternatives

What all real-time analytics databases have in common →Compare side by side →

ElasticsearchCommercialAlso good for full-text search with relevance rankingThe distributed search and analytics engine built on Apache Lucene: JSON documents in, full-text, vector and log queries out, over a REST API.

OpenSearchOpen sourceAlso good for full-text search with relevance rankingThe Apache 2.0 fork of Elasticsearch and Kibana 7.10.2 that AWS started in 2021, now run by a Linux Foundation project.

ClickHouseOpen sourceAlso good for sub-second queries on fresh eventsAn open-source column-oriented database for real-time analytics, fast enough to serve dashboards over billions of rows.

Apache DruidOpen sourceAlso good for sub-second queries on fresh eventsAn open-source real-time analytics database that makes Kafka and Kinesis events queryable within seconds and serves fast slice-and-dice queries to dashboards and APIs.

Apache PinotOpen sourceAlso good for sub-second queries on fresh eventsA real-time distributed OLAP database from LinkedIn, built to answer analytics queries from end users in milliseconds at hundreds of thousands of queries per second, over data that arrived from Kafka seconds ago.

StarRocksOpen sourceAlso good for sub-second queries on fresh eventsAn open-source MPP analytical database with a vectorized engine that serves fast joins and real-time updates on its own tables, and also queries Iceberg, Hudi, Delta Lake and Hive tables in place.

Apache DorisOpen sourceAlso good for sub-second queries on fresh eventsAn open-source MPP analytical database, born at Baidu as Palo, that serves sub-second queries on fresh, updatable data through the MySQL protocol and also queries Iceberg, Hudi, Paimon and Hive tables in place.

How it fits with other technologies

What CrateDB uses

Sensor data: a monthly-partitioned table with a document column and a full-text index · sql

CREATE TABLE readings (
  device_id   TEXT,
  ts          TIMESTAMP WITH TIME ZONE,
  temperature DOUBLE PRECISION,
  payload     OBJECT(DYNAMIC),            -- new keys become columns on insert
  note        TEXT INDEX USING FULLTEXT WITH (analyzer = 'english'),
  month       TIMESTAMP WITH TIME ZONE GENERATED ALWAYS AS date_trunc('month', ts)
) PARTITIONED BY (month);

-- Aggregation over doc values, the column store
SELECT device_id, date_trunc('hour', ts) AS hour, avg(temperature)
FROM readings
WHERE ts >= CURRENT_TIMESTAMP - INTERVAL '1 day'
GROUP BY 1, 2 ORDER BY 2;

-- Full-text search on the same table, ranked by BM25
SELECT device_id, note, _score
FROM readings
WHERE MATCH(note, 'fan overheating')
ORDER BY _score DESC LIMIT 10;

See it in a real stack

No architecture uses CrateDB yet. Drop it into the playground and wire it up yourself.Open playground →

Where it came from2013–2026

CrateDB began in Dornbirn, Austria, where Christian Lutz, Bernd Dorn and Jodok Batlogg founded Crate in 2013 to build an open-source clustered database for fast text search and analytics; the first release came in April 2013. The founders had about ten years of history with Elasticsearch, including running some of Europe’s largest deployments. They started with their own Apache-licensed Elasticsearch plugins, such as inout and timefacets, which were merged into CrateDB, and built SQL on top of Elasticsearch’s clustering and Lucene’s indexes. Crate won TechCrunch Disrupt Europe in London in October 2014.

CrateDB 1.0 shipped in December 2016, after more than a million downloads, the same year the company moved its headquarters to San Francisco while development stayed in Austria. CrateDB 2.0 in May 2017 brought the first Enterprise Edition. With 4.0 in 2019 the team stopped tracking Elasticsearch directly and copied the code into its own repository, and the company adopted an open-core model that founder Christian Lutz later called a mistake. When Elastic moved Elasticsearch to the SSPL and Elastic License in January 2021, Crate.io said it would no longer use it as an upstream, and CrateDB 4.5 in March 2021 put every feature, including user management and privileges, under Apache 2.0; revenue was to come from support and CrateDB Cloud.

CrateDB 5.0 followed in July 2022 and 6.0 in July 2025. In October 2026 a newly formed holding company, Crate.io AG in Vaduz, Liechtenstein, took over the US company’s assets, including the Austrian subsidiary that holds the code, and Crate.io added STACKIT, a European cloud, as a CrateDB Cloud option.

Why it’s built this way

SQL on Elasticsearch’s clustering and Lucene’s indexes: The founders already ran large Elasticsearch clusters, and its Apache licence let them build on it freely; Bernd Dorn wrote that they would not have chosen it under the GPL. Lucene supplied the indexes underneath.
Copy the Elasticsearch code in, then drop the upstream: From 4.0 the team wanted control over the modules it used, so it copied the code and only backported fixes. Elastic’s 2021 licence change ended any reason to follow Elastic’s releases.
Speak the PostgreSQL wire protocol: Existing drivers and tools then work unchanged: pgjdbc connects, and Grafana reaches CrateDB through its ordinary PostgreSQL data source.
One Apache 2.0 codebase instead of open core: Christian Lutz wrote that over 85% of paying customers wanted a managed service anyway, that features such as authentication mattered to every user, and that a single codebase was simpler to develop and to partner on.

Timeline

2013
Crate is founded in Dornbirn, Austria; first release in April
2014
Crate wins TechCrunch Disrupt Europe in London
2016
CrateDB 1.0 ships in December; the company moves its headquarters to San Francisco
2017
CrateDB 2.0 brings the first Enterprise Edition
2019
CrateDB 4.0 copies Elasticsearch code into its own repository
2021
Crate.io drops Elasticsearch as upstream; CrateDB 4.5 makes everything Apache 2.0
2025
CrateDB 6.0 is released in July
2026
Crate.io AG in Liechtenstein takes over CrateDB; 6.5.0 ships in October

Sources15 · facts checked 23 October 2026

Improve this page on GitHub