Two Ways to Extract JSON from POST Requests in ASP.NET MVC Controllers

Last updated: October 15, 2026

Android apps live and die by API communication. Your app sends user input, preferences, or form data to a backend service—and that backend needs to parse incoming JSON quickly and reliably. ASP.NET MVC developers have two distinct approaches for handling this, each suited to different scenarios.

The first binds incoming data directly to a strongly-typed object. The second reads the raw byte stream when structure is unknown or variable. Understanding both gives you flexibility whether you're building a simple contact form handler or a full-featured mobile backend.

What happened:

• Model binding maps JSON fields to class properties automatically
• Stream reading provides raw access when structure is unpredictable
• JavaScript AJAX calls send JSON in the request body
• Postman simulates POST requests for local testing without client code
• The InputStream property grants direct access to raw request bytes

Sending Data from the Client Side

Your Android app or web frontend posts JSON using an AJAX call. JQuery handles this cleanly:

Javascript

$.ajax({

Type: "POST",

Url: "/Home/ProcessForm",

Data: JSON.stringify({ userId: 42, action: "update", payload: "sample" }),

DataType: 'json',

Success: function(response) { /* handle server response */ },

Error: function(err) { /* handle failure */ }

});

The stringify method converts your JavaScript object into a JSON string. The server receives this string in the request body. Set your URL to match your controller and action method names.

Approach One: Automatic Model Binding

When your incoming JSON follows a known, consistent structure, let ASP.NET handle the mapping. Define a class whose property names match your JSON keys:

Csharp

Public class UserCommand {

Public int UserId { get; set; }

Public string Action { get; set; }

Public string Payload { get; set; }

Public DateTime Timestamp { get; set; }

}

Add an instance of this class as a parameter to your action method:

Csharp

Public ActionResult ProcessForm(UserCommand command) {

// The framework populates command.UserId, command.Action, etc.

// from the incoming JSON automatically

Return View();

}

The model binder compares incoming JSON keys against your class properties. Matching names populate the corresponding fields. Type conversion happens automatically—strings become integers or dates as needed.

This approach works best when you control both the client sending the data and the server receiving it. Fixed, stable payloads make model binding the fastest solution.

Approach Two: Reading the Raw Stream

Sometimes you cannot predict what fields arrive. Perhaps the JSON includes optional properties, dynamic keys, or varies based on user input. In these cases, grab the raw bytes directly:

Csharp

Public ActionResult ProcessForm() {

Request.InputStream.Seek(0, System.IO.SeekOrigin.Begin);

String incoming = new StreamReader(Request.InputStream).ReadToEnd();

// Parse incoming with JsonDocument, Newtonsoft, or your parser of choice

Return View();

}

Request.InputStream provides access to the raw request body as a stream of bytes. Seeking to the beginning ensures you read from the start. StreamReader converts those bytes into a string you can parse.

Once you have the raw text, use System.Text.Json's JsonDocument for flexible querying or deserialize into dynamic objects. This method adds parsing overhead but gives you complete control.

Why This Matters for Your Projects

Model binding keeps your controller code clean and readable. Each parameter represents a typed contract with the client. Unit testing becomes straightforward—you can construct UserCommand objects directly without mocking HTTP requests.

Raw stream reading handles the messy reality of real-world APIs. Third-party integrations, legacy systems, or feature flags that change payload structure all benefit from reading first and interpreting second. You can log the exact incoming JSON for debugging before attempting parsing.

Neither approach is universally better. Experienced developers choose based on contract stability. Stable contracts benefit from binding. Evolving or external APIs need stream reading.

Say your Android app submits a support ticket with optional attachments, varying priority levels, and customer metadata that changes between app versions. Model binding breaks when new optional fields appear or existing fields rename. Stream reading lets your server accept any JSON structure, log it, then parse only the fields your current version understands. You future-proof the endpoint without rewriting client code.

Key takeaways

• Use model binding for predictable, version-controlled JSON structures
• Use stream reading for dynamic payloads or third-party integrations
• Test both approaches with Postman before integrating your Android app
• Always validate JSON data before processing—never trust incoming content
• Consider logging raw requests during development for easier debugging