Postman lets you test an API without a frontend: build HTTP requests, read status codes and JSON, check auth and errors, and run saved collections in one go.
Postman, explained by cats. Kitty builds an API. But how does she test it? She doesn’t want to build a whole frontend just to see if it works. Too much effort. So Kitty uses Postman. Postman lets Kitty send HTTP requests directly to her API.
GET. POST. PUT. DELETE. She types the URL. Adds headers. Adds a body. Clicks send. Boom. Response appears. Status code. JSON data. Everything visible. Kitty can test authentication. Check tokens. Simulate errors. She can even save requests in collections. Run them automatically.
Test entire APIs at once. Postman is like a manual control panel for talking to servers. No frontend needed. No guessing. That’s Postman. the tool Kitty uses to poke her API until it behaves
Postman is an app for sending HTTP requests to an API by hand and reading exactly what the API sends back.
It lets you test a backend before any frontend exists, so you can find out whether the API works without building a UI to ask it.
Why test an API without a frontend
A backend on its own has no buttons. It waits for HTTP requests and answers them. Building a frontend just to try one endpoint is slow, and when something breaks you can't tell whether the bug is in the UI code or in the API behind it.
Talking to the API directly removes that layer. You send a request, the server answers, and what you see is the API's real behaviour, with nothing in between to hide or change it.
You could do the same with curl in a terminal, and plenty of developers do. Postman puts the job in a window: a form for each part of the request, a formatted response, and a history of everything you sent. That makes it quicker to try things out, and easier to share what you tried with a team.
What goes into a request
Every request Postman sends is built from the same few parts, and each has its own field or tab.
The method
The method says what you want the server to do:
GET reads data.
POST creates something new.
PUT replaces something that already exists (PATCH changes part of it).
Postman, explained by cats. Kitty builds an API. But how does she test it? She doesn’t want to build a whole frontend just to see if it works. Too much effort. So Kitty uses Postman. Postman lets Kitty send HTTP requests directly to her API.
GET. POST. PUT. DELETE. She types the URL. Adds headers. Adds a body. Clicks send. Boom. Response appears. Status code. JSON data. Everything visible. Kitty can test authentication. Check tokens. Simulate errors. She can even save requests in collections. Run them automatically.
Test entire APIs at once. Postman is like a manual control panel for talking to servers. No frontend needed. No guessing. That’s Postman. the tool Kitty uses to poke her API until it behaves
In a REST API the same URL can do different things depending on the method, so in Postman you pick it from the dropdown beside the address bar. REST API best practices covers how a well-designed API uses them.
The URL and query parameters
The URL says which resource you mean, such as http://localhost:3000/cats?colour=ginger. Postman's Params tab splits the query string into key and value rows and keeps the address bar in step, which is easier to edit than a long URL.
Headers
Headers carry information about the request rather than the data itself: what format the body is in (Content-Type), what format you'd like back (Accept), and who you are (Authorization). Postman adds a few automatically and lists them as hidden headers, so you can check what was really sent.
The body
A POST or PUT usually carries a body. For a JSON API, choose 'raw' and 'JSON', then type the data:
{ "name": "Mochi", "colour": "ginger"}
Then click Send.
Reading the response
The response appears under the request: the status code, how long it took, its size, the body and the response headers. JSON bodies are formatted and coloured, so nested data is easy to read.
The status code is the first thing to check. Its first digit tells you who is at fault:
2xx means it worked: 200 OK, or 201 Created after a POST.
4xx means the request was wrong: 400 Bad Request, 401 Unauthorized, 404 Not Found.
5xx means the server failed: 500 Internal Server Error usually points at a bug or a crash in your code.
A worked example
Say you've built a small cat API and want to check it end to end:
POST the cat above to /cats. A well-behaved API answers 201 Created with the saved cat, now with an id such as 42.
GET /cats/42. You should get 200 OK and the same cat back.
DELETE /cats/42. Expect 204 No Content or 200 OK.
GET /cats/42 again. Now the answer should be 404 Not Found.
That checks the whole lifecycle of a resource in about a minute. If step 1 returns a 500 instead, the server failed to handle the request. Inspect both the response and the request you sent: malformed test input can still expose a server-side bug.
Testing authentication and errors
Most APIs protect some endpoints. Postman's Authorization tab can add a bearer token, basic auth, an API key or an OAuth 2.0 flow, and it writes the right header for you. With a bearer token, every request carries:
Authorization: Bearer eyJhbGciOiJIUzI1NiJ9...
Testing auth means checking that the wrong requests fail, not just that the right ones succeed:
No token at all should get 401 Unauthorized.
An expired or edited token should also get 401.
A valid token for a user who isn't allowed to do this should get 403 Forbidden.
401 versus 403 is the difference between authentication (who you are) and authorisation (what you may do), covered in Authentication vs Authorization.
Errors are tested the same way. Send a body with a required field missing, a number where a string should be, or an id that doesn't exist. A good API answers each with a clear 4xx and a message saying what was wrong, never a 500 and a stack trace. This is awkward to do from a frontend, because a well-built form stops you sending bad data in the first place. Postman sends whatever you type, so you see how the API itself copes.
Collections, variables and automated runs
Saving a request puts it in a collection: a named group of requests, with folders if you need them. A collection for the cat API might hold 'Log in', 'Create cat', 'Get cat', 'Update cat' and 'Delete cat'.
Variables and environments
Typing http://localhost:3000 into every request breaks the moment you want to test a staging server. Write {{baseUrl}}/cats instead, and set baseUrl in an environment: a named set of variable values, one for local and one for staging. Switching environments from the dropdown points every request at the other server.
Test scripts
Each request can run a script after the response arrives, written in JavaScript with Postman's pm object:
pm.test("returns 201", () => { pm.response.to.have.status(201);});pm.test("cat has an id", () => { const cat = pm.response.json(); pm.expect(cat.id).to.exist;});
A script can also save a value for later requests. After 'Create cat', pm.environment.set("catId", cat.id) stores the new id, and 'Get cat' can ask for {{baseUrl}}/cats/{{catId}}. The same trick lets 'Log in' save a token that every other request then sends.
Running the whole collection
The Collection Runner sends every request in a collection in order and reports which tests passed and which failed. To run the same checks in a CI pipeline, Postman's command-line runners (Newman, or the newer Postman CLI) run an exported collection and fail the build if a test fails:
newman run cats.postman_collection.json
Common mistakes
Treating 'it works in Postman' as 'it works'. Postman isn't a browser, so browser rules such as CORS don't apply to it. An endpoint that answers fine in Postman can still be blocked when your frontend calls it from another origin.
Sending JSON as plain text. If the body type is left on Text, the request goes out as text/plain, and many frameworks won't parse it, so the server sees no fields at all. Pick JSON.
Putting secrets in shared collections. Shared collection and environment values can be available to teammates through Postman's cloud. Keep production credentials out of shared values; use Postman Local Vault for secrets that must stay on your machine, rather than relying on visual masking.
Testing only the happy path. Bugs in validation and auth only show up in requests that should fail, such as a missing token or a bad body.
Hardcoding URLs and ids. Use variables, or the collection only works on your machine, against your data.
When to use it
Postman suits exploring an API you've just built or one you're about to call, reproducing a bug report, and sharing working example requests with a team. For tests that should run every time the code changes, unit and integration tests in your own test framework are usually the better home: they live next to the code and are versioned with it.
Postman also isn't the only option. curl and HTTPie do the same from a terminal, and Bruno keeps collections as plain files you can commit to Git. Pick whichever one your team will keep up to date.
Key takeaways
Postman sends HTTP requests straight to an API, so you can test a backend without building a frontend.
A request is a method, a URL, headers and an optional body; the response brings back a status code, headers and a body, usually JSON.
Test the failures too: missing tokens, bad input and unknown ids should get clear 4xx answers, never a 500.
Collections, variables and test scripts turn one-off requests into a suite you can rerun, in the app or from the command line.
A request that works in Postman doesn't prove a browser can make it, because CORS only applies in browsers.