JSON to C# Converter

Backend developers wiring up a new API client, integration engineers mapping a third-party webhook, and anyone writing a DTO by hand all hit the same tedious wall: transcribing a JSON sample into a C# model, one property at a time, guessing whether a field is an int or a long, and forgetting the serializer attribute until the binding fails at runtime.

Paste your JSON and this converter emits a complete C# class or record for every nested object, with PascalCase properties, correct primitive types, and the serializer attributes your project uses. It runs entirely in the tab, so sample payloads containing internal IDs or customer data never leave the machine.

How the conversion works

The converter walks the parsed JSON tree and maps each value to a C# type. Whole numbers become int when they fit in 32 bits and long when they do not. Decimal numbers become double. JSON true and false become bool, and any non-numeric value becomes string. Arrays produce a List of the element type, and every distinct object shape becomes its own class so nesting is preserved instead of collapsed into one giant type.

Property names are converted to PascalCase and any C# keyword collision is escaped with the @ prefix. When serializer attributes are enabled, each property is annotated with the original JSON key so deserialization binds correctly regardless of casing. With nullable reference types on, reference-type properties get a trailing ? unless the sample shows a concrete non-null value.

The generated code is plain C# with no third-party dependencies beyond the serializer you selected. Paste it into a new file, add the matching using directive, and compile.

Before and after: a typical API response

Input, a JSON payload from a user endpoint:

{ "id": 42, "name": "Ada Lovelace", "active": true,
  "tags": ["math", "code"],
  "address": { "city": "London" } }

Output, System.Text.Json class with nullable reference types:

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

namespace MyApp.Models
{
    public class Root
    {
        [JsonPropertyName("id")]
        public int Id { get; set; }

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

        [JsonPropertyName("active")]
        public bool Active { get; set; }

        [JsonPropertyName("tags")]
        public List<string> Tags { get; set; } = new();

        [JsonPropertyName("address")]
        public Address? Address { get; set; }
    }

    public class Address
    {
        [JsonPropertyName("city")]
        public string? City { get; set; }
    }
}

Who converts JSON to C# with this tool

Common mistakes when generating C# from JSON

• Ignoring the serializer attribute mismatch. If your project uses Newtonsoft but you generate System.Text.Json attributes, every property silently binds to null at runtime because the casing does not match. Match the attribute style to the serializer already registered in Program.cs or Startup.cs.
• Assuming every number is an int. Large IDs and timestamps overflow int and need long. The converter picks long automatically when the sample value exceeds int.MaxValue, but a sample with a small ID will still emit int. If you know the field grows, switch it to long by hand.
• Deleting the @ prefix on keyword properties. A JSON field named class or event produces @class or @event in C#. Removing the @ makes the file fail to compile. Keep the prefix or rename the property and rely on the attribute for binding.
• Generating mutable classes when you wanted immutability. Records give value equality and immutability by default. If you pick class by habit and then add init-only accessors manually, you are doing the work the record keyword already does. Switch the Type dropdown to record.

Best practices for JSON to C# workflows

• 1.Paste a realistic sample with real nesting and at least one array so every class the converter emits is exercised by your actual data shape.
• 2.Match the serializer attributes to the library your project already references, and confirm with one round-trip deserialization test before committing.
• 3.Prefer records for immutable DTOs on .NET 6 and later, and enable nullable reference types so missing fields surface at compile time instead of as null references.
• 4.Regenerate and diff when the upstream API changes, rather than editing properties by hand, so new fields are not silently dropped.

Frequently asked questions