NATS test server

Connect

NATS clients that speak WebSocket connect straight to the address above, each connection a server of its own. Clients on TCP go through the bridge, which listens on nats://localhost:4322 — off the usual 4222 — and carries every connection to the hub over one WebSocket: one bridge, one server, shared by every client that goes through it.

curl -O https://sondahub.com/industrial/bridge.mjs
node bridge.mjs nats

NATS on localhost:4322 → wss://api.sondahub.com/nats — nats://localhost:4322
every run of the bridge is a world of its own
the hub is a NATS server with JetStream — the APIs’ activity on store.>, fleet.>, bank.>…, streams STORE, FLEET, BANK…, key-value buckets fleet and fx, services orders.create and rpc.>
“orders-worker” — nats.js 2.29.1 connected from 127.0.0.1:52144
“orders-worker” subscribes to store.orders — the hub publishes there
orders.create ← order 900001 for 42.5: paid in 2 s, shipped in 5, delivered in 9, on store.orders

In a NATS client

nats -s nats://localhost:4322 sub 'fleet.>'
nats -s nats://localhost:4322 req rpc.store.getProduct '{"id":1}'
nats -s nats://localhost:4322 req orders.create '{"customer_id":7,"total":42.5}'
nats -s nats://localhost:4322 stream info STORE
nats -s nats://localhost:4322 kv watch fleet

import { connect, StringCodec } from 'nats.ws'

const nc = await connect({ servers: 'wss://api.sondahub.com/nats' })
const sc = StringCodec()
for await (const m of nc.subscribe('bank.fx')) console.log(m.subject, sc.decode(m.data))

nc, _ := nats.Connect("nats://localhost:4322")
js, _ := jetstream.New(nc)
kv, _ := js.KeyValue(ctx, "fleet")
w, _ := kv.WatchAll(ctx)
for e := range w.Updates() {
    if e != nil {
        fmt.Println(e.Key(), string(e.Value()))
    }
}

nc = await nats.connect("nats://localhost:4322")
js = nc.jetstream()
sub = await js.pull_subscribe("store.orders", durable="me", stream="STORE")
for m in await sub.fetch(10):
    print(m.subject, m.data.decode())
    await m.ack()

In LockFlare Sonda: a WebSocket request to wss://api.sondahub.com/nats, then the protocol as text messages, one line each — CONNECT {}, SUB fleet.telemetry 1, PUB greetings 5 followed by the payload. A line may leave off its CRLF; the server answers in text when you write text.

What is in it

Subjects the hub publishes on

Each message JSON, with the headers Content-Type: application/json and Sondahub-Key. Subscribe with wildcards: fleet.>, *.orders, >.

Streams and key-value buckets

Services

Core NATS

Subjects with * and > wildcards, queue groups (each message to one member), headers (HPUB and HMSG), request and reply through inboxes, and no responders — a request nobody serves gets a 503 status at once when the client asked for it (headers and no_responders in CONNECT, as every modern client does). echo:false keeps a client’s own messages from it; verbose answers +OK; UNSUB with a count; the server PINGs every two minutes and closes a connection that does not answer twice. The -ERR texts are nats-server’s: 'Invalid Publish Subject', 'Maximum Payload Violation', 'Unknown Protocol Operation', 'Authorization Violation'.

JetStream

Streams: create, update, info, list, names (with a subject filter), purge (by filter, up to a sequence, or keeping some), delete, message get and delete, direct get (both forms). Limits, interest and work-queue retention; max messages, bytes, age, message size and messages per subject; discard old or new; deduplication by Nats-Msg-Id within the duplicate window; Nats-Expected-Stream, -Last-Sequence, -Last-Subject-Sequence and -Last-Msg-Id; rollups with Nats-Rollup; sealed, deny-delete and deny-purge.

Consumers: durable and ephemeral (gone after five seconds without interest, or their inactive threshold), push and pull, every deliver policy (all, last, new, by start sequence, by start time, last per subject), filter subjects, ack none, all or explicit, ack wait and redelivery, max deliver, max ack pending, headers only, idle heartbeats. Acks: +ACK, -NAK (with a delay), +WPI, +TERM, +NXT, and an answer to an ack sent with a reply subject. Pull requests with batch, max_bytes, expires, no_wait and idle_heartbeat, ending in 408 Request Timeout, 404 No Messages or 409 as nats-server ends them.

Key-value buckets are streams the clients make (KV_name on $KV.name.>), so the clients’ kv APIs work: put, get, history, delete and purge markers, watch, keys. Errors carry nats-server’s codes: 10059 stream not found, 10014 consumer not found, 10058, 10065, 10071, 10148…

At most 25 streams of yours, 100 consumers a stream and 32 MB stored, in memory, for as long as the server lives.

Sign-in

Also on sondahub

Fake REST API · Public GraphQL API · gRPC-Web & Connect · SOAP test server · JSON-RPC & XML-RPC · OData test server · FHIR test server · Socket.IO test server · WebSocket test server · SSE test server · Public MQTT broker · Kafka test broker · AMQP test broker · AMQP 1.0 test broker · STOMP test server · Redis test server · FIX test server · HL7 v2 test server · MCP test server · MCP OAuth test server · Writes that persist · OpenAPI mock server · Webhook tester · Chaos and rate limits · SAML test IdP and SP · SCIM 2.0 test server · OAuth 2.0 test server · Auth test endpoints · HTTP test endpoints · Fake JSON data · Stripe sandbox · Twilio sandbox · SendGrid sandbox · Authorize.net sandbox · OpenAI sandbox · Anthropic sandbox · AWS Secrets Manager sandbox · Azure Key Vault sandbox · Google Secret Manager sandbox · 1Password Connect sandbox · Doppler sandbox · Infisical sandbox · OPC UA test server · Modbus TCP simulator · HART-IP simulator · DDS simulator

The mock APIs themselves: fake e-commerce API, fake IoT API, fake banking API, fake social media API, fake helpdesk API, fake flight booking API, fake user directory API. Built as the playground for LockFlare Sonda, the API client that lives on your computer.