Introduction

In modern .NET, the simplest way to send a POST request is HttpClient. It handles the request body, headers, and response stream cleanly, and for JSON APIs the convenience methods in System.Net.Http.Json remove most of the boilerplate.

The basic JSON POST pattern

If you need to send a JSON payload and read a JSON response, PostAsJsonAsync is the shortest clear solution:

1using System.Net.Http.Json;
2
3var client = new HttpClient();
4
5var request = new CreateUserRequest("Alice", "[email protected]");
6var response = await client.PostAsJsonAsync(
7    "https://api.example.com/users",
8    request
9);
10
11response.EnsureSuccessStatusCode();
12
13var user = await response.Content.ReadFromJsonAsync<UserResponse>();
14Console.WriteLine($"{user!.Id} {user.Email}");
15
16public record CreateUserRequest(string Name, string Email);
17public record UserResponse(int Id, string Name, string Email);

This works because PostAsJsonAsync serializes the request object as JSON and sets the content type automatically.

Sending raw content yourself

If you need more control over the body, build the content manually:

1using System.Text;
2using System.Text.Json;
3
4var client = new HttpClient();
5
6var payload = new { name = "Bob", age = 30 };
7var json = JsonSerializer.Serialize(payload);
8using var content = new StringContent(json, Encoding.UTF8, "application/json");
9
10using var response = await client.PostAsync("https://api.example.com/users", content);
11response.EnsureSuccessStatusCode();
12
13string body = await response.Content.ReadAsStringAsync();
14Console.WriteLine(body);

This pattern is useful when you want to inspect or customize the serialized JSON directly.

Posting form data instead of JSON

Not every endpoint expects JSON. Traditional form handlers often expect application/x-www-form-urlencoded:

1var client = new HttpClient();
2
3var form = new Dictionary<string, string>
4{
5    ["username"] = "alice",
6    ["password"] = "secret123"
7};
8
9using var content = new FormUrlEncodedContent(form);
10using var response = await client.PostAsync("https://example.com/login", content);
11
12string result = await response.Content.ReadAsStringAsync();
13Console.WriteLine(result);

The important part is matching the content type to what the server expects.

Handling errors and timeouts

A POST example is incomplete if it ignores failures. The minimum safe pattern is:

1using System.Net.Http.Json;
2
3var client = new HttpClient
4{
5    Timeout = TimeSpan.FromSeconds(10)
6};
7
8try
9{
10    using var response = await client.PostAsJsonAsync(
11        "https://api.example.com/users",
12        new { name = "Charlie" }
13    );
14
15    if (!response.IsSuccessStatusCode)
16    {
17        var errorText = await response.Content.ReadAsStringAsync();
18        Console.WriteLine($"HTTP {(int)response.StatusCode}: {errorText}");
19        return;
20    }
21
22    Console.WriteLine(await response.Content.ReadAsStringAsync());
23}
24catch (HttpRequestException ex)
25{
26    Console.WriteLine($"Request failed: {ex.Message}");
27}
28catch (TaskCanceledException)
29{
30    Console.WriteLine("Request timed out");
31}

That gives you predictable behavior instead of silent failure.

Using HttpClient correctly in real applications

The examples above create HttpClient inline because they are minimal. In production applications, especially ASP.NET Core, prefer IHttpClientFactory so you do not create and dispose clients in a tight loop.

1builder.Services.AddHttpClient("api", client =>
2{
3    client.BaseAddress = new Uri("https://api.example.com/");
4});

Then request the named client from a service class. The goal is connection reuse and better lifetime management, not just cleaner syntax.

Reading the response as text or JSON

The response handling method depends on what the server returns:

• use ReadAsStringAsync() for plain text or when you want raw inspection
• use ReadFromJsonAsync() for structured JSON responses
• use stream-based handling for very large payloads

Pick the format based on the API contract rather than habit.

Common Pitfalls

One common mistake is creating a new HttpClient for every single request in long-running code. That can lead to poor connection reuse and unnecessary resource pressure.

Another issue is sending JSON with the wrong content type. If the server expects JSON and you accidentally send form-encoded data, the request may fail even though the code compiles perfectly.

People also forget to check the status code. A POST that returns 400 or 500 is still a valid HTTP response, so you need EnsureSuccessStatusCode() or an explicit branch.

Finally, avoid blocking on async calls with .Result or .Wait(). In application code, use await consistently to reduce deadlock risk and keep the request flow clear.

Summary

• 'HttpClient is the standard way to send POST requests in modern .NET.'
• 'PostAsJsonAsync is the shortest clean option for JSON APIs.'
• Use StringContent or FormUrlEncodedContent when you need a specific body format.
• Always inspect or enforce the HTTP status before trusting the response body.
• In production apps, prefer IHttpClientFactory over creating many short-lived clients.