JSON to C# Class Generator

Example Input

{
  "id": 1,
  "name": "Priya Singh",
  "email": "priya@learnhubly.com",
  "isActive": true,
  "tags": ["developer", "admin"],
  "profile": {
    "bio": "Principal Software Engineer",
    "skills": ["Go", "React", "TypeScript"]
  }
}

Example Output

using System.Collections.Generic;
using System.Text.Json.Serialization;

public class User
{
    [JsonPropertyName("id")]
    public int Id { get; set; }

    [JsonPropertyName("name")]
    public string Name { get; set; }

    [JsonPropertyName("email")]
    public string Email { get; set; }

    [JsonPropertyName("isActive")]
    public bool IsActive { get; set; }

    [JsonPropertyName("tags")]
    public List Tags { get; set; }

    [JsonPropertyName("profile")]
    public Profile Profile { get; set; }
}

public class Profile
{
    [JsonPropertyName("bio")]
    public string Bio { get; set; }

    [JsonPropertyName("skills")]
    public List Skills { get; set; }
}

Does it support Record types?

Yes. C# 9.0+ record types are supported as an output option. Records are immutable by default, have value-based equality, and are now the recommended model type for API responses in modern .NET 6 and later projects. A generated record looks like public record User(int Id, string Name, string Email) with init-only properties set during deserialization. Records work with both Newtonsoft.Json and System.Text.Json with the correct serializer configuration. Choose the record type output if you are starting a new .NET 6+ project.

Does it support Newtonsoft.Json and System.Text.Json?

Yes, both are supported. For Newtonsoft.Json (Json.NET), the generated class uses [JsonProperty("fieldName")] attributes on each property. For System.Text.Json, it uses [JsonPropertyName("fieldName")] attributes instead. These are mutually exclusive — the attributes from one library are not read by the other. Check your project's NuGet packages: if you have Newtonsoft.Json installed use those attributes, if you are on .NET Core 3.0 or later without Newtonsoft, use System.Text.Json attributes which are built into the framework.

What C# types are inferred from JSON?

JSON strings become string. JSON integers become int for typical values or long for very large values. JSON decimal numbers become double. JSON booleans become bool. JSON null values make the property nullable. JSON arrays become List with the element type inferred from the array contents. JSON nested objects become separate named C# classes referenced by the parent class. Date strings like 2026-05-20T14:30:00Z are inferred as string since JSON has no date type — change these to DateTime or DateTimeOffset manually after generating.

Can I use this with ASP.NET Core Web API?

Yes. ASP.NET Core Web API uses System.Text.Json by default since .NET Core 3.0. Generate your classes with System.Text.Json attribute style, add them to your Models folder, and use them as action method return types or as deserialization targets for HttpClient responses. For model binding (deserializing request bodies), ASP.NET Core automatically deserializes the request body into the typed model class using the [JsonPropertyName] attributes for field mapping. For consuming external APIs, use HttpClient with JsonSerializer.DeserializeAsync() using the generated class.

How do I handle JSON fields with snake_case names in C#?

C# convention is PascalCase for public properties (UserId not user_id). The generated class handles this automatically — it generates a PascalCase property name and adds the original JSON field name as the attribute value: [JsonPropertyName("user_id")] public int UserId { get; set; }. During deserialization, the serializer reads the user_id field from JSON and maps it to the UserId C# property using the attribute. You never need to manually handle the case conversion — that is exactly what the JsonProperty and JsonPropertyName attributes are for.

Does it handle nullable reference types for .NET 6+?

Yes. For fields that appear as null or are absent in your JSON sample, the tool generates nullable types — string? instead of string, int? instead of int, CustomClass? instead of CustomClass. In .NET 6 and later where nullable reference types are enabled by default, this prevents null reference warnings at compile time and null reference exceptions at runtime. For fields that are never null in the API response, the tool generates non-nullable types. Review the generated output and mark any additional fields as nullable if you know they can be null in real API responses.

What should I do if the generated class has too many nested classes?

For deeply nested JSON with many levels of nested objects, the tool generates a separate class for each nested object. This is correct behavior but can result in many small class files. You have two options: put all generated classes in a single file for simple cases — C# allows multiple class definitions in one file — or split them into separate files in a Models folder following the one-class-per-file convention. For very deeply nested structures, consider whether the API response design itself could be simplified. If you control the API, flatter response objects are generally easier to consume on the client side.

How do I deserialize a JSON array into a List of the generated class?

If the API returns a JSON array like [{...}, {...}, {...}] rather than a single object, deserialize into List rather than YourClass directly. With System.Text.Json: var list = JsonSerializer.Deserialize>(jsonString); and with Newtonsoft.Json: var list = JsonConvert.DeserializeObject>(jsonString); The generated class describes a single item — the List wrapper handles the array. If the API returns a paginated response wrapper like {data: [...], total: 100}, create a separate wrapper class like public class PagedResponse { public List Data { get; set; } public int Total { get; set; } } and deserialize as PagedResponse.