sondahub / Connect
Connect from Sonda
Protocol by protocol: what to paste where — in Sonda, or in any API client. Each API's page has its own addresses; these are the shapes. No keys, no accounts, nothing to set up. Sonda itself is at lockflare.com/sonda.
Writes, and the session
Send them like you would to any API. They are validated, run through the real logic and answered as a real server would — 201 with the record and a Location header, 200 with the changed record, 422 naming every wrong field. sondahub has no database, so the answer also carries X-Sondahub-Session: a signed token with everything you have changed. Send the newest one back on every request (as that header, or ?_session=) and your writes are there — the record you created comes back on GET, shows up in lists, counts in totals.
In an API client, carry the header from each response into the next request — most clients can capture a response header into a variable — and a chain of requests behaves like a real backend. Without the header every request starts from the seed, and the answer says so: X-Sondahub-Write: simulated. With it: X-Sondahub-Write: session, and the body's _note reads “Kept in your session, not on the server: this write lives in the X-Sondahub-Session token this answer carries. Keep sending the newest token and every request sees it.” More on sessions.
REST
Import → From a URL, paste an OpenAPI address. Sonda builds the project: a folder per collection, a request per operation, example bodies from the schema. Fetch the spec again from the same place to update the project when the hub changes. The REST API in full.
| API | OpenAPI |
|---|---|
| Store | https://api.sondahub.com/v1/store/openapi.json |
| Fleet | https://api.sondahub.com/v1/fleet/openapi.json |
| Bank | https://api.sondahub.com/v1/bank/openapi.json |
| Social | https://api.sondahub.com/v1/social/openapi.json |
| Helpdesk | https://api.sondahub.com/v1/helpdesk/openapi.json |
| Flights | https://api.sondahub.com/v1/flights/openapi.json |
| Identity | https://api.sondahub.com/v1/identity/openapi.json |
Every list request takes page, limit, sort, q, fields, expand and one filter per field with the _ne _gt _gte _lt _lte _like _in _null suffixes; details on each API's page.
GraphQL
A request in GraphQL mode with the endpoint https://api.sondahub.com/v1/{api}/graphql. Introspection answers the usual query, so the schema loads and completions work. Mutations are simulated like every write, with the note in extensions. Subscriptions are not offered over HTTP; the streams below carry the same events. More on GraphQL.
gRPC-Web and Connect
Every API is a protobuf service too, described by https://api.sondahub.com/v1/{api}/{api}.proto. A client that speaks gRPC-Web or Connect calls https://api.sondahub.com/grpc with it; and since Connect is plain HTTP, any REST request can make the same call — POST JSON to https://api.sondahub.com/grpc/sondahub.{api}.v1.{Api}Service/{Method}. Native gRPC over HTTP/2 is not offered — the platform cannot send trailers — and answers UNIMPLEMENTED saying so. More on gRPC-Web.
SOAP, JSON-RPC and XML-RPC
Every API is a SOAP service too: the WSDL at https://api.sondahub.com/soap/{api}?wsdl, document/literal over SOAP 1.1 (text/xml and a SOAPAction) and 1.2 (application/soap+xml), and the same service behind WS-Security at https://api.sondahub.com/soap/secure/{api} — a UsernameToken or HTTP Basic, sonda / probe. In Sonda, POST the envelope with those two headers; the session token comes back in the HTTP header and in a Session SOAP header. JSON-RPC 2.0 is at https://api.sondahub.com/jsonrpc (its OpenRPC document at a GET of the same address) and XML-RPC at https://api.sondahub.com/xmlrpc, methods named {api}.{verb}{Thing}: store.getProduct. More on SOAP · more on JSON-RPC and XML-RPC.
OData
Every API is an OData 4.0 service too: the root at https://api.sondahub.com/odata/{api}/ and the CSDL at https://api.sondahub.com/odata/{api}/$metadata. A client that reads metadata — Power BI or Excel through Get Data → OData feed, or any OData library — finds the entity sets and navigation on its own; from Sonda, GET an entity set with the query options as parameters: $filter=price lt 30 and category/name eq 'Toys', $expand=reviews($top=3), $select, $orderby, $count=true. Writes keep to the session like every other write; If-Match with an entity's @odata.etag catches a stale update. More on OData.
FHIR
A FHIR R4 (4.0.1) server over a synthetic clinic at https://api.sondahub.com/fhir, its CapabilityStatement at https://api.sondahub.com/fhir/metadata. From Sonda, GET a type with search parameters — /fhir/Observation?patient=1&code=http://loinc.org|8867-4&_sort=-date — and send resources as application/fhir+json; a FHIR client library takes the base URL. Writes keep to the session like every other write; If-Match with a resource's ETag catches a stale update, and errors come back as OperationOutcomes. More on FHIR.
Socket.IO
A Socket.IO server for v3 and v4 clients at https://api.sondahub.com, the default path /socket.io/, over the WebSocket transport — set transports: ['websocket'], since long-polling needs memory between requests that sondahub does not keep. Namespace /{api} per API: the five calls per collection as events with an acknowledgement (getProduct, createTransfer…), answered { ok, data } or { ok, error }, and the live topics pushed as events. / has the test events (echo, sleep, ask, clock, binary, kick, drop), and /admin refuses you with connect_error until you send auth: { token: 'sonda-probe-key' }. More on the Socket.IO server.
WebSocket
A WebSocket request to wss://api.sondahub.com/v1/{api}/ws, with ?topics=a,b to hear only some topics. The server says hello, then pushes the API's activity as JSON messages, one tick a second; send {"type":"subscribe","topics":[…]}, {"type":"ping"}, or anything else to have it echoed. The stream is generated for your connection alone. For testing the pane itself, wss://api.sondahub.com/v1/utils/ws echoes every frame, text or binary. More on the WebSocket test server.
Server-Sent Events
An SSE request to https://api.sondahub.com/v1/{api}/events, same topics parameter. Each message arrives as an event named after its type or topic with an increasing id; a reconnect with Last-Event-ID continues the numbering. A comment line keeps the connection warm every fifteen seconds. For a plain clock, https://api.sondahub.com/v1/utils/sse?count=10&interval=1000. More on SSE.
MQTT
In the MQTT pane: broker wss://api.sondahub.com/mqtt, version 5 or 3.1.1, any username and password. Subscribe to fleet/+/telemetry and readings arrive every two seconds; publish to fleet/{serial}/commands and the device answers on fleet/{serial}/ack. Retained messages, wildcards, QoS 1 and topic aliases all behave. Two things to know: the broker only speaks WebSocket — there is no port 1883 — and it serves each connection its own world, so a message you publish reaches your own subscriptions, not another client's. More on the broker.
Kafka
Kafka speaks TCP, so it goes through the bridge: run node bridge.mjs kafka and point a Kafka item at localhost:9192 — not 9092, so a broker you already run keeps its port. Sixteen topics are already talking, with five minutes of history; produce an order to store.orders and watch it get paid, shipped and delivered. SASL is optional: sonda / sondahub with PLAIN or SCRAM. Run the bridge again and it takes the next port with a cluster of its own. More on the broker.
AMQP and STOMP
AMQP 0-9-1 goes through the bridge too: run node bridge.mjs amqp and point a RabbitMQ item at localhost:5772 as guest / guest — not 5672, so a broker you already run keeps its port; STOMP on the same broker is at localhost:61713. A queue per API is already filling from amq.topic; publish an order to the orders queue and it moves on store.orders, or ask the rpc queue with a reply_to. AMQP 1.0 clients use the same port, or wss://api.sondahub.com/amqp over WebSocket with the subprotocol amqp, reading /queues/fleet and sending to /exchanges/amq.topic/…. STOMP also comes straight over WebSocket, no bridge: a WebSocket request to wss://api.sondahub.com/stomp, then each frame as a message — CONNECT first. More on AMQP · AMQP 1.0 · STOMP.
NATS
A NATS server with JetStream at wss://api.sondahub.com/nats for clients that speak NATS over WebSocket, and at nats://localhost:4322 for the rest through the bridge (node bridge.mjs nats). The hub publishes on fleet.telemetry, store.orders and the other feeds, keeps them in a stream per API, and answers requests: orders.create takes an order, rpc.store.getProduct and every other call answers. From Sonda, a WebSocket request to that address with the protocol as text lines — CONNECT {}, then SUB fleet.telemetry 1. More on NATS.
Redis
Redis clients go through the bridge: run node bridge.mjs redis and point a Redis item at localhost:6479 — not 6379, so a Redis you already run keeps its port. Database 0 is full and moving: streams like fleet:telemetry with pub/sub channels of the same names, a hash per device and currency pair, and orders:incoming, read by the hub’s own consumer group. To try commands from Sonda, a WebSocket request to wss://api.sondahub.com/redis takes them as text — HGETALL bank:fx:EUR/USD — and answers in RESP. More on Redis.
FIX
A FIX acceptor, SONDAHUB, for FIX 4.2, 4.4 and 5.0 SP2: run node bridge.mjs fix and point an initiator at localhost:9976 with TargetCompID SONDAHUB and a SenderCompID of your own. Orders on currency pairs fill against the bank API’s live quotes; market data streams as they move. From Sonda, a FIX item sending to localhost:9976, with TargetCompID SONDAHUB and a SenderCompID of yours under Session, TLS off. Without the bridge, a WebSocket request to wss://api.sondahub.com/fix takes messages typed with | between fields — no BodyLength or CheckSum needed. Sonda’s FIX setup, field by field.
HL7 v2
POST an HL7 v2 message to https://api.sondahub.com/hl7 — segments ending in a carriage return — and the ACK comes back in the answer: AA, or AE with an ERR segment for each problem. Ready messages are at https://api.sondahub.com/hl7/samples. For MLLP over TCP, run node bridge.mjs hl7 and send to localhost:2675 — in Sonda, a new HL7 interface with localhost:2675 where it asks where to send, then Connect and paste a message under Send. More on HL7.
MCP
An MCP server at https://api.sondahub.com/mcp, Streamable HTTP, stateless. Any MCP client that speaks Streamable HTTP connects with just the address; Sonda can also talk to it as plain HTTP — POST a JSON-RPC message to that address. The tools, resources and prompts. The same server behind OAuth is at https://api.sondahub.com/mcp/secure: a client that implements the MCP authorization flow discovers everything from the 401. The flow, step by step.
OPC UA, Modbus, HART-IP and DDS
Each over a WebSocket of its own. OPC UA at opc.wss://api.sondahub.com/opcua, the WebSocket mapping of OPC UA Part 6 (subprotocol opcua+uacp, SecurityPolicy None, anonymous or any user). The Modbus TCP gateway at wss://api.sondahub.com/modbus and the HART-IP loop at wss://api.sondahub.com/hart-ip take their frames as binary messages exactly as they travel on TCP — or JSON as text, so a WebSocket request in Sonda can drive them: {"unit":1,"function":3,"address":0,"count":10}, {"command":3,"tag":"PT-101"}. For a tool that speaks only TCP, the bridge opens the usual port on your computer. The industrial protocols.
DDS goes through the bridge too: run node bridge.mjs dds, and in Sonda’s DDS settings choose Peers only with the peer 127.0.0.1 on the loopback interface, with the types from sondahub-dds.idl. The bridge also serves Fast DDS’s TCP transport on port 5100, and with --secure DDS Security, using the playground certificates. A WebSocket request to wss://api.sondahub.com/dds speaks JSON instead: {"subscribe":"*"}. The DDS simulator.
Authentication
The auth test endpoints hold one endpoint per scheme, checked for real, and the OAuth 2.0 test server runs every grant, dynamic client registration included. The credentials are printed at the top of the utilities page.
SCIM and SAML
SCIM 2.0 at https://api.sondahub.com/scim/v2 with Authorization: Bearer sonda-scim-token — in Sonda, a Bearer token in the auth editor. The SAML identity provider's metadata is https://api.sondahub.com/saml/metadata; the test service provider's is https://api.sondahub.com/saml/sp/metadata. Both sit on the Identity API's people. SCIM · SAML.
Sandboxes
Stand-ins for vendors’ APIs, at their own paths on the API host: Stripe’s /v1/… with any sk_test_ key as a Bearer token, Twilio’s /2010-04-01/…, /verify/v2/… and /lookups/v2/… with Basic auth, SendGrid’s /v3/… with any SG. key as a Bearer token, Authorize.net’s /xml/v1/request.api with the credentials in each XML or JSON body (and /rest/v1 with Basic auth for its webhooks), OpenAI’s /v1/chat/completions, /v1/responses and /v1/embeddings with any sk- key as a Bearer token, and Anthropic’s /v1/messages with any sk-ant- key in x-api-key and anthropic-version: 2023-06-01. In Sonda, an Authorization header — Bearer or Basic with the key — for Stripe, Basic auth for Twilio, a Bearer token for SendGrid and OpenAI, an API key header (plus the version header) for Anthropic, and nothing for Authorize.net’s calls (the bodies carry the login); send X-Sondahub-Session back to keep what you made. Each one imports like an API: Import → From a URL with https://api.sondahub.com/sandbox/stripe/openapi.json, https://api.sondahub.com/sandbox/twilio/openapi.json, https://api.sondahub.com/sandbox/sendgrid/openapi.json, https://api.sondahub.com/sandbox/authorizenet/openapi.json, https://api.sondahub.com/sandbox/openai/openapi.json or https://api.sondahub.com/sandbox/anthropic/openapi.json. The secrets managers import the same way, from https://api.sondahub.com/sandbox/{aws-secrets-manager, azure-key-vault, google-secret-manager, 1password-connect, doppler, infisical}/openapi.json: AWS Signature Version 4 (service secretsmanager) for AWS, a Bearer token for the rest. The sandboxes.
Controls on any request
Headers that make any endpoint misbehave on purpose, or call you back — add them to any request, in Sonda or any other client:
X-Sondahub-Chaos: latency=800,jitter=200,fail=0.2,status=503 | Slow answers, failures at a rate, cut-off bodies. Chaos |
X-Sondahub-RateLimit: 10/60 | A quota with RateLimit headers and 429s. Rate limits |
Idempotency-Key: … | In a session: the first answer to a write, replayed; 422 for the same key on another request. Without one: the same key, the same new id. |
Accept: text/csv (xml, yaml, ndjson, msgpack) | Another format for the JSON answer to a GET. |
Accept: application/problem+json | Errors as RFC 9457 problem details. |
X-Sondahub-Webhook: https://… | Every write POSTs a signed event there. Webhooks |
And to mock an API that is not here, the OpenAPI mock server turns any OpenAPI or Swagger file into a working endpoint.
Not Sonda
Everything is plain HTTP, so curl, a browser, or any client works the same way. The examples on every page run from the page itself. And the data is just files: every collection as JSON.