How to Test DELETE API By Playwright

What Is a DELETE API? Complete Guide to Testing DELETE API Using Playwright Java

In modern web applications and RESTful services, APIs are the backbone of communication between client and server. While GET retrieves data, POST creates new resources, and PUT updates existing ones, the DELETE API is responsible for removing resources from the server.

If you are an automation tester, backend developer, or preparing for API automation interviews, understanding how DELETE API works and how to test it using Playwright Java is extremely important.

In this comprehensive guide, you will learn:

• What is a DELETE API?

• How DELETE API works in REST architecture

• Common response status codes

• Why DELETE API testing is important

• Step-by-step guide to testing DELETE API using Playwright Java

• Java code example with explanation

• How to validate deletion properly

• Negative test scenarios

• Best practices for DELETE API testing

This article is written in a natural, human-friendly tone, fully SEO optimized, and AdSense compliant for blog publishing.

What Is a DELETE API?

A DELETE API is an HTTP method used in RESTful web services to remove an existing resource from the server.

It typically requires a unique identifier (such as an ID) to specify which resource should be deleted.

Simple Definition

DELETE = Remove an existing resource from the server

Example of DELETE API

If you have a user stored in a database with ID 123, you can delete that user using:

DELETE /users/123

This request tells the server to remove the user with ID 123 permanently.

Common Response Status Codes for DELETE API

When testing a DELETE API, understanding response codes is essential.

Status Code	Meaning
200 OK	Deletion successful (with response body)
204 No Content	Deletion successful (no response body)
404 Not Found	Resource does not exist
401 Unauthorized	Authentication required
403 Forbidden	Permission denied
500 Internal Server Error	Server-side issue

Most DELETE APIs return 204 No Content when deletion is successful.

Why Test DELETE API?

Testing a DELETE API is critical to ensure system integrity and data safety.

Here’s why:

1. Confirm Resource Is Actually Removed

Just because API returns success doesn’t mean data is deleted. Testing verifies actual deletion.

2. Validate Correct Status Codes

Ensures server follows API contract.

3. Check Unauthorized Access Handling

Ensures only authorized users can delete data.

4. Prevent Accidental Deletions

Ensures no unintended resources are removed.

5. Validate Error Scenarios

Ensures proper handling of invalid or non-existing resource IDs.

In production systems, improper DELETE API handling can lead to major data loss issues.

How DELETE API Works in REST Architecture

The flow is simple:

1. Client sends DELETE request with resource ID.

2. Server verifies authentication and authorization.

3. Server removes resource from database.

4. Server returns appropriate HTTP status code.

Example:

DELETE https://example.com/api/users/2

Testing DELETE API Using Playwright Java

Many people know Playwright as a UI automation tool. However, it also provides powerful API testing capabilities using APIRequestContext.

With Playwright Java, you can:

• Send DELETE requests

• Send GET, POST, PUT requests

• Validate status codes

• Validate headers

• Verify resource deletion

• Combine API and UI automation

And all of this without launching a browser.

Example Scenario

We will test this DELETE API:

https://reqres.in/api/users/2

This example API is taken from reqres.in for demonstration purposes.

Step-by-Step Guide to Test DELETE API in Playwright Java

Let’s go through the steps in detail.

Step 1: Add Maven Dependency

Add the Playwright dependency in your pom.xml file:

<dependency>
    <groupId>com.microsoft.playwright</groupId>
    <artifactId>playwright</artifactId>
    <version>1.44.0</version>
</dependency>

Always use the latest stable version available.

Step 2: Java Code to Test DELETE API

Here is the complete working example:

import com.microsoft.playwright.*;

import java.util.Map;

public class DeleteAPITest {
    public static void main(String[] args) {
        try (Playwright playwright = Playwright.create()) {
            // Set up base URL and headers
            APIRequest.NewContextOptions options = new APIRequest.NewContextOptions()
                .setBaseURL("https://reqres.in")
                .setExtraHTTPHeaders(Map.of(
                    "Content-Type", "application/json"
                ));

            APIRequestContext request = playwright.request().newContext(options);

            // Send DELETE request
            APIResponse response = request.delete("/api/users/2");

            // Print response details
            System.out.println("Status Code: " + response.status());
            System.out.println("Status Text: " + response.statusText());

            if (response.status() == 204) {
                System.out.println("DELETE API test passed");
            } else {
                System.out.println("DELETE API test failed");
            }

            request.close();
        }
    }
}

Code Explanation (Step-by-Step)

Let’s break down the code for better understanding.

(a) Set Base URL

.setBaseURL("https://reqres.in")

This defines the base API endpoint.

Instead of writing full URL every time, we only use relative path.

(b) Add Headers

.setExtraHTTPHeaders(Map.of("Content-Type", "application/json"))

Headers are necessary when API expects specific content type or authentication tokens.

(c) Send DELETE Request

request.delete("/api/users/2");

This sends DELETE request to remove user with ID 2.

(d) Validate Status Code

response.status();

Expected successful status = 204 No Content

(e) Close Request Context

request.close();

Always close context to release resources.

Expected Output

Status Code: 204
Status Text: No Content
DELETE API test passed

This confirms that the resource was successfully deleted.

How to Verify Resource Deletion (Important Step)

A professional way to confirm deletion is:

1. Send DELETE request.

2. Send GET request for same ID.

3. Validate GET returns 404 Not Found.

Example:

APIResponse getResponse = request.get("/api/users/2");
System.out.println("GET after DELETE Status: " + getResponse.status());

Expected:

404 Not Found

This confirms the resource is permanently removed.

Negative Testing for DELETE API

Always test negative scenarios.

1. Delete Non-Existing Resource

DELETE /users/9999

Expected response:

404 Not Found

2. Unauthorized Delete Request

If authentication token is missing:

Expected:

401 Unauthorized

3. Forbidden Request

If user doesn’t have permission:

Expected:

403 Forbidden

Negative testing ensures system security and stability.

Measuring Response Time

Performance matters in API testing.

Example:

long start = System.currentTimeMillis();
APIResponse response = request.delete("/api/users/2");
long end = System.currentTimeMillis();

System.out.println("Response Time: " + (end - start) + " ms");

You can define acceptable threshold such as:

• Response time < 2000 ms

Best Practices for DELETE API Testing

Here are professional best practices:

1. Always Validate Status Code

Never assume success.

2. Confirm Actual Deletion

Send GET request after DELETE.

3. Test Security

Validate authentication and authorization.

4. Test Edge Cases

Invalid IDs
Large data sets
Concurrent deletion requests

5. Use Assertions Framework

Integrate with TestNG or JUnit for structured validation.

Combining API and UI Testing

Playwright allows you to combine API and UI tests efficiently.

Example scenario:

1. Use POST API to create user.

2. Use DELETE API to remove user.

3. Launch browser.

4. Verify deleted user does not appear in UI.

This approach increases automation reliability and speed.

Common Interview Questions on DELETE API

1. What is DELETE API?

2. What status code is returned for successful DELETE?

3. What does 204 No Content mean?

4. How do you confirm resource deletion?

5. How to automate DELETE API using Playwright?

6. What are common negative scenarios?

If you are preparing for automation interviews, mastering DELETE API testing is essential.

Advantages of API Testing

• Faster than UI testing

• More stable and reliable

• Detect backend issues early

• Suitable for CI/CD pipelines

• Supports microservices testing

Modern automation frameworks always include API testing as a core component.

Conclusion

A DELETE API is used to remove an existing resource from the server in RESTful applications. Proper testing ensures that:

• Resource is actually deleted

• Correct status codes are returned

• Unauthorized access is blocked

• No unintended data is affected

Using Playwright Java, you can:

• Send DELETE requests

• Validate status codes

• Confirm deletion with GET request

• Measure response time

• Handle negative scenarios

• Integrate API and UI testing seamlessly

If you are learning automation testing or preparing for interviews, mastering DELETE API testing with Playwright will significantly enhance your skills.

Suggested Posts:

1. Automate GET API in Playwright
2. Automate POST API in Playwright
3. Automate PUT API in Playwright
4. Automate Lombok API in Playwright
5. Test API by POJO Class in Playwright