How to wrap JSON array response with a root property name in Web API

Other Questions API
1

I’m working on a Web API endpoint that currently returns a plain JSON array, but I want to wrap it inside an object with a specific property name.

Right now my API returns this format:

[{"userID":10,"orderID":20,"storeID":30},{"userID":40,"orderID":50,"storeID":60}]

However, I need it to look like this instead:

{"results":[{"userID":10,"orderID":20,"storeID":30},{"userID":40,"orderID":50,"storeID":60}]}

Here’s my current controller method:

public HttpResponseMessage GetRecentOrders()
{
    using (var db = new AppDbContext())
    {
        var orders = db.Order.Where(x => x.createdDate > CurrentUser.LastCheckDate).ToList();
        var json = JsonConvert.SerializeObject(orders);
        var response = Request.CreateResponse(HttpStatusCode.OK);
        response.Content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
        return response;
    }
}

What’s the best approach to add a wrapper property around my JSON array response?

2

Skip the manual JsonConvert stuff and just create a wrapper class instead. Way cleaner and lets the framework handle serialization for you. Here’s what I do: public class OrdersResponse { public List Results { get; set; } } Then update your controller: public HttpResponseMessage GetRecentOrders() { using (var db = new AppDbContext()) { var orders = db.Order.Where(x => x.createdDate > CurrentUser.LastCheckDate).ToList(); var response = new OrdersResponse { Results = orders }; return Request.CreateResponse(HttpStatusCode.OK, response); } } No more manual JSON headaches, plus you get type safety. I’ve used this in tons of projects and it’s rock solid across Web API versions.

3

Skip the manual JsonConvert serialization. Just create an anonymous object to wrap your results and let Web API handle it automatically. Change your controller method like this:

public IHttpActionResult GetRecentOrders()
{
    using (var db = new AppDbContext())
    {
        var orders = db.Order.Where(x => x.createdDate > CurrentUser.LastCheckDate).ToList();
        return Ok(new { results = orders });
    }
}

Way cleaner than manual string manipulation. The framework does the JSON serialization and sets the headers for you. I’ve used this pattern in tons of projects - works great across different Web API versions.

4

Wrappers work but get annoying fast when you’ve got dozens of endpoints needing different formats. Your frontend wants “results” here, “data” there, “items” somewhere else.

I automated this with Latenode. Built a flow that catches API responses and transforms them based on headers or query params. No code changes.

It checks if the response is an array, then wraps it however you want. Works on any endpoint automatically. You can throw in pagination metadata, error handling, even merge multiple APIs.

Controllers stay clean, transformation happens in middleware where it should.

Running this setup for months across several services. Set it once, forget it.

5

just wrap ur orders list in an anonymous object b4 serializing - var wrapper = new { results = orders }; then serialize that instead. way simpler than custom serializers or attributes.

6

Skip the manual JSON serialization. You’re overcomplicating this.

Just create a simple wrapper class and return it:

public class OrdersResponse
{
    public List<Order> results { get; set; }
}

public IHttpActionResult GetRecentOrders()
{
    using (var db = new AppDbContext())
    {
        var orders = db.Order.Where(x => x.createdDate > CurrentUser.LastCheckDate).ToList();
        var response = new OrdersResponse { results = orders };
        return Ok(response);
    }
}

Web API handles the JSON conversion automatically. I’ve used this pattern hundreds of times - it works perfectly.

Bonus: you can easily add more properties later like pagination info or metadata.