NATS

Editor’s note: This NATS review is based on my hands-on test of NATS Server 2.15 with the nats CLI 0.5.1, in October 2026. I weighed pricing and value, local setup, JetStream durability, edge protocols, and day-two operations.

Quick verdict: I recommend NATS for teams that want one lightweight messaging layer for microservices and cloud-to-edge applications. One Apache 2.0 server handles pub/sub, request-reply, queue groups, persistent JetStream streams, Key/Value store, and Object Store.

The trade-off is operational responsibility: budget for JetStream cluster management or Synadia support. Cloud Starter and Pro have no support SLA, despite their paid monthly subscriptions.

In this NATS review, I’ll take a closer look at Synadia Cloud pricing, the local setup experience, persistence limits, edge connectivity, and production recovery. NATS remains a CNCF project, with JetStream included in the free server rather than reserved for a commercial edition.

Key Takeaways

• Free Apache 2.0 server: NATS Server 2.15.2 is the latest release, published October 26, 2026.
• Predictable Cloud plans: Synadia Cloud costs $0, $49, or $199 monthly, with Enterprise by quote and no overages.
• Bounded persistence: JetStream supports up to 5 replicas; the server’s default message size is 1 MiB.
• MQTT limitation: NATS supports MQTT 3.1.1, not MQTT 5.
• Production caveats: Starter at $49/month and Pro at $199/month lack support SLAs; users have reported memory growth in 3-node clusters on the NATS GitHub issue tracker.

Pros and Cons

How Much Does NATS Cost?

NATS Server is free under Apache 2.0, including JetStream; paying Synadia buys hosting, management tooling, or support. Self-hosting removes the software bill, not responsibility for persistent cluster capacity and recovery.

• Personal ($0/month): Start here for development. No card is required, and the pool includes 2 accounts, 10 connections, and 5 GiB storage.
• Starter ($49/month): For small projects needing 100 connections and 100 GiB network data. Its 1 GiB HA storage allowance and missing support SLA limit its production appeal.
• Pro ($199/month): For pre-production or noncritical applications needing 1,000 connections. Its 2 MiB message limit doubles Starter’s, but paying more still does not buy a support SLA.
• Enterprise (by quote): For production requiring vendor-backed support. Custom quotas come with an 8 MiB message allowance, support with an SLA, and a design review.
• Bring Your Own NATS ($49/month per system): An add-on to any Cloud plan for managing an existing NATS system. It includes a 14-day free trial, remote server statistics, and JetStream asset management.
• Synadia Platform (no public price): Managed deployment in your cloud includes a 99.99% uptime SLA and zero-downtime upgrades. The self-hosted option includes 24/7 support and offers a 60-day trial.

Plan	Price/month	Accounts	Connections	Leaf nodes	Max message	Network data	Storage	HA storage	Support
Personal	$0	2	10	2	1 MiB	10 GiB	5 GiB	Not listed	Not listed
Starter	$49	3	100	3	1 MiB	100 GiB	10 GiB	1 GiB	No SLA
Pro	$199	10	1,000	10	2 MiB	1 TiB	50 GiB	10 GiB	No SLA
Enterprise	By quote	Custom	Custom	Custom	8 MiB	2 TiB	Custom	Custom	Support + SLA, design review

Synadia Cloud allocates each plan’s fixed resource pool across accounts, with no overages. Its global supercluster spans 4 regions:

• Taipei
• Dublin
• Ohio
• Oregon

Workload and integration allowances

• Starter: 1 service, 3 functions, and 1 connector.
• Pro: 3 services, 5 functions, and 3 connectors.

Is NATS Good Value for Money?

• Self-hosting has a low entry cost: In Synadia’s core NATS container tests, a 1-core, 32 MiB node handled 100 publishers sending 1,000 messages per second each, totaling 100,000 messages per second.
• Cloud bills are predictable: Fixed pools avoid usage-based overage charges. Confluent Cloud Standard starts around $385/month with eCKU billing, while Google Cloud Pub/Sub charges $40 per TiB after the first 10 GiB monthly.
• Support changes the buying decision: Starter and Pro lack support SLAs. Compare Enterprise and Platform quotes against the cost of staffing a self-hosted deployment, not against the server’s $0 license.

Reviewer’s Notes: I recommend Personal or self-hosted NATS for development, then Pro at $199/month for pre-production. Critical production belongs on Enterprise, Synadia Platform, or self-hosting with an explicit on-call owner. Bring Your Own NATS adds management tooling, including account management and stream sharing; select production support separately from those control-plane features.

My Experience With NATS

I started NATS locally with JetStream enabled, then used the nats CLI to move from basic messaging to a stream and a Key/Value store bucket. Persistence ran in the same server process as my initial messaging setup.

Installing the Server

I installed the server on macOS with brew install nats-server. NATS also offers docker pull nats:latest, so Homebrew was a choice rather than a prerequisite.

Available builds

• macOS on arm64 and amd64
• Linux, including ARM and s390x
• Windows
• FreeBSD amd64

Other installation options

• Windows package manager: scoop install main/nats-server.
• Portable installation: A release zip.
• Go installation: go install.
• Kubernetes deployment: Helm charts in nats-io/k8s.

I started the server with nats-server -js, enabling JetStream without installing a separate persistence service. For monitoring, I added -m 8222 to the startup command.

I kept the port assignments distinct during setup:

• 4222: Client traffic.
• 8222: HTTP monitoring.
• 6222: Cluster routing, not the local client connection.

Publishing My First Messages

I installed nats CLI 0.5.1 and used nats sub and nats pub hello world against the local server at nats://0.0.0.0:4222. I started with core messaging before creating persistent storage through JetStream.

I also tried the public demo server with nats sub -s nats://demo.nats.io '>'. That command used a wildcard subscription against a remote NATS endpoint rather than my local process.

The local server defaults differ substantially from Synadia Cloud Personal’s 10-connection pool:

• Connections: The server defaults to a maximum of 65,536.
• Payload: The default maximum is 1 MiB.
• Pending data: Each client has a 64 MiB pending-byte limit.
• Control line: The maximum is 4,096 bytes.

Creating a Stream and a KV Bucket

I created a stream with nats stream add, then created a Key/Value store bucket with nats kv add. Both tasks stayed within the nats CLI and the server I had already started.

For the stream, I focused on the choices that affect persistence:

• Storage: File storage is the default; memory storage is also available.
• Retention: Limits, Interest, and WorkQueue policies serve different message lifecycles.
• Replication: Clustered JetStream supports up to 5 replicas per stream.

I checked /varz and /jsz through the monitoring listener on port 8222. Those endpoints let me inspect the running server and JetStream through the local HTTP interface.

Reviewer’s Notes: The single-server workflow was my strongest first impression: I installed NATS, enabled JetStream, and created storage through the same server and CLI. For an initial evaluation, that compact setup earned my preference; production still needs explicit retention limits and a recovery plan.

JetStream: Streams, Consumers and Delivery Guarantees

NATS JetStream adds persistent streams inside the messaging server, with file storage by default and memory storage as an alternative. Choose JetStream when application work must remain available beyond a consumer’s current connection.

Retention and acknowledgment settings determine the lifecycle of that stored work:

• Retention: Limits is the default. Interest tracks consumer interest, while WorkQueue removes a message after its consumer acknowledges it.
• Discard behavior: Streams can discard old messages or reject new ones, including a per-subject rejection option.
• Capacity limits: MaxAge, MaxBytes, MaxMsgs, and MaxMsgsPerSubject bound retention.
• Replication: Up to 5 replicas belong to one cluster, not a cross-region supercluster.
• Deduplication: Nats-Msg-Id identifies duplicate publishes within a default 2-minute window, configurable with --dupe-window.
• Replication topology: A mirror follows one origin and is not directly writable. Choose Sources for new configurations that combine one or more origins while remaining writable.

Use pull consumers for new applications, especially work-queue processing. Durable consumers preserve named state; ephemeral consumers suit temporary consumption, and ordered consumers are always ephemeral with automatic flow control.

Consumer setting	Available behavior
Delivery	Push or pull
Lifetime	Durable or ephemeral
Acknowledgment	Explicit by default, all, none, or flow control
Replay	Instant by default or original timing
Ordered consumer	Ephemeral with automatic flow control

Explicit acknowledgments are the default; AckFlowControl arrived in 2.14. Messages that reach MaxDeliver remain in the stream until removed through the API, so include that cleanup in work-queue recovery procedures.

• 2.12: Atomic batch publishing and counter streams.
• 2.14: Fast batch ingest and repeating or cron-based schedules through Nats-Schedule.
• 2.15: A default limit of 1,000 consumers per stream.

InactiveThreshold cleans up idle consumers, while ReplayOriginal preserves original message timing instead of the default instant replay.

Stream controls

• Subject transforms: Change subject mappings.
• Deletion controls: DenyDelete and DenyPurge restrict removal.
• Placement: Select a cluster and tags.

I rate built-in scheduling highly for recurring application work. Test application retries against the deduplication window before relying on JetStream to prevent repeated processing.

Key/Value and Object Store

NATS’s Key/Value store adds compare-and-swap and watch operations without a separate storage service. It fits configuration and coordination within a NATS application, not a blanket replacement for a primary database.

• Basic operations: Put, get, delete, purge, and list keys.
• Conditional writes: Create sets a value only when absent; update uses compare-and-swap.
• Change observation: Watch follows updates.
• Bucket limits: Control total size, maximum value size, and TTL.

Monotonic reads and writes are guaranteed, but read-your-writes is not. A direct get can reach a follower or mirror rather than return the value an application just wrote.

For locks, build around conditional operations instead of assuming an ordinary read immediately returns the latest write. For configuration, use watch-based updates when that behavior fits the application.

Users have reported a catchup failure on the NATS GitHub issue tracker: an in-memory R3 Key/Value bucket at about 1,000 updates per second left a restarted pod stuck for over 20 minutes until stream deletion. The issue opened in March 2024 and closed in August 2024.

Object Store chunks files into stream-backed buckets, with put, get, delete, and watch operations. It is not distributed file storage: all files in a bucket must fit on the target file system.

• Best for: Configuration, coordination, and bounded file storage alongside existing NATS messaging.
• Skip if: Your application requires primary-database semantics or distributed file capacity; choose a storage layer built for those requirements.

Clustering, Leaf Nodes and Edge Protocols

NATS leaf nodes let an edge site authenticate clients locally while connecting to a larger NATS system. This topology suits applications that need local messaging without routing every interaction through a distant application endpoint.

Leaf nodes can bridge operator and security domains while preserving queue semantics across connections. Synadia Cloud uses a global supercluster across 4 regions, and leaf nodes extend that system into infrastructure outside the managed service.

• Clusters: Group servers, with each JetStream stream and its replicas bound to one cluster.
• Superclusters: Connect clusters into a broader NATS system.
• Leaf nodes: Attach local environments while keeping local traffic local and authenticating clients at the edge.

WebSocket support runs alongside TCP and has been available since NATS 2.2. It supports TLS, compression, and Origin checking, but accepts binary frames only, so check client compatibility before choosing WebSocket rather than TCP.

MQTT support has a harder compatibility boundary:

• Protocol: MQTT 3.1.1, with QoS 0, 1, and 2.
• Persistence: The connecting account must have JetStream enabled for sessions and retained messages.
• Missing version: MQTT 5 is not supported in the server.

Skip NATS as the direct MQTT endpoint when MQTT 5 is mandatory. Users have reported on the NATS GitHub issue tracker that MQTT is not horizontally scalable; validate that requirement separately from general NATS clustering.

NATS provides JWT account tooling through nsc. Version 2.12 disabled insecure TLS cipher suites by default and added the X25519MLKEM768 TLS curve option.

Version 2.14 added runtime-reloadable leaf node remotes, giving operators another configuration control for connected edge environments.

More than 40 client language implementations broaden integration choices. Check the specific client’s JetStream and transport support before treating language availability as feature parity.

Operations, Releases and Governance

NATS 2.15 added quorum-recovery and maintenance controls, including META.RESCUE for a metalayer that lost quorum. Rehearse recovery on the intended JetStream topology before production.

• HTTP endpoints: /varz, /connz, /jsz, and /healthz on the monitoring listener at port 8222.
• Open tooling: The Apache 2.0 prometheus-nats-exporter and nats-surveyor.
• Kubernetes packaging: Helm charts in nats-io/k8s.
• Commercial observability: Synadia Insights provides 100+ checks.

Users have reported memory growth in 3-node Kubernetes clusters, backups timing out on roughly 4.6 GiB streams, and JetStream quorum loss on the NATS GitHub issue tracker. The memory-growth report dates to October 2023; include memory behavior and restoration in production acceptance testing.

• 2.12.0, September 22, 2025: Added reconnect backoff and TLS hardening.
• 2.14.0, April 30, 2026: Added asynchronous replicated-stream snapshots; version 2.13 was skipped.
• 2.15.0, September 17, 2026: Added evacuate and cancel-move endpoints, META.RESCUE, and stream backup/restore v2.
• 2.15.2, October 26, 2026: The latest server release.

Version 2.15 also introduced a desired-state metalayer for streams and consumers.

NATS’s Apache 2.0 license remains intact after the 2025 dispute. Synadia moved to withdraw NATS from CNCF in April and signaled a Business Source License.

The May 1, 2025 agreement assigned the NATS trademarks to the Linux Foundation while keeping the GitHub repositories and nats.io with CNCF. Any proprietary Synadia fork must use a different name.

Reviewer’s Notes: Set JetStream memory limits and test backup restoration before production. Rehearse quorum recovery and server maintenance on the intended topology. The 2.15 controls expand recovery options, but my production recommendation still requires an on-call owner and a practiced recovery procedure.

How Does NATS Compare to Competitors?

NATS is my choice for combined application messaging and edge connectivity; Kafka integration or cloud-native ingestion points to a different shortlist.

• Apache Kafka / Confluent Cloud: Basic starts at $0/month, Standard around $385/month with a 99.99% SLA, and Enterprise around $895/month, billed through eCKUs. Choose this route for Kafka-centered event pipelines when that ecosystem matters more than NATS’s single-server feature mix.

• Redpanda: Serverless supports up to 100 MB/s write with a 99.9% SLA; BYOC supports up to 2 GB/s write in your VPC. Include Redpanda in dedicated streaming evaluations instead of choosing NATS solely for its compact local installation.

• RabbitMQ: RabbitMQ Streams provide replicated, replayable logs with non-destructive reads over AMQP 0.9.1 or a dedicated binary protocol. Evaluate this first for an existing RabbitMQ deployment that needs replay, rather than adding NATS just to introduce log semantics.

• Apache Pulsar: Multi-tenancy, geo-replication, and tiered storage support platforms with up to one million topics. Choose Pulsar for a multi-tenant streaming shortlist when those requirements outweigh NATS’s request-reply and edge topology.

• Google Cloud Pub/Sub: Google Pub/Sub charges $40 per TiB after the first 10 GiB each month. Choose it for Google Cloud-centric messaging when avoiding a self-run NATS deployment matters more than extending the same messaging system to edge sites.

• Amazon Kinesis Data Streams: US East on-demand pricing is $0.08 per GB ingested, $0.04 per GB retrieved, and $0.04 per stream-hour. For AWS-native ingestion, model retrieval and stream-hour charges rather than comparing ingestion alone with Synadia’s fixed pools.

Option	Commercial model or limit	My preferred fit
NATS / Synadia Cloud	Free server; Cloud from $0/month	Application messaging and edge
Confluent Cloud	Basic $0/month; eCKU billing	Kafka-centered pipelines
Redpanda	Serverless up to 100 MB/s write	Dedicated streaming evaluation
RabbitMQ Streams	Replay over AMQP 0.9.1 or binary protocol	Existing RabbitMQ deployments
Apache Pulsar	Up to one million topics	Multi-tenant platforms
Google Cloud Pub/Sub	$40/TiB after 10 GiB/month	Google Cloud messaging
Amazon Kinesis Data Streams	Ingestion, retrieval, and stream-hour charges	AWS-native ingestion

For NATS vs Kafka decisions, start with the application contract rather than headline throughput. NATS fits request-reply plus durable streams; the Kafka route fits projects whose integration requirements already determine that choice.

Confluent Cloud Standard, at about $385/month, and Synadia Platform’s managed option both include a 99.99% uptime SLA. Synadia Platform has no public price; compare its quote with Confluent’s capacity costs rather than treating uptime and support SLAs as interchangeable.

How I Reviewed NATS

I ran NATS Server 2.15 locally with JetStream and nats CLI 0.5.1. I published and subscribed to messages, created a stream and Key/Value store bucket, and checked the /varz and /jsz monitoring endpoints.

I compared Synadia Cloud’s plan quotas and support commitments. My pricing comparison distinguished fixed resource pools from Confluent’s eCKUs and the usage charges for Google Cloud Pub/Sub and Amazon Kinesis Data Streams.

I weighed JetStream retention and replication alongside edge protocols and recovery tooling. I also examined server changes from 2.12 through 2.15 and operational problems users have reported on the NATS GitHub issue tracker.

I evaluated Key/Value consistency and Object Store capacity constraints when judging whether NATS could replace a separate application storage service.

Prices current as of October 2026.

Should You Use NATS for Messaging and Streaming?

I recommend NATS when application messaging and persistent streams need to share one system. Its Apache 2.0 server combines request-reply with JetStream, while leaf nodes extend that platform beyond a central cloud deployment.

For microservices teams, request-reply plus durable work queues is the strongest fit. Edge and IoT applications also fit when MQTT 3.1.1 meets their protocol requirements.

Small teams can evaluate those capabilities through one server binary, but assign ownership for JetStream capacity and recovery before production. Self-hosting fits only when an on-call team accepts that persistence work.

Skip NATS when MQTT 5 is mandatory or Kafka-ecosystem integration determines the architecture. Buyers requiring vendor-backed support need to evaluate Enterprise or Synadia Platform rather than stopping at Cloud Pro.

Choose the deployment around support and storage requirements, not the ease of the local setup. Starter’s 1 GiB HA storage and Pro’s 10 GiB HA storage deserve particular attention.

Start with NATS locally or Synadia Cloud Personal, and validate one representative message workflow before selecting a paid deployment.

FAQs

Is NATS free and open source?

Yes, NATS Server is free under Apache 2.0, including JetStream. The May 2025 agreement kept the repositories and nats.io with CNCF and assigned the trademarks to the Linux Foundation.

Synadia sells hosting, tooling, and support separately; using persistent streams does not require a commercial license or a paid Synadia Cloud subscription.

How much does Synadia Cloud cost?

Synadia Cloud Personal costs $0/month, Starter $49/month, and Pro $199/month; Enterprise is priced by quote. Every plan uses a fixed resource pool with no overages.

Starter and Pro lack support SLAs. Bring Your Own NATS costs another $49/month per system and includes a 14-day free trial on any Cloud plan.

NATS vs Kafka: which should I use?

I recommend NATS for request-reply, durable application messaging, and edge connections within one system. Choose Kafka when Kafka-ecosystem integration drives the project.

Confluent Cloud Standard starts around $385/month with a 99.99% SLA. See How Does NATS Compare to Competitors? above for the broader shortlist and commercial differences.

Does NATS support MQTT 5?

No, NATS Server supports MQTT 3.1.1, not MQTT 5. It supports QoS 0, 1, and 2, and the connecting account must have JetStream enabled because sessions and retained messages persist.

Rule out the direct NATS MQTT endpoint when MQTT 5 is a firm application requirement.

What is the maximum message size in NATS?

NATS Server defaults to a 1 MiB payload limit, but that default is not an absolute server maximum. The server warns above 8 MiB.

Synadia Cloud caps messages at 1 MiB on Personal and Starter, 2 MiB on Pro, and 8 MiB on Enterprise. Check payload size before choosing a plan.