JSON to C# Class — PascalCase Properties, JSON Attributes, Nullable, Zero Upload

Real-world use cases

• Type a third-party API response without hand-writing classes

  You're integrating the GitHub API and the user object has 30+ fields. Curl the endpoint once, paste the JSON here, set the root name to `GitHubUser`, keep System.Text.Json. The nested objects lift out as their own classes automatically (`GitHubUserPlan`), `html_url` becomes `HtmlUrl` with a `[JsonPropertyName("html_url")]` attribute, and `site_admin` becomes `SiteAdmin` so it actually binds. Copy the output into `Models/GitHubUser.cs` and `JsonSerializer.Deserialize<GitHubUser>(body)` fills a fully-typed object instead of a `JsonElement` you have to walk by hand.

• Generate request/response DTOs for a new ASP.NET endpoint

  A teammate sends you a sample JSON body for the `/orders` POST they're building. Paste it, name the root `CreateOrderRequest`, switch the type to `record` and the accessor to `init` so the DTO is immutable. Paste the response sample too as `CreateOrderResponse`. Two records, fully attributed, committed to `Dtos.cs` before either of you writes the controller action.

• Decide nullable vs non-nullable for a webhook payload

  A vendor's webhook sometimes includes `cancelled_at` and sometimes omits it. Log the first few payloads, paste them as a JSON array, and the optional-field detection flags `cancelled_at`. With nullable on and detect-dates on it becomes `DateTime?`, so in your handler `if (e.CancelledAt is not null)` cleanly distinguishes "cancelled" from "still active" — instead of guessing whether default(DateTime) means absent.

• Replace a JObject / dynamic blob with a real type

  Old code does `dynamic data = JObject.Parse(body)` and reaches in with `data.user.id`, losing all compile-time checking. Capture one representative response, paste it, generate the class, replace the dynamic. Now `int`, `long`, and `double` are inferred at the property level and the compiler catches a renamed field instead of a runtime `RuntimeBinderException` in production.

• Build strongly-typed config from appsettings.json

  Your service reads a `config.json` / `appsettings.json` section. Paste it, name the root `ServiceOptions`, get `ServiceOptions`, `ServiceOptionsServer`, `ServiceOptionsServerTls` nested classes with `int` ports and `bool` flags. Drop them in `ServiceOptions.cs`, bind with `builder.Services.Configure<ServiceOptions>(...)`, and your config is type-checked at compile time instead of throwing at runtime on a typo'd key.

Common pitfalls

• Pasting a single object and expecting some properties to be nullable. A single object has no missing-key signal, so every field is required unless its value is literally null. Nullable/optional inference only kicks in across an array of objects where some elements carry a key and others don't. To explore optionality from one sample, wrap it as `[{...}]`.

• Expecting System.Text.Json to bind snake_case without the attribute. Unlike Newtonsoft (case-insensitive by default), System.Text.Json matches property names case-sensitively. That's why this tool emits `[JsonPropertyName("site_admin")]` — delete it and `SiteAdmin` silently comes back as its default. Keep the attributes, or set a global naming policy in your serializer options.

• Assuming numeric IDs should be long. If your IDs arrive as JSON strings (Stripe `cus_123`, many UUID APIs), they infer as `string`, not long — and that's correct. `long` only applies to integer JSON values that exceed Int32 range. Don't manually retype a string ID to long; you'll break deserialization with a format exception.

• Treating a field that's only ever null as a typed property. `{"meta": null}` gives `public object Meta` because null carries no type information. If you know the real shape, feed a non-null sample (`{"meta": {"k": 1}}`) so the tool can infer a proper class.

• Pasting JSON5 / JSON-with-comments / trailing commas. The tool uses strict `JSON.parse`, so comments, unquoted keys, and trailing commas all error out with a line and column. Strip them first, or run the input through a JSON formatter as a pre-step.

Privacy