Recently, I started working on an ASP.NET Core project, a travel dating app. Every time I make a fetch request from my frontend using the JavaScript code, I receive a 400 Bad Request status. The body of the response has an error object saying: "A non-empty request body is required". So in this post, I'm going to discuss possible reasons for that error and solutions to resolve it when encountering a "400 Bad Request" error with the message "A non-empty request body is required", it indicates that the server expects a request body with content, but the request sent to the server does not contain any data.

Here's how we can address this issue:

  1. Check your API to ensure that you are sending the correct request format expected by the server. It's possible that the endpoint requires specific parameters or data in the request body.
  2. Check the content of the request being sent. Ensure that the request body is not empty and contains the necessary data required by the server. For example:
  3.     {
          "Name": "john",
          "Age": "20"

    Let's explore scenarios where we might encounter the "400 Bad Request" error with the message "A non-empty request body is required":

    1. Missing Request Body: One common scenario is when we make a POST or PUT request to an API endpoint that expects data in the request body, but we fail to include any data. For example:
    2.     POST /api/resource HTTP/1.1
          Content-Type: application/json

      In above case, the server expects JSON data in the request body, but the body is empty, resulting in the "A non-empty request body is required" error.

    3. Incorrect Content-Type: Another scenario is when the request body is present, but the Content-Type header does not match the expected content type. For instance:
    4.     POST /api/resource HTTP/1.1
          Content-Type: application/x-www-form-urlencoded

      If the server expects JSON data but receives form-urlencoded data, it may asusme the request body as empty, leading to the "400 Bad Request" error.

    5. Empty Data Object: Sometimes, we may include an empty object in the request body, which the server does not accept as a valid payload.
    6.     POST /api/resource HTTP/1.1
          Content-Type: application/json

      If the server requires specific data fields to be present in the request body, sending an empty object result in the "A non-empty request body is required" error.

  4. Also ensure that you are using the correct HTTP method for the intended operation. For instance, if the operation requires sending data to the server, we should use HTTP methods like POST or PUT instead of GET. You can use debugging tools or network monitoring tools to inspect the network requests being sent. Verify that the request is correctly formatted and contains the expected data.
  5. Implement error handling mechanisms in our application to properly handle server responses, including "400 Bad Request" errors and display meaningful error messages to users and provide help on how to resolve the issue.

By following above steps and ensuring that our requests meet the server's expectations, we should be able to resolve the "400 Bad Request" error with the message "A non-empty request body is required".


When I encountered the same issue while learning about HTTP requests, I discovered the root causes for the errors my colleague faced.

Firstly, I realized that I didn't pass the "Content-Length" value in my HTTP request. This caused the server to expect a request body but not receive any data, leading to the "A non-empty request body is required" error.

In the second case, there was a mismatch between the parameters sent by the client and the parameters expected by the server method, esulted in the server interpreting the request body incorrectly or not recognizing it at all, causing the "400 Bad Request" error.

Including the "Content-Length" header in the HTTP request ensures that the server knows the length of the request body, helps prevent errors related to missing or incomplete request data and ensuring consistency between the parameters sent by the client and those expected by the server method is crucial for successful communication. 

Here i'm simply sharing creating a POST API for adding an Employee in ASP.NET Core and calling it from JavaScript, so that you can take help from this code.

  1. Create Employee Class:
  2.     public class Employee
            public int Id { get; set; }
            public string Name { get; set; }
            public string Department { get; set; }
            public decimal Salary { get; set; }
  3. Create POST Endpoint:
  4.     [ApiController]
        public class EmployeesController : ControllerBase
            public IActionResult AddEmployee(Employee employee)
                // Add logic to save the employee to the database or data store
                // Example: _employeeRepository.Add(employee);
                return Ok("Employee added successfully");
  5. Call the API in JavaScript
  6.     fetch('/api/employees', {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json'
            body: JSON.stringify({
                "Id": 1,
                "Name": "John Doe",
                "Department": "Engineering",
                "Salary": 50000.00
        .then(response => {
            if (!response.ok) {
                throw new Error('Failed to add employee');
            return response.json();
        .then(data => {
            console.log(data); // Log success message or handle response
        .catch(error => {
            console.error('Error:', error);

We call the POST API from JavaScript code to send data to the server and add a new employee. We typically use JavaScript's Fetch API or other HTTP request libraries to make the HTTP POST request to the API endpoint.

Using above code you can easily add employees through our ASP.NET Core API and interact with it from client-side JavaScript code.