/ 02 — API CLIENT · AIR-GAPPED

The API client that never leaves your side.

Requests, collections, environments, scripts, checks and imports — the whole desk — and then what an enterprise or a regulated organization needs underneath it: nothing of yours ever sits on a vendor's server, the team store is on storage you own, and the controls are enforced by the backend, not by a checkbox. Free forever up to 10 seats, every capability included; $5 a seat a month past them, billed by the year.

NO ACCOUNT NO VENDOR CLOUD 74 PROTOCOLS FREE FOREVER UP TO 10 SEATS
Your computer and your own storage talk to each other, sealed; LockFlare stands outside the gap and holds nothing. YOUR SIDE · NOTHING LEAVES IT your computer projects sealed under your password your storage S3 · Git · SFTP · Sonda Server sealed · a key per project, wrapped per reader · every file signed, every signer checked · secrets resolved at send, never written · no account, no telemetry, no update check THE AIR GAP LockFlare holds nothing reaches nothing
Everything an API desk does. Nothing a regulated organization cannot have.
74 protocolsREST to Kafka to Modbus, from one desk
Local-first, air-gappedYour computer, your storage, no vendor cloud
Enforced by the backendPermissions, approvals, locks — not a checkbox
/ WHAT ONLY SONDA DOES

Eight things you will not find on another API desk.

Each one is in the build you download today, free, with no account. Each links to its own page, and to the capability list where every line is something the code does.

/ 01 · PROTOCOLS

74 protocols from one desk.

HTTP and GraphQL, gRPC in all four shapes with reflection, WebSocket, Socket.IO and SSE. The brokers: Kafka, RabbitMQ, NATS, AMQP 1.0, Redis streams, STOMP. The verticals: FIX for the trading desk, HL7 v2 over MLLP and FHIR for the hospital, OData, SOAP, MCP for the AI tools. And the plant floor: Modbus, OPC UA, HART-IP and DDS devices are items of a project like any request — a tank level crossing a line can start a flow that calls your APIs.

One project holds all of them, with the same variables, the same auth, the same checks, the same people.

Every protocol, listed
/ 02 · VIRTUAL MACHINES

Linux servers inside the client.

Sonda Virtual Machine runs small Linux servers on your Mac or PC, each a tab with its own console and its own address. Install nginx, Node, Python, Go, PostgreSQL or Redis from a menu, run your API there and call it from any request — the same desk, no Docker, no cloud, nothing else installed.

One click puts up a sample deployment — API, database, website, nginx — with the project that calls it, so a newcomer has something real to send to in the first five minutes.

The machines
/ 03 · DOCUMENTATION

Documentation that writes itself from the project.

The project already knows its requests, their descriptions, the examples kept from live answers, the checks and the specification it was imported from. Sonda writes the documentation from that, as it stands now: one self-contained HTML file to hand to anyone, or OpenAPI 3.1, 3.0 or Swagger 2.0 as JSON or YAML — with code samples in cURL, raw HTTP, fetch, Go and Python, variables filled in, inherited auth applied, and auth values never written out.

Change the project and write it again. Themis can write the descriptions for you.

Specs, imports and documentation
/ 04 · APPROVAL FLOWS

Approval flows the backend enforces.

A change to a shared project is submitted and frozen — nothing moves until it is approved or sent back. The flow has stages and quorums: two of three reviewers, then one of security, then it is published for the team. Who sits in each stage is the project's own signed file, read by every Sonda; a submission nobody approved is not published, whoever tries, by whatever door — a shortcut, a drag and drop, an import or Themis meet the same rule.

Locks hold a component while someone works on it. Every step goes to the activity log.

Approvals, locks and merge
/ 05 · DISCOVER

The API behind any application, written for you.

Use the application — in a browser Sonda opens, on a phone through Sonda's proxy, or from a HAR file — and Sonda writes the API behind it: the endpoints with their ids turned into variables, trackers and static files left out, GraphQL split by operation, the token and the call that issued it, a flow that replays the session, and a mock that answers like the real thing.

Nothing captured is written to disk. Under the organization's Discovery rules, when there is one.

Discover
/ 06 · FLOWS AND APPS

Flows that start from a message. Apps over your APIs.

A flow is a canvas of calls and steps — branches, waits, inputs — run in order or on a trigger: a message on a broker, a reading from a device, a tag that moves. An app puts screens and dashboards over your own APIs — fields, buttons, tables, charts — for the people who never see a request. They get a runner seat that runs the apps it is given and nothing else.

Functions and watchers run on a schedule or on an event, in the app, on your computer.

Flows · Apps and runners
/ 07 · SCHEDULES

Your APIs watched around the clock, inside your network.

Sonda Server — one program on a Linux or Windows box of yours — runs a request, a folder or a whole project every minute, every hour, daily or weekly, with its scripts and checks, from inside your network. Mail or a webhook when it breaks and again when it recovers, a summary every day or every week, trends on every schedule. An advanced run signs in first, fetches a list and runs the target for each row.

Every run is sealed under the project's key; the server reads only what is sealed for the key you paired.

Schedules and alerts · Sonda Server
/ 08 · THE TEAM STORE

A team store on storage you own. Divisions sealed apart.

The team works through Git, S3, Cloudflare R2, Azure Blob, Google Cloud Storage, Backblaze B2, SSH, WebDAV or MongoDB — or a Sonda Server, which holds the store's credential so no member computer does. Encrypted before it leaves the computer: a key per project, wrapped for each reader; every file signed, a signer the roster does not name refused. Access to the bucket alone decrypts nothing.

An organization is divisions, each with its own administrators and its own key — Payments opens nothing of Platform's. An invitation grants exactly what you say: a whole division, some of its workspaces, or some projects, for the organization's own people or an external guest, until a day you set.

The team store · Organizations and divisions
/ AND THE REST OF THE DESK

The things you expect, done the air-gapped way.

Nothing here needs an account, a cloud or a server of ours. Secrets never touch a file; a private API is reached through a server you already have; the AI is yours.

Secrets resolved at send

A secret:// reference is resolved at send from HashiCorp Vault, AWS Secrets Manager, Azure Key Vault, Google Secret Manager, 1Password, Doppler or Infisical, cached in RAM and masked on the way back — never written to the workspace or the team store. Or Sonda's own vault: a fresh 256-bit key per secret, wrapped per reader.

Via: send from where the API is reachable

An IP-whitelisted API, a private network, a box behind a bastion: Via runs the request from any server you can SSH into, with TLS carried inside the SSH channel and the host key verified. Nothing is installed on that server.

Checks, runner, load

Checks as sentences on every response, a runner for whole folders with datasets and reports, load tests with ramp-up, percentiles and pass criteria. Every send kept and diffed against the last.

Echo: a mock that answers instead of the API

An Echo answers at echo://name/path instead of a real API — from a data set that remembers what you posted, from a body with placeholders, from a script, or from a flow. A database becomes endpoints at sonda://name/path that any request calls, with every value bound and a switch that makes it read-only for real.

Themis AI, with your own key

Explains a parameter, drafts a request, a check or the documentation, reads an answer against the spec — with the provider and the key your organization chose, and the same permissions as the person asking. The seat is the division's; nothing goes through LockFlare.

Bring your work with you

Collections from the client you use today come across with their auth, scripts, variables and tests; OpenAPI, Swagger, WSDL, OData and FHIR specifications become projects and stay attached to them; a HAR file becomes an API. Scripts in JavaScript, Go or Python, with one sonda API.

/ EDITIONS

Free forever. All three editions.

One build, every capability, for everyone. The only number that matters is seats. Open an edition to see the three side by side — what each needs, where its work is kept, who holds what, and what it gives you.

Free forever

Solo

One engineer, one computer. Nothing to sign up for. Git-readable projects, the whole workspace sealed under your password, incognito requests that keep no history, response or cookie.

Every protocol. Every feature.

Compare the editions →
Free forever

Small Teams

Up to 10 seats free, with every enterprise capability included — $5 a seat a month past them, billed by the year. Collaborate through Git or storage you already own, or run Sonda Server on a box of yours. Nothing of the team's ever touches LockFlare.

Small teams have nothing to worry about.

Compare the editions →
Free forever up to 10 seats

Enterprise and Regulated

The same build. Organizations and divisions, backend-enforced permissions, approval flows, Entra and Okta provisioning, external secret managers, signed rosters, activity log.

Above 10 seats, $5 a seat a month, billed by the year — $60 a seat — as seat licenses, any number from 1 to 500 per purchase, each a year of use from the day it is assigned; the pool renews a seat on its own. A signed key, opened in your own store. How Sonda licensing works.

Compare the editions →
/ LOCKFLARE SONDA

1,687 capabilities, each one checked against the code that ships.

View all capabilities →
/ LOCKFLARE SONDA · THE THREE EDITIONS

The same build. Three places for the work to live.

Every edition is the whole of Sonda — every protocol, every feature. What changes is where the work is kept, what each computer holds, and who checks a sign-in. Pick the edition you are looking at.

SoloStandalone · one computer Small TeamsWithout Sonda Server · 10 seats free Enterprise and RegulatedWith Sonda Server · 10 seats free
What it needs
In place firstSonda on one computer and a password of at least 8 characters. No account, no server, no repository, nothing to sign up for.A repository of the team's own — Git, S3, Cloudflare R2, Azure Blob, Google Cloud Storage, Backblaze B2, an SSH server, WebDAV or a MongoDB database — and its credentials. Nothing to install, no server to run.A Linux or Windows server the company has access to. Sonda Server, one static binary, is installed on it before the organization is made, and the server is kept running.
Who runs itYou.Nobody on your side — the repository's own service does. No server administration.Your administrators. A setup in a terminal names the port, the address, the networks allowed and a token said once; then a service, started with the machine.
SeatsOne. No license, no expiry.Ten free forever, every capability included; $5 a seat a month past them, billed by the year.Ten free forever. Above them, $5 a seat a month, billed by the year as seat licenses — any number, 1 to 500 per purchase — each a year of use from the day it is assigned, on a signed key opened in your own store.
Where the security sits
Where the work is keptOn this computer only, sealed under your password — the key derived with Argon2id. There is no way to recover it: not by LockFlare, not by anyone.In the team's repository, reached by each computer directly. Encrypted before it leaves the computer: a key per project, wrapped for each reader. Access to the bucket alone decrypts nothing.On a server of the company's own, kept by Sonda Server — in a folder of that server's disk, or in a repository only the server signs in to. Sealed the same way: a key per project, wrapped per reader.
What each computer holdsYour projects, under your seal. No credential of anyone else's.What the repository signs in with: each ticket carries it, sealed, and each computer keeps it, sealed.The server's address and its token. What the store signs in with stays on the server; no member computer ever holds it.
Who gets inWhoever has the password, on this computer. There is no server to ask.Whoever holds the repository's credentials, as the repository's own service decides. Inside the store, the signed rosters decide: take a reader off a project and its key turns.A person who signs in with a username and a password the server checks itself — from a Sonda that carries the server's token, from the networks the server is told to answer. Ten failed sign-ins on a username in ten minutes, and none is taken for five. An account paused or revoked is refused at its next call.
On the wireNothing but the requests you send, to the hosts you send them to. No telemetry, no license check, no update check.The repository's own channel — HTTPS to the bucket, SSH with the host key pinned, Git over its own transport. Every document carries an Ed25519 signature; a reader accepts only the signers its collection allows.TLS 1.3 and up, on both ends; the server's certificate pinned by fingerprint and carried in every ticket. A call without the token is told nothing — an empty not-found, connection closed. A connection from outside the networks allowed is closed as it arrives.
Permissions and approvalsYours alone — there is nobody to approve or to restrict.Divisions, permissions the backend enforces, approval flows, locks, shared projects: the same Sonda for the team. Who may write what lives in the team's signed files, read by every Sonda — a file not signed by who may sign it is refused, and so is a permissions file older than the last one seen.The same, with the door in one place: the server checks every sign-in, reads the users index again when it changes and ends the sessions of an account closed — nothing has to be re-sent to every computer for it.
What it gives you
Made forOne engineer, one computer.Developers, small teams, startups, agencies.Government, defense, healthcare, finance — where the data must stay on the organization's own servers.
The benefit, in one lineThe whole client with no account, no cloud and no sync — offline, sealed, yours.Collaboration on storage you already own, with nothing to administer and nothing of the team's on any server but your own.One door to the store, on your own server, that checks every sign-in itself — and member computers that never hold the store's credential.
Scheduled runsWatchers in an app, every few seconds or at set times, while the app is open on this computer.The same, on each computer. Runs that go on with every computer closed need Sonda Server.Sonda Server runs requests, folders and whole projects on a cadence, inside your network — alerts by mail or webhook, a daily or weekly summary.
What LockFlare holdsNothing, in all three. No project, no credential, no telemetry, no license check — and no way to reach any of it.