DB-EnginesextremeDB - Features to look for if faster data management is a priorityEnglish
Deutsch
Knowledge Base of Relational and NoSQL Database Management Systemsprovided by Redgate Software

DBMS > KurrentDB (aka EventStoreDB)

KurrentDB (aka EventStoreDB) System Properties

Please select another system to compare it with KurrentDB (aka EventStoreDB).

Editorial information provided by DB-Engines
NameKurrentDB (aka EventStoreDB)
DescriptionAn event-driven database that records every change as an immutable event, indexes it for fast access via fine-grained streams, and projects it into state exposed via pub/sub or database tables for efficient event-driven workflows.
Primary database modelEvent Store
Secondary database modelsDocument store infoEvent data uses JSON per default
Time Series DBMS infoStrict global and per-stream ordering of events allows for time-series use cases requiring auditability and immutability
DB-Engines Ranking infomeasures the popularity of database management systemsranking trend
Trend Chart
Score1.15
Rank#182  Overall
#1  Event Stores
Websitewww.kurrent.io
Technical documentationdocs.kurrent.io
DeveloperKurrent, Inc. (formally, EventStore Limited)
Initial release2012
Current release25.1, October 2025
License infoCommercial or Open SourceSource Available
Cloud-based only infoOnly available as a cloud serviceno infoSelf-Managed: On-Prem and Cloud, and As cloud-based DBaaS (Kurrent Cloud)
DBaaS offerings (sponsored links) infoDatabase as a Service

Providers of DBaaS offerings, please contact us to be listed.
Implementation language.NET/C#
Server operating systemsDocker
Kubernetes
Linux
Windows
Data schemeschema-free
Typing infopredefined data types such as float or dateYes: JSON event data and metadata; Binary event data; Strongly-typed language interfaces
XML support infoSome form of processing data in XML format, e.g. support for XML data structures, and/or support for XPath, XQuery or XSLT.Partial: Store XML as string data; Convert XML to JSON; Base64 encode XML infoClient SDKs in .NET, Java, Python, Node.js, Go, and Rust provide flexibility to handle XML serialization/deserialization in application code before sending events to KurrentDB
Secondary indexesTwo virtual index streams built on the most frequently queried metadata fields. Consumers use them by pointing their stream filter to the index stream via the Read/Subscription API.
SQL infoSupport of SQLIntrospective SQL for simplified metrics collection of system, database, and application operations
APIs and other access methodsArchiving infoArchive old data to object storage for long-term retention, reconstruction and DR
Client SDKs infoAvailable in multiple languages including Python, Java, .NET, Node.js, Go, and Rust⁠
gRPC API infoHigh performance, low latency interface with streaming support for all KurrentDB operations
HTTP API infoRESTful interface for basic administration and operations
Management API infoFor administrative operations⁠
MCP Server infoconversational interactions with events for both technical and non-technical users
Navigator infoDesktop client interface for managing events, streams, configurations, and monitoring
OpenTelemetry Exporter infoPush metrics via OpenTelemetry protocol
Prometheus Metrics infoExport metrics in Prometheus format⁠
Pub / Sub API infoCatch-up Subscriptions - Self-managed subscriptions for filtered events by stream or event type, and Persistent Subscriptions - Server-managed subscriptions with multiple consumers, checkpointing, and retries⁠
Web UI infoBrowser-based client interface for managing events, streams, configurations, and monitoring
Supported programming languages.NET/C#
Go
Java
Node.js
Python
Rust
Server-side scripts infoStored proceduresUser-Defined Projections, System Projections, Projection Configuration Options, Server Administration Scripts, Connector Transformations
TriggersProjections, Persistent Subscriptions, Catch-up Subscriptions, Connectors
Partitioning methods infoMethods for storing different data on different nodesStream Level Partitioning, where each stream holds the events for a single entity or process (e.g., customer-123, order-456); Stream boundaries that align with business aggregates / entities and transactional consistency requirements;⁠ Fine-grained vs. coarse-grained streams - KurrentDB promotes fine-grained streams without expensive re-partitioning; Category-based organization where streams can be grouped by categories for easier management; Support for billions of streams, so reads/writes touch only the relevant stream, improving latency, scalability, and maintenance; For downstream pipelines (e.g., Kafka), partitions can be aligned by stream ID, suffix, or event headers, keeping physical partitioning consistent with KurrentDB’s logical model
Replication methods infoMethods for redundantly storing data on multiple nodesBuilt-in Clustering Replication infoHA Clustering: Uses secure, quorum-based replication with leader election via gossip protocol, where each node maintains data independently without shared disks Read-only Replica - Nodes that replicate data asynchronously from the cluster but don't participate in write operations, elections, or quorum - primarily used to scale read operations
Event Distribution Methods infoCatch-up Subscriptions - Self-managed subscriptions that can replicate filtered events by stream or event type from a particular position Persistent Subscriptions - Server-managed subscriptions supporting multiple competing consumers with checkpointing and retries
External System Replication infoConnector System - Real-time event distribution to external systems with at-least-once delivery, retry capabilities, event filtering, and automatic checkpointing Multi-sink Support - Can replicate to KurrentDB, Kafka, RabbitMQ, MongoDB, and HTTP endpoints simultaneously
Kurrent Replicator infoCross-cluster Replication - A specialized tool that facilitates replication or migration of data between different KurrentDB clusters or instances Migration Support - Used specifically for migrating data between clusters, allowing you to replicate all events from one cluster to another
MapReduce infoOffers an API for user-defined Map/Reduce methodsEvent-native processing and streaming; Data Pipeline Integration; Distributed Processing Patterns; KurrentDB offers event-native processing and streaming: User-Defined Projections - JavaScript-based server-side processing for transformations and state aggregations across streams;⁠ System Projections - Built-in indexing by category, event type, and correlation ID for efficient event retrieval; Data Pipeline Integration: Native Connectors - Real-time event streaming to external systems where MapReduce processing could occur (e.g. Spark/Hadoop via Kafka or files via HTTP); Event Export - Stream events to data processing platforms that do support MapReduce; Distributed Processing Patterns: Stream Processing - Events can be processed in parallel across multiple subscribers; Event Replication - Distribute events across multiple systems for parallel processing
Consistency concepts infoMethods to ensure consistency in a distributed systemAppend-only Log - Events are only appended and never modified, serving as an immutable audit trail of all historical changes
Atomic writes of events - entire batch of events submitted in the same write.
Eventual Consistency - KurrentDB supports eventually consistent systems where all parts of a distributed system will eventually return the same values, typically within milliseconds to seconds rather than large spans of time
Guaranteed Consistent Ordering - Events are consistently ordered in the order they were appended across both the event log and streams, ensuring events are always read in the same consistent order⁠
Guaranteed Write Durability - Writes are guaranteed to be fully durable once acknowledged⁠
Immutable Events - All events cannot be altered once appended, ensuring data integrity and consistent audit trails
Optimistic Concurrency Control - Prevents lost updates from concurrent appends using a lock-free approach to reduce contention and performance overhead
Quorum-based Replication - High availability clusters use secure, quorum-based replication with leader election via gossip protocol
Read-only Replicas - Asynchronous replication for scaling read operations without participating in write operations or quorum decisions
Sequential Event Numbering - Events are automatically assigned strictly monotonically increasing numbers (without gaps) within their stream to ensure reliable state reconstruction and concurrency handling⁠
Stream-level Consistency - KurrentDB can ensure data consistency within a stream when multiple writers are trying to append concurrently⁠
Transactional vs Eventual Consistency - The system allows you to consciously choose consistency boundaries so business requirements are met, with everything else being eventually consistent⁠
Foreign keys infoReferential integrityNone, but Kurrent DB provides other event-native consistency guarantees: Correlation IDs - Events can include correlation IDs to link related events across different streams; Event-driven associations - Use projections to build read models that represent relationships between entities;⁠ Application-level validation - Business logic in your application ensures data integrity rather than database constraints; Event sourcing patterns - Model relationships through the sequence and content of events rather than foreign key constraints; Optimistic concurrency control - Prevents lost updates during concurrent writes;⁠ ⁠Sequential event numbering - Ensures reliable state reconstruction;⁠ Immutable events - Once written, events cannot be altered, providing audit trail integrity⁠
Transaction concepts infoSupport to ensure data integrity after non-atomic manipulations of dataWrites use an implicit transaction: all records are appended contiguously in the same chunk and committed atomically.
Concurrency infoSupport for concurrent manipulation of dataTraditional databases rely on pessimistic locking, KurrentDB's event-driven architecture with optimistic concurrency control provides better scalability while maintaining data consistency through its append-only, immutable event model; Optimistic Concurrency Control: Lock-free approach - Concurrent appends that lead to lost updates can be prevented with optimistic concurrency control, done in a lock-free way to reduce contention and performance overhead; Stream-level consistency - KurrentDB can ensure data consistency within a stream when multiple writers are trying to append concurrently; Sequential event numbering - Events are automatically assigned strictly monotonically increasing numbers (without gaps) to ensure reliable state reconstruction and concurrency handling; Stream Position Management: Unique event positions - Each event has its own unique position within a stream, represented by a numeric, incremental value that can be used to define order and detect concurrency issues;⁠ Race condition prevention - The position system helps prevent accidental overwrites or lost updates due to concurrency and race conditions; Distributed Concurrency: Quorum-based clustering - High availability clusters use secure, quorum-based replication with leader election via gossip protocol for distributed concurrency management; Multiple competing consumers - Persistent subscriptions support multiple competing consumers with checkpointing and retries
Durability infoSupport for making data persistentCore Durability Features: Guaranteed Write Durability - Writes are guaranteed to be fully durable once acknowledged, ensuring data is safely persisted to disk; Immutable Events - All events stored in KurrentDB cannot be altered once appended, ensuring data integrity and durability over time; Append-only Log - Events are only appended and never modified, serving as an immutable audit trail that captures all historical changes; Storage and Backup Durability: Backup and Restore - Comprehensive backup functionality for full or differential backups and restores over disk snapshots or file copy backups; Event Store Replicator - Tool for facilitating replication or migration of data between different KurrentDB clusters to ensure data durability across environments; Archiving / DR - Archive to ObjectStore or long-term data retention; Clustering for High Durability: High Availability Clustering - Uses secure, quorum-based replication with leader election via gossip protocol, where each node independently maintains data without shared disks; Read-only Replicas - Asynchronous replication to additional nodes for enhanced data durability and read scaling
User concepts infoAccess controlKMS Integration (for connectors)
Kubernetes Operator Role-based access controls
LDAP integration
Mutual TLS / X.509 authentication
OAuth authentication
Password-based authentication
Role-Based Access Control
Stream Access Policy
Stream ACLs

More information provided by the system vendor

We invite representatives of system vendors to contact us for updating and extending the system information,
and for displaying vendor-provided information such as key customers, competitive advantages and market metrics.

Related products and services

We invite representatives of vendors of related products to contact us for presenting information about their offerings here.



Share this page

Featured Products

Redgate pgCompare logo

pgCompare - PostgreSQL schema comparison for faster, safer deployments.
Stay in control of schema changes across dev, test, and production.
Try pgCompare

Datastax Astra logo

Bring all your data to Generative AI applications with vector search enabled by the most scalable
vector database available.
Try for Free

Neo4j logo

See for yourself how a graph database can make your life easier.
Use Neo4j online for free.

RaimaDB logo

RaimaDB, embedded database for mission-critical applications. When performance, footprint and reliability matters.
Try RaimaDB for free.

Present your product here