You install Postman, open it, and hit a sign-in screen. Somewhere below the buttons is a smaller option: continue without an account, into what Postman calls the lightweight API client. If you're here, you probably want to know how far that path actually goes. Maybe your company restricts cloud tools, maybe you work in an air-gapped environment, or maybe you simply don't think sending requests to localhost should require an account.
Here's exactly what works without signing in, what doesn't, and what happens to your data if you sign in later, all verified against Postman's own documentation. Plus what to use when "mostly local" isn't enough.
Without an account, Postman's lightweight API client is a request sender: you can make calls, read responses, and keep a local history. What you can't do is organize anything: no collections, no environments, no saved workflow. It's a scratchpad in the original sense: useful for one-offs, not a place to build.
Per Postman's documentation (checked August 2026):
| Capability | Without an account |
|---|---|
| HTTP, GraphQL, gRPC, WebSocket, Socket.IO, MQTT requests | ✓ |
| Send requests & inspect responses | ✓ |
| Request authentication | ✓ |
| Post-response scripts & tests | ✓ (pre-request scripts aren't listed in the docs) |
| Response visualization | ✓ |
| Request history | ✓ stored locally, shown in the sidebar |
| Collections (saving & organizing requests) | ✗ requires sign-in |
| Environments & variables | ✗ requires sign-in |
| Workspaces, sync, collaboration | ✗ requires sign-in |
The line Postman's docs draw is clear, and worth quoting: "All of your work in the lightweight API Client is stored locally and isn't synced online with Postman." Local-only, that is, until you sign in. More on that below.
If this setup feels new, it's because Postman used to work differently. Scratch Pad was Postman's account-free mode, and it supported collections. Then, in 2023:
Postman's stated reason was engineering cost: maintaining separate offline and cloud architectures consumed, in their words, "2x–4x the amount of time" as new protocols were added. That's a fair business decision to make. Postman is a collaboration platform, and cloud workspaces are the product. But it means the account-free path went from "Postman, minus sync" to "a request console, minus everything else." The community threads asking to bring offline mode back have been running ever since.
Used for what it is, the lightweight client is fine: poking at a local service, checking an endpoint's response shape, firing a quick gRPC or WebSocket call without leaving a GUI. Auth on a single request works. You can write post-response tests. Your recent calls sit in the history sidebar.
The friction starts the moment you have two related requests, because there's nowhere to put them. No collection to group them, no environment to hold the base URL you're now pasting into both, no way to hand your setup to a teammate.
The lightweight client's local-only storage has an expiration condition: signing in. Per Postman's docs, when you sign in, "your open requests and request history are automatically copied from the lightweight API Client to your default workspace" (or one you select). That's convenient if you wanted an account all along. It's also exactly what you need to know about in advance if keeping work off third-party infrastructure was the reason you avoided signing in. There's no long-term "local mode with collections"; the workflow features and the cloud arrive together.
For the privacy-focused: what an API client transmits is a bigger topic than one post, so we'll publish a fuller look at API-client data flows separately. The short version for now is above, in Postman's own words: lightweight-client work stays local until you sign in; signed-in Postman is built around cloud sync.
Full disclosure, since you're on Bruno's blog: this is where we tell you about Bruno. We'll keep it factual.
Bruno is an open-source API client built on the opposite architecture: there is no account to sign in to, and there is no sync service to send anything to. Collections, environments, and tests are plain files in a folder you choose, which means the features Postman gates behind sign-in are simply… local:
| Capability | Postman (no account) | Bruno |
|---|---|---|
| HTTP / GraphQL / gRPC / WebSocket requests | ✓ | ✓ |
| Socket.IO / MQTT | ✓ | ✗ |
| Collections | ✗ | ✓ local files |
| Environments & variables | ✗ | ✓ local files |
| Secrets | n/a | ✓ stored encrypted, outside collection files |
| Run whole collections + tests | ✗ | ✓ app Runner or CLI (bru run) |
| Team sharing | ✗ (cloud workspaces only) | ✓ Git: clone, branch, PR |
| Account required | for everything beyond one-off requests | never |
| Works air-gapped | partially | fully |
Two honest notes. First, if your team lives in shared cloud workspaces with mocks and monitors, Postman's model is the point, not the problem. Bruno's collaboration story is Git, which suits teams that already review everything as code. Second, the Socket.IO/MQTT row above goes to Postman; Bruno doesn't support those protocols today.
If the local-files model fits how you work, the on-ramp is short:
Yes. The lightweight API client works without sign-in and supports HTTP, GraphQL, gRPC, WebSocket, Socket.IO, and MQTT requests, with local request history and post-response scripts. Collections, environments, and workspaces all require an account.
The account-free lightweight client stores everything locally and doesn't sync with Postman's servers, per Postman's docs. The full, signed-in product is built around cloud workspaces and sync.
Postman stopped shipping Scratch Pad with new downloads on May 15, 2023, when it announced the lightweight API client; the deprecated Scratch Pad mode ended for existing users on September 15, 2023, with a migration tool that moved local work into cloud workspaces.
Locally on your machine. Postman's docs state lightweight client work "is stored locally and isn't synced online." If you later sign in, your open requests and history are automatically copied into a Postman workspace.
Bruno, an open-source, Git-friendly API client with no account at all: collections, environments, tests, and secrets all live as local files, shareable through Git and runnable in CI via its CLI.
Postman without an account is a capable request console and nothing more. That's by design, and Postman is transparent about why. If one-off requests are all you need, it does the job. The moment you need collections, environments, and tests that live somewhere (offline, in your repo, under your control), that's not a workaround away in Postman. It's a different architecture.
Download Bruno: no account, no sync, no sign-in wall between you and your own API workspace.