Data Engineeringadvanced

NATS vs Apache Kafka

NATS vs Apache Kafka compared for 2026: NATS 2.15 with core pub/sub, request-reply, JetStream streams, work queues, KV and object stores, leaf nodes and MQTT vs Kafka 4.4 with partitioned logs, KRaft, consumer and share groups, transactions, Kafka Streams, Connect and tiered storage, with a JetStream test we ran, footprint, release cadence, Synadia Cloud pricing and a clear pick per situation.

Quick Answer

NATS and Kafka both move events between services, but they start from opposite ends. NATS is one Go binary (19 MB for linux-amd64 in our download) that does fire-and-forget pub/sub, request-reply and queue groups out of the box, and adds persistence only where you ask for it with JetStream: streams with limits, interest or work-queue retention, server-side consumers, publish deduplication, plus key-value and object stores built on the same streams. It clusters with Raft (R3 recommended, at most R5 per stream), joins regions with gateways and reaches firewalled sites with outbound leaf nodes; it became a CNCF Graduated project on 2 November 2026 and 2.15.3 shipped on 11 November. Kafka is a distributed, partitioned, replicated commit log: per-partition ordering, retention as long as you want, consumer groups and (since 4.2) production-ready share groups for queue-style work, transactions for exactly-once read-process-write, Kafka Streams and Kafka Connect. Kafka 4.4.0 (22 October 2026) runs KRaft only and needs Java 17+ on brokers. Pick NATS for service-to-service messaging, edge and multi-region fan-out with a small ops footprint; pick Kafka when the durable, replayable log and its stream-processing and connector ecosystem are the product.

Last updated November 16, 2026. Covers NATS Server 2.15.3 and 2.14.10 (11 November 2026), the 2.15, 2.14 and 2.12 upgrade notes, NATS's CNCF graduation on 2 November 2026 and Synadia Cloud pricing, against Apache Kafka 4.4.0 (22 October 2026), 4.3.2 and 4.2.2 with the 4.4 documentation (introduction, design, KRaft, tiered storage, Java, hardware, upgrade notes, Kafka Streams), all read on 16 November 2026, plus a JetStream deduplication and work-queue test we ran the same day.

Feature comparison of NATS vs Apache Kafka
FeatureNATSApache Kafka
License & Governance
Apache-2.0; CNCF Graduated (2 Nov 2026); commercial editions from Synadia
Apache-2.0; Apache Software Foundation project
Core Model
Subject-based pub/sub with wildcards; JetStream streams capture subjects into persistent, sequenced logs
Distributed, partitioned, replicated commit log of topics
Delivery Guarantees
Core NATS at-most-once; JetStream at-least-once with acks and redelivery
At-least-once by default; exactly-once with idempotent/transactional producers and read_committed consumers
Persistence
Opt-in per stream (JetStream), memory or file storage
Always: every event is written to the log on brokers
Retention Options
Limits (MaxMsgs/MaxBytes/MaxAge, default), Interest, WorkQueue
Time/size retention for as long as you configure, log compaction (last value per key), tiered storage
Ordering & Scaling Unit
Sequence numbers per stream; subject-mapping partition() transforms for scale-out
Guaranteed order per topic-partition; partitions are the unit of parallelism
Replication
Raft per stream, R1 to R5 (R3 is the documented production minimum)
Per topic-partition replication factor (3 is the common production setting); KRaft metadata quorum
Consumer Model
Server-side durable consumers that track position; pull consumers and queue groups
Consumer groups with offsets; share groups for cooperative, per-record consumption
Work-queue Semantics
Core queue groups plus WorkQueue retention (first ack removes the message)
Share groups (production-ready since 4.2) with delivery counts and DLQs (4.4)
Duplicates & Exactly-once
Nats-Msg-Id deduplication within a duplicate window (2 min in the docs example); atomic batch publish since 2.12
Idempotent producer and transactions for exactly-once; Kafka Streams exactly-once processing
Request-Reply
Built in (reply subjects / inboxes)
Not built in (build it with reply topics)
Multi-tenancy & Quotas
Accounts with isolated subject spaces, account-level JetStream limits
Client quotas on bandwidth and request rate per user/client-id
Multi-region & Edge
Full-mesh clusters, gateways for super-clusters, outbound leaf nodes for edge sites; stream mirrors and sources
Topic replication can span datacenters or regions; MirrorMaker 2 (on Kafka Connect) between clusters
Extra Protocols
MQTT v3.1.1 (QoS 0/1/2) and WebSocket on the same server
Kafka wire protocol; REST via community proxies
Built-in KV / Object / Compaction
Key-value store and object store built on JetStream streams
Log compaction keeps the latest value per key; no object store
Stream Processing & Connectors
Counters, delayed message scheduling (2.12); bridges to Kafka, JMS, Spark, Flink; Synadia Connectors (hosted)
Kafka Streams (Java/Scala, stateful, exactly-once) and Kafka Connect
Message Size
max_payload default 1 MB, configurable to 64 MB (8 MB advised maximum)
Configurable per broker and topic; large payloads usually stored externally
Runtime & Footprint
Single Go binary, ~15 MB typical memory per docs; JetStream defaults to 75% of RAM/disk unless limited
JVM brokers and controllers; docs example uses a 6 GB heap and recommend dedicated multiple disks and page cache
Official Clients
Tier 1: Go, JavaScript/TypeScript, Python, Java, Rust, C#/.NET, C; Tier 2: Zig, Swift, Ruby, Elixir
Java/Scala clients shipped with Kafka; community clients for Go, Python, C/C++ and more
Kubernetes
Official Helm chart (StatefulSet) and NACK controller for streams/consumers as CRDs
Official apache/kafka and apache/kafka-native Docker images
Release Cadence & Support
New minor about every six months; latest two minors patched (2.15 latest, 2.14 maintained)
Goal of three releases a year; 4.4, 4.3 and 4.2 lines currently supported
Managed Service Pricing
Synadia Cloud: Personal $0, Starter $49/month, Pro $199/month, Enterprise custom; Synadia Platform single-tenant
Offered by many vendors; Apache publishes no pricing
Latest Release (Nov 2026)
2.15.3 and 2.14.10 (11 Nov 2026)
4.4.0 (22 Oct 2026); 4.3.2 (23 Oct 2026); 4.2.2 (29 Sep 2026)

Pricing at a glance

Entry prices and free tiers as listed on TechLogHub for Apache Kafka; the other tool is not listed in the directory yet.

ToolFree tierStarts atBillingPlans listed
Apache Kafka pricingYes——Open source - free under the Apache License 2.0; self-managed

Prices as written by the maker on their listing; medians and context on each tool's pricing page. See the 2026 pricing report for the directory-wide picture.

NATS

NATS is an open-source messaging system; Synadia, which describes itself as the creators of NATS, sells hosted and enterprise editions. Applications publish and subscribe on subjects through nats-server, a single Go binary that also handles request-reply, queue groups, clustering, multi-tenant accounts, MQTT and WebSocket. JetStream, built into the same server, adds persistent streams, durable consumers, key-value and object stores. NATS joined the CNCF in March 2018 and moved to the Graduated maturity level on 2 November 2026.

Pros

  • One small binary: our linux-amd64 nats-server 2.15.3 is 19 MB and idled at about 17.6 MB RSS with JetStream enabled
  • Covers pub/sub, request-reply, load-balanced queue groups, persistent streams, work queues, KV and object storage without extra systems
  • Subject-based addressing with wildcards, so routing needs no topic or partition planning up front
  • Leaf nodes dial out from firewalled sites and gateways join regions into a super-cluster, a natural fit for edge-to-cloud
  • Accounts give isolated subject spaces per tenant on one cluster, with explicit imports and exports
  • Seven Tier 1 clients (Go, JS/TS, Python, Java, Rust, C#/.NET, C) and a hosted option from $0 on Synadia Cloud

Cons

  • Core NATS is at-most-once with no replay; you must opt into JetStream per subject for durability
  • Much smaller stream-processing and connector ecosystem than Kafka; the official Kafka bridge exists but there is no Kafka Streams or Connect equivalent of the same breadth
  • JetStream stream replicas are capped at R5, and 2.15 adds a default limit of 1,000 consumers per stream that you may need to raise
  • Default max payload is 1 MB and the docs advise against going above 8 MB
  • MQTT support is v3.1.1 only; MQTT v5 clients are rejected at connect

Best For

Microservices, request-reply APIs, IoT and edge fleets, and multi-region fan-out where low latency and a small operational footprint matter more than a long-term replayable log feeding analytics.

Apache Kafka

Apache Kafka is an open-source distributed event streaming platform from the Apache Software Foundation. Producers append events to partitioned, replicated topics stored durably on brokers; consumers read them in order per partition, at their own pace, for as long as the data is retained. Kafka ships Kafka Connect for moving data in and out, Kafka Streams for stream processing in Java and Scala, MirrorMaker 2 for cross-cluster replication, and since 4.0 runs only in KRaft mode without ZooKeeper.

Apache Kafkaon TechLogHub: reviews, pricing & alternatives

Pros

  • The durable, replayable log is the core design: retain events as long as you want and re-read from any offset
  • Per-partition ordering for events with the same key, and partitions spread load across brokers
  • Transactions and idempotent producers give exactly-once read-process-write, and Kafka Streams offers exactly-once processing
  • Kafka Connect and a very large client and connector ecosystem make it the default hub for data pipelines and CDC
  • Share groups (Queues for Kafka) are production-ready since 4.2, and 4.4 adds dead-letter queues for them
  • Tiered storage moves older segments to external storage such as S3 or HDFS while keeping recent data on local disks

Cons

  • Heavier to run: JVM brokers (Java 17, 21 or 25), KRaft controllers, partition planning and disk-throughput tuning
  • No built-in request-reply or lightweight fire-and-forget mode; every message goes through the log
  • Tiered storage needs a third-party RemoteStorageManager plugin and does not support compacted topics
  • Upgrades from ZooKeeper clusters must pass through the 3.9 bridge release before 4.x
  • No native MQTT, WebSocket or edge leaf-node concept; edge fleets need extra gateways or bridges

Best For

Event-sourced systems, data pipelines, CDC, analytics feeds and stream processing where you need a long-retained, replayable, per-key ordered log and the Kafka Connect and Kafka Streams ecosystem.

Two different shapes: a messaging fabric and a commit log

NATS starts from transient messaging. A publisher sends to a subject such as orders.created, every interested subscriber connected at that moment gets it, and nothing is stored: the docs call this at-most-once and never replayed. Request-reply and queue groups (load balancing across subscribers) are part of that core, so a NATS cluster can replace an RPC layer as well as a broker. Persistence is an opt-in layer, JetStream: you create a stream bound to subject patterns, the server appends matching messages with sequence numbers, and server-side consumers track each client's position and redeliver unacked messages, which gives at-least-once delivery. Kafka starts from the log. Every event is appended to a partition of a topic on disk and kept for as long as retention allows; consumers are just readers with offsets, and any number of consumer groups can read the same data independently and replay it. Events with the same key land in the same partition, and Kafka guarantees consumers see each partition in write order. That design is why Kafka excels at replay, backfills and stream processing, and why it has no cheap fire-and-forget mode: nothing in Kafka skips the log. In NATS the stream is a feature; in Kafka it is the whole system.

Queues, delivery guarantees and duplicates

Work queues used to be a clear NATS win. NATS offers them twice: core queue groups for transient load balancing, and JetStream WorkQueue retention, where the first ack removes the message for everyone. JetStream also has Interest retention (keep a message until every interested consumer has acked it) and the default Limits retention (keep until MaxMsgs, MaxBytes or MaxAge). Kafka closed much of the gap with share groups (Queues for Kafka, KIP-932): preview in 4.1, production-ready in 4.2, and in 4.4 records that exceed the delivery count or are rejected can go to a dead-letter queue. Note the operational detail in the 4.2 notes: on clusters with fewer than three brokers you must lower the share-coordinator state topic replication settings before using share groups. For duplicates, Kafka's answer is the idempotent and transactional producer; with read_committed consumers that gives exactly-once read-process-write, and Kafka Streams exposes exactly-once processing directly. NATS JetStream deduplicates on publish: messages carrying the same Nats-Msg-Id header inside the stream's duplicate window are rejected as duplicates, and 2.12 added atomic batch publish. Consumer-side processing in NATS remains at-least-once, so handlers should still be idempotent.

Clusters, regions and the edge

A NATS cluster is a full mesh of routes, and JetStream replicates each stream through its own Raft group. The docs treat R3 as the production minimum and cap streams at R5; a PubAck returns only after a quorum has committed the write. For more than one region, gateways join independent clusters into a super-cluster so traffic stays local unless a subscriber elsewhere needs it, and streams can be mirrored or sourced across regions (2.12 added promoting a mirror for disaster recovery). The distinctive piece is the leaf node: a NATS server that opens an outbound connection to a hub and bridges subject interest, which suits factory floors, ships, cars and retail sites that cannot accept inbound connections. The same server speaks MQTT v3.1.1, so existing devices can connect without a bridge. Kafka replicates per topic-partition (three copies is the common production setting) with a KRaft controller quorum for metadata; cross-cluster replication is MirrorMaker 2, built on Kafka Connect. Kafka's 4.4 documentation describes no leaf-node equivalent and no MQTT listener, so edge fleets usually sit behind an MQTT broker or gateway that forwards into Kafka. On operations, NATS 2.15 added evacuate endpoints for draining a server and a desired-state metalayer for safer scaling and moves.

Running it: footprint, upgrades, ecosystem and cost

NATS is a single Go binary with clustering, JetStream, leaf nodes, MQTT and WebSocket enabled by configuration. The docs cite about 15 MB of memory as typical, and JetStream sizes itself to 75% of RAM and available disk unless you set max_memory_store and max_file_store, which you should in containers. Minor releases come about every six months and the two latest lines get patches (2.15 since 17 September 2026, 2.14 maintained); watch the 2.15 change that caps streams at 1,000 consumers by default, which KV watchers count against. Kafka runs JVM brokers on Java 17, 21 or 25 (the docs recommend 25), and its hardware guide is about dedicated disks, page cache and sizing memory to buffer about 30 seconds of writes. It aims for three releases a year. Kafka 4.x is KRaft-only; ZooKeeper clusters must migrate on the 3.9 bridge release first, and in 4.4 storage directories formatted by kafka-storage are no longer forward-compatible. The ecosystem gap runs the other way: Kafka Connect, Kafka Streams and community clients in most languages are why data platforms standardize on Kafka. Managed NATS on Synadia Cloud costs $0 (Personal: 2 accounts, 10 connections, 5 GiB storage), $49 a month (Starter: 100 connections, 10 GiB storage) or $199 a month (Pro: 1,000 connections, 50 GiB storage), with Enterprise on request.

Worked example: deduplication and a work queue on NATS 2.15.3

We downloaded nats-server v2.15.3 for linux-amd64 from GitHub on 16 November 2026 (19,117,749-byte binary), started it with nats-server -js and drove it from Python with nats-py. First we created an ORDERS stream on orders.> with a 120-second duplicate window and published the same payload twice with the header Nats-Msg-Id: ord-1001. The first PubAck came back as seq=1, duplicate=None; the retry came back as seq=1, duplicate=True, and stream info reported 1 message. That is the behaviour that makes producer retries safe within the window. Second, we created a JOBS stream with WorkQueue retention, published three jobs on jobs.resize, fetched them with a durable pull consumer named workers and acked each one; the messages arrived as img-0, img-1, img-2 and the stream then held 0 messages, because the first ack removes a work-queue message. While idle with JetStream on, the server's resident memory was about 17.6 MB. The equivalent in Kafka needs a topic, an idempotent or transactional producer and, for queue semantics, a share group on 4.2 or later; it works, but you also run brokers and a KRaft quorum. This test shows behaviour, not throughput: we ran no performance benchmark.

Verdict

Pick NATS when the job is moving messages between services and sites: microservice events, request-reply RPC, work queues, device telemetry and multi-region or edge fan-out. One small binary covers all of it, leaf nodes reach factories and vehicles behind firewalls, accounts keep tenants apart, and JetStream adds durable streams, work queues and a KV store only where you need them. A three-node R3 cluster is a modest operational load, and Synadia Cloud starts free if you would rather not run it. Pick Kafka when the log itself is the product: event sourcing, CDC from databases, feeding warehouses and lakes, and stream processing that needs per-key ordering, long retention, replay from any offset and exactly-once read-process-write. Kafka Connect and Kafka Streams have no NATS equivalent of the same breadth, and share groups mean Kafka now covers queue-style consumption too. Accept the cost: JVM brokers, partition planning, disk tuning and a heavier upgrade path. Many organizations run both, NATS at the edge and between services and Kafka as the analytics backbone, joined by a bridge. If you are choosing one for a new backend without a data-platform team, start with NATS; if you already have one, Kafka is the safer hub.

All Comparisons

NATS vs Apache Kafka — FAQ

Common questions answered from the comparison above

Is NATS faster than Kafka?

The NATS docs claim millions of messages per second with sub-millisecond latency, and Kafka is built for very high throughput on its log; both are vendor and project claims, and we have not benchmarked them. The bigger difference is the path: core NATS does not write to disk at all, while every Kafka message is appended to a replicated log. Compare JetStream with Kafka, on your own hardware and message sizes, if durability is required.

Can NATS JetStream replace Kafka?

For service-to-service events, work queues and moderate retention, often yes: JetStream gives persistent streams, replay, durable consumers and work-queue semantics. It is a weaker fit when you depend on Kafka Connect connectors, Kafka Streams, long-term per-key ordered logs for analytics, or tools that speak the Kafka protocol. Many teams keep Kafka as the data backbone and use NATS between services and at the edge.

Does NATS support exactly-once delivery?

JetStream deduplicates on publish using the Nats-Msg-Id header within a stream's duplicate window, and supports atomic batch publish since 2.12. Delivery to consumers is at-least-once with acks and redelivery, so consumer handlers should be idempotent. Kafka offers exactly-once read-process-write through idempotent and transactional producers with read_committed consumers, and Kafka Streams provides exactly-once processing.

Does Kafka still need ZooKeeper?

No. Kafka 4.0 and later run only in KRaft mode, and ZooKeeper mode has been removed. Clusters still on ZooKeeper must migrate to KRaft using the 3.9 bridge release before upgrading to 4.x. The current release is 4.4.0 (22 October 2026).

Can Kafka be used as a work queue now?

Yes. Share groups (Queues for Kafka, KIP-932) became production-ready in Kafka 4.2. Consumers in a share group cooperatively consume records from the same partitions, with a maximum delivery count, and 4.4 adds dead-letter queue support. Classic consumer groups remain the right choice when you need strict per-partition ordering.

How much does managed NATS cost?

Synadia Cloud listed a Personal plan at $0 per month, Starter at $49 per month (3 accounts, 100 connections, 10 GiB storage), Pro at $199 per month (10 accounts, 1,000 connections, 50 GiB storage) and Enterprise on request, with no overage charges, as read on 16 November 2026. NATS itself is free under Apache-2.0 if you run it yourself.

Get the next comparison by email

One email a week: new and trending developer tools, fresh comparisons, and what shipped. Unsubscribe in one click.