PUT, PATCH, and DELETE Requests in Postman

PUT, PATCH, and DELETE Requests in Postman

A complete REST API testing workflow requires mastery of all HTTP methods. After GET and POST, PUT, PATCH, and DELETE complete the CRUD (Create, Read, Update, Delete) cycle. Understanding the difference between PUT and PATCH — a common interview question — is particularly important for any developer working with REST API testing in Postman.

PUT — Full Resource Replacement

PUT replaces an entire resource with the data you provide. If you omit any fields in the body, they will be set to null or their default values on the server. Always send the complete representation of the resource when using PUT.

PUT https://jsonplaceholder.typicode.com/posts/1

{
  "id": 1,
  "title": "Updated Title - Full Replacement",
  "body": "This replaces the entire post content.",
  "userId": 1
}

A successful PUT returns 200 OK with the updated resource. The key distinction: if you send only the title field in a PUT request, the body and userId fields would be cleared on a real server (JSONPlaceholder returns them, but it is simulated).

PATCH — Partial Update

PATCH updates only the specific fields you include in the request body. The server merges your changes with the existing resource — fields you do not include remain unchanged.

PATCH https://jsonplaceholder.typicode.com/posts/1

{
  "title": "Only the Title Changed"
}

The body and userId remain exactly as they were. PATCH is more efficient than PUT when you only need to update one or two fields in a large object — you send less data and avoid accidentally clearing fields.

DELETE — Remove a Resource

DELETE removes a resource from the server. Most DELETE requests have no body. The response is typically 204 No Content (success, nothing to return) or 200 OK with a confirmation message.

DELETE https://jsonplaceholder.typicode.com/posts/1

In Postman, select DELETE, enter the URL, and click Send. Do not add a body. The response should be 200 OK with an empty object {} from JSONPlaceholder — in production APIs it would typically be 204 No Content.

PUT vs PATCH — When to Use Each

Aspect	PUT	PATCH
Updates	Entire resource	Specific fields only
Missing fields	Set to null/default	Remain unchanged
Idempotent	Yes	Not guaranteed
Payload size	Full resource	Only changed fields
Use when	Replacing the whole object	Updating specific properties

Headers for Update Requests

For PUT and PATCH requests, always include the Content-Type: application/json header (Postman sets this automatically when you choose raw JSON). For DELETE requests, no Content-Type header is needed. For all requests hitting authenticated APIs, include the Authorization header.

Testing All CRUD Operations Together

A complete CRUD test flow on the same resource looks like this:

• POST /users — Create a user, save the returned ID
• GET /users/{id} — Read the created user, verify all fields
• PUT /users/{id} — Replace the user with updated data
• PATCH /users/{id} — Update a single field
• DELETE /users/{id} — Delete the user
• GET /users/{id} — Verify deletion returns 404 Not Found

Key Takeaways

• PUT replaces the entire resource — send all fields. Correct response: 200 OK.
• PATCH updates specific fields only — send only changed fields. Correct response: 200 OK.
• DELETE removes a resource — no body needed. Correct response: 204 No Content or 200 OK.
• Test all CRUD operations in sequence on the same resource ID for a complete test flow.