How to Send POST Request Using Rest Assured Framework in Java?

Why Rest Assured Matters in API Testing

In today’s cloud-first world, API testing is one of the most critical aspects of software quality assurance. RESTful APIs dominate modern application development, and tools like Rest Assured in Java make it easy to automate API validations.

Sending POST requests using Rest Assured is a fundamental skill for QA engineers, developers, and automation testers who work on enterprise-level projects. Whether you’re testing microservices, cloud-based APIs, or secure web applications, mastering this skill improves both efficiency and accuracy in testing.

What is Rest Assured?

Rest Assured is a Java-based library designed for testing RESTful APIs. It provides a fluent API that simplifies writing readable and maintainable test scripts. Instead of using complex code with HttpURLConnection or Apache HttpClient, testers can simply use Rest Assured to:

• Send GET, POST, PUT, DELETE requests
• Validate response codes and headers
• Extract response body values
• Integrate with TestNG and JUnit

Key benefits:

• Simplifies API testing in Java
• Supports JSON and XML
• Works well with BDD frameworks like Cucumber
• Reduces boilerplate code

Why Use POST Requests in API Testing?

In REST APIs, POST requests are mainly used to:

• Create new resources (e.g., user registration, adding items to a database)
• Submit data to the server for processing
• Trigger background workflows (like AWS Lambda triggers)

For example:

• A POST request to /users can add a new user.
• A POST request to /orders can create a new order in an e-commerce system.

Step-by-Step Guide: Sending a POST Request Using Rest Assured in Java

1. Add Rest Assured Dependency

If you’re using Maven, include the following in your pom.xml:

<dependency>
    <groupId>io.rest-assured</groupId>
    <artifactId>rest-assured</artifactId>
    <version>5.3.0</version>
    <scope>test</scope>
</dependency>

For Gradle:

testImplementation 'io.rest-assured:rest-assured:5.3.0'

2. Import Required Packages

In your Java class, import these packages:

import io.restassured.RestAssured;
import io.restassured.response.Response;
import static io.restassured.RestAssured.*;
import static org.hamcrest.Matchers.*;

3. Simple POST Request Example

Here’s a basic POST request example using Rest Assured:

import org.testng.annotations.Test;


public class PostRequestExample {
    @Test
    public void sendPostRequest() {
        String requestBody = "{\n" +
                "  \"name\": \"John Doe\",\n" +
                "  \"job\": \"Software Engineer\"\n" +
                "}";
        Response response = given()
                .header("Content-Type", "application/json")
                .body(requestBody)
        .when()
                .post("https://reqres.in/api/users")
        .then()
                .statusCode(201)
                .extract().response();
        System.out.println("Response: " + response.asString());
    }
}

✅ This sends a POST request to https://reqres.in/api/users with JSON payload and validates 201 Created status code.

4. POST Request with Path and Query Parameters

Sometimes APIs require parameters in the request. Example:

@Test
public void sendPostWithParams() {
    given()
        .header("Content-Type", "application/json")
        .queryParam("role", "admin")
        .body("{ \"username\": \"gopesh\", \"password\": \"securePass\" }")
    .when()
        .post("https://example.com/api/login")
    .then()
        .statusCode(200)
        .body("token", notNullValue());
}

Here:

• queryParam("role", "admin") is appended to the URL.
• The response validates the presence of a token.

5. Sending POST Request with POJO Class

Instead of hardcoding JSON strings, use POJO (Plain Old Java Object):

public class User {
    private String name;
    private String job;
    // Constructors, Getters, Setters
}

@Test
public void sendPostUsingPOJO() {
    User user = new User("Neptune Tester", "QA Engineer");
    given()
        .header("Content-Type", "application/json")
        .body(user)
    .when()
        .post("https://reqres.in/api/users")
    .then()
        .statusCode(201)
        .body("name", equalTo("Neptune Tester"));
}

👉 This improves readability and reusability.

6. Handling Authentication in POST Requests

Many enterprise APIs require authentication (Basic Auth, Bearer Tokens, OAuth2). Example with Bearer Token:

@Test
public void sendAuthenticatedPost() {
    String token = "your_jwt_token_here";
    given()
        .header("Authorization", "Bearer " + token)
        .header("Content-Type", "application/json")
        .body("{ \"title\": \"New Blog Post\", \"content\": \"SEO-optimized article on Rest Assured\" }")
    .when()
        .post("https://example.com/api/posts")
    .then()
        .statusCode(201);
}

This is common in enterprise-grade APIs, AWS Lambda invocations, and cloud-native apps.

Real-World Applications of Rest Assured POST Requests

• E-commerce: Create new orders, users, carts
• Banking APIs: Initiate transactions securely
• Cloud Automation: Trigger AWS Lambda functions via API Gateway
• Healthcare: Submit patient records securely
• DevOps: Automate deployment workflows

📊 According to MarketsandMarkets (2023), the API testing market size is expected to grow from USD 1.2 billion in 2020 to USD 6.2 billion by 2026, driven by cloud adoption and microservices.

Challenges in POST Request Testing

• Handling dynamic tokens for authentication
• Large JSON payloads with nested objects
• Data-driven testing for multiple inputs
• Verifying database changes after POST requests
• Performance testing of POST-heavy endpoints

Pro Tip: Combine Rest Assured with TestNG + DataProviders to handle large datasets efficiently.

Best Practices for POST Requests in Rest Assured

• Always use Content-Type headers
• Validate both status code and response body
• Use POJOs for complex payloads
• Keep sensitive data (like tokens) in environment variables
• Integrate with CI/CD pipelines (Jenkins, GitHub Actions)

FAQs: Sending POST Request Using Rest Assured in Java

1. What is the difference between GET and POST in Rest Assured?

• GET retrieves data without altering server state.
• POST sends data to create or modify resources.

2. Can we send form-data in POST requests with Rest Assured?

Yes, using .formParam("key", "value") for x-www-form-urlencoded requests.

3. How do I validate JSON response fields?

Use:

.body("id", notNullValue())
.body("name", equalTo("John"));

4. Can Rest Assured test SOAP APIs?

Yes, but it’s primarily designed for REST APIs. For SOAP, use XML payloads.

Conclusion: Why You Should Learn Rest Assured POST Requests

Learning how to send POST requests in Rest Assured with Java is essential for anyone pursuing a career in Automation Testing, DevOps, or Cloud Engineering.

It not only simplifies API testing but also integrates seamlessly with enterprise workflows, from e-commerce platforms to cloud-native microservices. By following best practices and using structured payloads (POJOs), you can create scalable and maintainable automation scripts.

🚀 Start small, experiment with dummy APIs like reqres.in, and then move to enterprise-grade systems for real-world experience.