Desktop macOS · Windows · Linux

Every protocol. Real git.
No account.

Your app talks REST, sockets, subscriptions and gRPC. Your API client should too, and the collection describing it should be reviewable like any other code. KnockPort does both, from files on your own disk, with nothing to sign into.

Download KnockPortSee what's different

Free forever · No account required · Works offline

KnockPort showing a request returning 200 OK in 2.2 ms, with the JSON response syntax-highlighted beside its headers and timing.

One app, one request model

RESTGraphQLWebSocketServer-Sent EventsMQTTSocket.IOgRPC

Why KnockPort

Four things you've learned to live with

You shouldn't have to.

Four tools for one feature

Your REST client can't open a socket, so you keep wscat, an MQTT client and a GraphQL playground open beside it.

REST, GraphQL, WebSocket, SSE, MQTT and Socket.IO all live in the same window, in the same folders.

Realtime you can't save

Clients that do support sockets treat them as a scratchpad. Close the tab and the URL, the subscribe frame and the topics are gone.

A socket is an ordinary saved request. Its messages, topics and variables travel with your collection.

Sign in to use your own work

Your collections sit in someone else's cloud behind an account, and a flaky connection means you can't test anything.

No account, and your requests, collections and tokens never leave your machine - it works fully offline, and syncs through your own git when you want it. The only thing it sends is an anonymous install-count ping per version: a random id and the version number, no request data.

Auth that almost works

The moment you need mTLS, NTLM, Digest or a service on localhost, the browser-based tools quietly can't.

Sending happens on your machine, so private networks, client certificates and eight auth schemes all just work.

An API surface nobody can review

Your collection changes in someone's cloud. There is no diff, no branch, no review, and no way to tell what changed between two releases.

Collections are plain files, and git is built in. Branch, commit, diff and amend in the app; open the pull request where you open every other one. The app itself is source-available too - every release ships its full source to read and audit.

Git, built in

Review an API change like code

Collections are plain files, so a change to a request is a diff you can read and revert - not a mystery edit in someone's cloud workspace. Branch, commit and amend in the app, then open the pull request wherever you open every other one.

  • See exactly what changed, line by line
  • One request per file, ordered keys - built to diff cleanly
  • Push to GitHub, GitLab or your own remote
KnockPort's Source Control panel: a collection's requests tracked as individual YAML files, staged for commit, with one request's diff shown line by line.

Realtime, done properly

A socket you can save, share and re-run

Most clients bolt sockets on as one global panel that forgets everything the moment you close it. In KnockPort a WebSocket sits in a folder next to your REST calls, with its messages and subscriptions saved alongside it.

  • {{baseUrl}} works in socket URLs, topics and payloads
  • Keep the frames you send often instead of retyping them
  • Filter and pause a live stream without dropping the connection
A live WebSocket session in KnockPort, listing timestamped incoming messages with their sizes.

Streams you can read

Every event, labelled and in order

Server-sent events carry names and ids. Tools that render them as one undifferentiated blur make you squint at a wall of text, or show you nothing at all and call it working.

  • Each event type colour-coded at a glance
  • Search a running stream without disconnecting
  • Export the whole session when you need to share it
KnockPort showing a server-sent event stream with info, warning and error events distinguished by colour.

Coming from somewhere else

What changes on day one

Import what you already have from Postman, Insomnia, Bruno, OpenAPI, HAR or a curl command, then notice what you stop working around.

Open a WebSocket, SSE stream or MQTT topicEvery protocol, in the same app
Save that socket into a collectionSame folders, same variables, same tests as REST
Use {{variables}} in a socket URL or payloadResolved everywhere, not just in REST
Keep collections as files you can review in a PRPlain YAML, one file per request
Work with no account and no internetNothing to sign into; your work is never uploaded
Reach localhost, mTLS and private networksRequests leave from your machine, not a proxy
Bring what you already haveImport Postman, Insomnia, Bruno, OpenAPI, HAR and curl
Branch, commit and diff without leaving the appReal git, not a change log
Read the app's own source, not just your collectionsSource-available under the FSL; MIT plugin SDK
Run the scripts you already wrotepm.*, bru.* and chai run unchanged

Everything else

The parts you'd expect, done well

Collection runner

Run a folder end to end, with tests, and see every response.

Mock servers

Serve an endpoint back before the backend exists.

Scripts and tests

Pre-request and post-response JavaScript, assertions that fail loudly.

Environments

Swap dev, staging and prod without touching a request.

Eight auth schemes

Basic, Bearer, OAuth 1 & 2, Digest, NTLM, Hawk and WSSE.

Redirect chains

Every hop, with its own timing breakdown.

Code generation

Turn any request into curl, JavaScript or Python.

Response tooling

Filter, prettify, diff against saved examples, snapshot.

Git, built in

Branches, commits, diffs and amends over your collection files.

Your existing scripts

pm.*, bru.* and chai run as they are. No rewrite.

Import anything

Postman, Insomnia, Bruno, Hoppscotch, OpenAPI, HAR and curl.

gRPC

Unary and streaming, with reflection and a stream view.

Plugins

A versioned SDK for importers, themes and protocols.

Command palette

Every action, one keystroke away.

Cookie jar

Per-collection, inspectable, and it survives a restart.

History

Every request you send, saved and searchable - reopen any of them.

On the way

What we're building next

None of this is in the app yet. It is here so you can tell where KnockPort is going before you commit a team's collections to it.

KnockPort on the web

The same app in a browser tab, for when you cannot install one. It shares the collection format rather than reimplementing it.

An agent that can drive it

Describe the call you want and have it built, run and asserted against, with the request left in your collection to read rather than hidden behind a chat log.

MCP support

Expose your collections as tools an AI assistant can call, and consume MCP servers as requests like any other protocol.

Performance testing

Take a collection you already have and run it under load, from the same file, without rewriting it as a script.

Try before you install

A live API to point it at

KnockPort opens with a ready-made collection wired to a public demo API that speaks every one of them. Press Send and watch a login token flow straight into the next request, with nothing to set up.

Or poke at it from your terminal
# see your own request, reflected back
curl https://knockport.com/echo -d '{"hello":"knockport"}'

# a live stream you can watch arrive
curl -N 'https://knockport.com/sse/ticks?count=5'

Download KnockPort

The desktop app is the whole product: every protocol, your files on your disk, and requests that leave from your machine, which is what makes localhost, client certificates and private networks work at all.

Get KnockPort on macOS

curl -fsSL https://knockport.com/install.sh | sh
Prefer Homebrew or a direct .dmg?
brew install --cask transmitworks/tap/knockport
Apple silicon .dmgIntel .dmg

After Homebrew, clear the download flag once: xattr -dr com.apple.quarantine /Applications/KnockPort.app (Homebrew dropped the --no-quarantine flag in 6.x).

Verifies its SHA-256 and installs to Applications. A direct .dmg is refused on first launch as "damaged" until you clear quarantine, because KnockPort is not notarized by Apple yet (see Privacy).

Get KnockPort on Windows

curl -fsSL https://knockport.com/install.bat -o "%TEMP%\kp.bat" && "%TEMP%\kp.bat"

Prefer PowerShell? This does the same:

Invoke-RestMethod https://knockport.com/install.ps1 | Invoke-Expression
Prefer a direct download?
Installer .exeMSI .msi

Verifies its SHA-256 and runs the installer. A command-line download avoids the SmartScreen warning a browser download triggers, because KnockPort is not code-signed yet (see Privacy).

Get KnockPort on Linux

curl -fsSL https://knockport.com/install.sh | sh
Prefer a distro package?
Debian / Ubuntu .debFedora / RHEL .rpmArch / any distro .AppImage

Downloads the AppImage to ~/.local/bin and verifies its SHA-256. Prefer a native package? Use the .deb or .rpm above.

All downloads and past releases

v0.4.1. The complete API client, free forever - no account to create.