Generate strongly-typed C# classes from JSON data — with smart type inference and serialization attributes
Ready to Generate C# Classes
Paste JSON in the left panel or load a sample to get started
Use our free JSON to CSharp generator to produce strongly-typed class definitions in four simple steps
Paste any JSON into the left panel of our JSON to CSharp converter — API responses, config files, database exports, you name it. The editor validates syntax in real time so you know immediately if something looks off.
{
"id": 123,
"name": "John Doe",
"isActive": true,
"address": {
"street": "123 Main St",
"city": "Springfield"
}
}Choose the target serialization library (System.Text.Json or Newtonsoft.Json) and whether JSON null values should become nullable object? properties. Every JSON to C# class conversion names the top-level class Root. The JSON to CSharp generator applies your options immediately.
The JSON to CSharp converter generates class definitions automatically in the right panel as you type, with PascalCase properties, proper type inference, and serialization attributes. Nested JSON objects become separate CSharp classes automatically.
public class Root
{
[JsonPropertyName("id")]
public int Id { get; set; }
[JsonPropertyName("name")]
public string Name { get; set; }
[JsonPropertyName("isActive")]
public bool IsActive { get; set; }
[JsonPropertyName("address")]
public Address Address { get; set; }
}
public class Address
{
[JsonPropertyName("street")]
public string Street { get; set; }
[JsonPropertyName("city")]
public string City { get; set; }
}Copy the JSON to CSharp output to clipboard or download it as a .cs file. Drop it straight into your .NET project and start deserializing JSON with full type safety provided by the generated CSharp classes.
What the JSON to C# class generator produces for nested objects, arrays, nulls and property names, and how to use the result as a DTO or POCO with System.Text.Json or Newtonsoft.Json.
The top-level object becomes a class named Root. Every nested object becomes a separate public class named after its key in PascalCase, so "customer" produces a Customer class and a Customer Customer property on its parent. If two objects would get the same class name, the second one gets a number suffix (Address2).
Arrays map to List<T>, with T taken from the first non-null element: List<string>, List<int>, or a generated class for an array of objects. An empty array becomes List<object>. Only the first object of an array is inspected, so fields that appear only in later items are not added, and class names are not singularized ("items" gives List<Items>; rename it to Item if you prefer).
Whole numbers become int (long when the value is outside the Int32 range), decimals become double, true/false become bool, and every string, including dates and GUIDs, stays string. A JSON null has no type, so it becomes object, or object? with the Nullable option on. A single sample cannot show which fields are optional, so change types such as int?, decimal or DateTimeOffset by hand where your data needs them.
Keys in snake_case, kebab-case or camelCase are turned into PascalCase property names (full_name → FullName). Each property keeps the original key in an attribute, [JsonPropertyName("full_name")] for System.Text.Json or [JsonProperty("full_name")] for Newtonsoft.Json, so the C# name can differ from the JSON key. Keys that are not valid C# identifiers, such as ones starting with a digit, are not fixed for you and need a manual rename.
The generator always writes mutable public class types with { get; set; } properties, which both serializers read and write. It does not generate records. If you want immutable DTOs, convert a class by hand, for example public record Customer([property: JsonPropertyName("full_name")] string FullName);. System.Text.Json (.NET 5 and later) and Newtonsoft.Json can both deserialize through a record's constructor.
The output contains only properties: no base classes, constructors or methods. That makes the classes plain POCOs you can use as request and response DTOs in ASP.NET Core controllers, as the target type for HttpClient calls, or as configuration models. The file starts with the using lines the attributes need; Newtonsoft.Json also needs its NuGet package.
This sample has a nested object (customer), an array of objects (items), an array of strings, a null value, a date string and snake_case keys. Paste the same JSON into the converter above to reproduce the classes in the next card.
{
"order_id": 1042,
"customer": { "full_name": "Ana Silva", "email": "[email protected]" },
"items": [
{ "sku": "A-100", "quantity": 2, "unit_price": 19.99 },
{ "sku": "B-200", "quantity": 1, "unit_price": 5.5 }
],
"tags": ["gift", "priority"],
"coupon": null,
"created_at": "2026-10-09T08:30:00Z"
}This is the exact converter output with the default settings. customer and the objects in items became the Customer and Items classes, coupon became object because it was null, and created_at stayed a string. With Newtonsoft.Json selected the classes are identical except for using Newtonsoft.Json; and [JsonProperty] attributes.
using System;
using System.Collections.Generic;
using System.Text.Json.Serialization;
public class Root
{
[JsonPropertyName("order_id")]
public int OrderId { get; set; }
[JsonPropertyName("customer")]
public Customer Customer { get; set; }
[JsonPropertyName("items")]
public List<Items> Items { get; set; }
[JsonPropertyName("tags")]
public List<string> Tags { get; set; }
[JsonPropertyName("coupon")]
public object Coupon { get; set; }
[JsonPropertyName("created_at")]
public string CreatedAt { get; set; }
}
public class Customer
{
[JsonPropertyName("full_name")]
public string FullName { get; set; }
[JsonPropertyName("email")]
public string Email { get; set; }
}
public class Items
{
[JsonPropertyName("sku")]
public string Sku { get; set; }
[JsonPropertyName("quantity")]
public int Quantity { get; set; }
[JsonPropertyName("unit_price")]
public double UnitPrice { get; set; }
}Pass the root class to the serializer that matches the attributes you generated: JsonSerializer.Deserialize<Root>(json) for System.Text.Json or JsonConvert.DeserializeObject<Root>(json) for Newtonsoft.Json. The attributes map each JSON key to its property, so no naming policy or case-insensitive option is needed. The usage code on the right is written by hand, not generated by the tool.
using System.Text.Json; // System.Text.Json, built into .NET
using Newtonsoft.Json; // Newtonsoft.Json NuGet package
string json = File.ReadAllText("order.json");
// System.Text.Json (classes generated with [JsonPropertyName])
Root? order = JsonSerializer.Deserialize<Root>(json);
Console.WriteLine(order?.Customer.FullName); // Ana Silva
string back = JsonSerializer.Serialize(order);
// Newtonsoft.Json (pick "Newtonsoft.Json" in the serializer
// menu so the classes use [JsonProperty] instead)
Root? order2 = JsonConvert.DeserializeObject<Root>(json);
string back2 = JsonConvert.SerializeObject(order2, Formatting.Indented);Common questions about using the JSON to C# class generator
Edit, format, and beautify JSON
Validate, fix, and inspect JSON
Compare, measure, and map JSON
Convert JSON to other formats
Convert other formats to JSON
Convert, format, fix, and minify XML
Generate code and format other languages