JSON to Code Types Generator
Paste JSON to instantly generate a TypeScript interface, Python dataclass or Pydantic model, Go struct, and Kotlin data class. Free, browser-only.
JSON to Code Types Generator
Paste any JSON document and get ready-to-use type definitions for TypeScript, Python, Go, and Kotlin — nested objects become named types, arrays are merged element-by-element, optional and nullable fields are detected, and every original key is preserved. All inference runs locally in your browser; your JSON never leaves this page.
Type inference and code generation happen entirely in your browser — no upload, no account, no server.
How to Use the JSON to Code Types Generator
Paste your JSON
Drop any JSON document into the input box — an API response, a webhook payload, a config file, or a database export. Generation is live: types appear the moment the JSON parses. Click "Try sample" to load a realistic nested example with arrays, optional fields, nulls, and kebab-case keys.
Name your root type and set options
The root type is called "Root" by default — rename it to match your domain ("Order", "UserProfile"). Tick "All fields optional" if your payload is a sparse PATCH-style document where any field may be absent.
Pick your target language
Switch between the TypeScript, Python, Go, and Kotlin tabs. For Python, choose between a plain dataclass and a Pydantic BaseModel — Pydantic adds runtime validation and automatic alias handling for non-snake_case keys.
Copy the generated types into your project
Click Copy and paste the output straight into your codebase. Nested objects become separate named types, optional and nullable fields are marked per-language idiom, and every original JSON key is preserved via quoting, aliases, struct tags, or SerialName annotations.
About JSON to Code Types — From Payload to Typed Model
Why generate types from JSON at all?
Almost every modern integration task begins the same way: someone hands you a JSON payload — an API response, a webhook body, a message-queue event — and your first job is to describe its shape in your own language so the compiler, the IDE, and your teammates can reason about it. Writing that model by hand is tedious and error-prone: it is easy to miss that one field is sometimes absent, that another is occasionally null, or that a "price" that looked like an integer in the first three samples turns out to be a decimal in the fourth. A generator that reads the actual document and derives the types mechanically catches exactly the cases a tired human skips, and it does so in milliseconds. The output is a starting point, not gospel — you should still rename types to match your domain and tighten fields you know more about than the sample shows — but starting from an inferred model is strictly better than starting from a blank file.
What the inference engine actually does
The engine parses your document once, then builds an abstract shape for every value
it finds. Nested objects are lifted into separate named types, with names derived
from their keys in PascalCase — a customer object becomes
Customer, and an items array of objects becomes a list of
Item. When two shapes at different positions in the document are
structurally identical, they are merged under a single name instead of producing
duplicate definitions; when two different shapes would claim the same name, the
later one receives a numeric suffix. Arrays are the interesting case: rather than
trusting the first element, the engine merges the shape of every element.
A key present in some elements but not others is marked optional; a key whose values
disagree on type becomes a union where the language supports one; a key that is null
anywhere becomes nullable. Numbers are tracked across all samples too, so a field is
only integral if every occurrence is a whole number — one fractional value widens it
to a float for good. Empty arrays and empty objects, which carry no evidence about
their contents, honestly degrade to unknown-element and string-keyed-map types
rather than guessing.
Four languages, four sets of idioms
Code generation is only useful when the output reads like a native of the target
language wrote it. TypeScript output uses plain interfaces — the zero-cost,
erased-at-compile-time way to describe data — and keeps your original JSON keys
verbatim, quoting the ones that are not valid identifiers. Python output converts
keys to snake_case and offers two idioms: a stdlib @dataclass for
dependency-free codebases, or a Pydantic BaseModel with
Field(alias=...) entries when you want runtime validation and exact
round-tripping of kebab-case keys. Go output exports every field in PascalCase, as
encoding/json requires, and always emits a json struct tag
carrying the original key, adding omitempty for optional fields and
pointer types for nullable ones. Kotlin output produces
@Serializable data classes for kotlinx.serialization, camelCasing
the property names and attaching @SerialName wherever the property
no longer matches the JSON key, with Int widening to Long
when a sample value overflows 32 bits. The result in each tab is code you can paste
into a real project without a cleanup pass — mappings intact, nullability explicit,
and no invented fields the document never showed.
10 Facts About JSON and Type Generation
TypeScript interfaces are a compile-time-only construct: they are fully erased during transpilation and add zero bytes and zero runtime cost to your shipped JavaScript — which is why generated interfaces are the cheapest form of API documentation you can adopt.
Python dataclasses arrived in Python 3.7 via PEP 557 as a zero-dependency way to declare typed record classes; Pydantic goes further by actually validating values at runtime, which is why FastAPI made it the backbone of its request models.
Go's encoding/json package can only marshal and unmarshal EXPORTED struct fields (those starting with an uppercase letter) — which is why every generated Go field is PascalCase and carries a json struct tag pointing back at the original lowercase key.
kotlinx.serialization is implemented as a compiler plugin rather than a reflection library: serializers for every @-annotated data class are generated at compile time, making it fully compatible with Kotlin/Native and ProGuard-minified Android builds.
JSON itself has only ONE number type — there is no int/float distinction in the specification. This tool re-derives the distinction by scanning every sample value: if all occurrences are whole numbers you get int/Int/int64, and a single fractional value widens the field to float/Double/float64.
A JSON field that is null and a JSON field that is absent are two different things: null maps to nullability (a question-mark type or pointer), while absence maps to optionality (a "?" property, a default value, or omitempty). Conflating them is one of the most common causes of serialization bugs.
When this tool merges an array of objects, a field that appears in only some elements is marked optional in the generated type — the same union-of-shapes technique TypeScript's own compiler uses when inferring the element type of a heterogeneous array literal.
JavaScript stores all numbers as IEEE 754 doubles, so integers above 9,007,199,254,740,991 (2^53 − 1) silently lose precision the moment JSON.parse runs — 64-bit database IDs are safer transported as JSON strings, a caveat that applies to every browser-based JSON tool.
Each language has its own field-naming convention — camelCase in Kotlin, snake_case in Python, PascalCase in exported Go — so honest code generation must always emit a mapping back to the original key: quoted keys in TypeScript, aliases in Pydantic, json tags in Go, and SerialName in Kotlin.
Structurally identical objects appearing at different places in one payload (say, billing and shipping addresses with the same fields) are detected by shape signature and reuse a single generated type instead of producing near-duplicate definitions — the same deduplication trick production tools like quicktype use.
Frequently Asked Questions
- No. Parsing, shape inference, and code generation all run inside your browser in plain JavaScript — nothing is transmitted, logged, or stored anywhere. You can open your network inspector and confirm no request fires when you paste. That makes the tool safe for payloads containing internal identifiers, tokens, or customer data, though as a habit you should still redact real secrets before pasting anything anywhere.
- It inspects every sample value for a field across the whole document, including all elements of arrays. If every occurrence is a whole number the field stays integral (int in Python, int64 in Go, Int or Long in Kotlin); if any single occurrence has a fractional part the field widens to float/float64/Double. TypeScript always gets number, since JavaScript has no integer type. One caveat: JSON cannot distinguish 129.0 from 129, so a float field whose samples all happen to be whole numbers will be inferred as an integer — add one fractional sample value to pin it.
- A field that is null in at least one sample becomes nullable: TypeScript gets a union with null, Python gets Optional[...], Go gets a pointer type (so nil can represent null), and Kotlin gets the question-mark suffix. A field that is ONLY ever null has no evidence of an underlying type, so it is emitted as nullable unknown/Any/any — replace it by hand once you know what the API sends when the value is present.
- When the tool merges the object shapes across every element of an array, a key that appears in some elements but not all is marked optional — a question-mark property in TypeScript, a default of None in Python, omitempty on the Go struct tag, and a null default in Kotlin. Optionality is about presence; nullability is about value. A field can be both: present sometimes, and null when present.
- Choose dataclass when you want zero dependencies and you already trust the data — it is a plain container with type hints that nothing enforces at runtime. Choose Pydantic when the JSON crosses a trust boundary (an external API, user input): BaseModel validates every field on construction, coerces compatible types, and its alias mechanism cleanly maps kebab-case or camelCase JSON keys onto snake_case Python attributes. FastAPI users should almost always pick Pydantic.
- Go can only serialize exported (uppercase) fields, so the generator must rename every key to PascalCase — and without a tag, encoding/json would then expect "OrderId" in the JSON instead of the real "order-id". Emitting an explicit json:"original-key" tag on every field makes round-tripping exact and self-documenting, and optional fields additionally get omitempty so absent values are dropped when you marshal back to JSON.
- An empty array carries no evidence of its element type, so you get unknown[] in TypeScript, list[Any] in Python, []any in Go, and List<Any?> in Kotlin. An empty object similarly becomes Record<string, unknown>, dict[str, Any], map[string]any, and Map<String, Any?>. If you can, paste a sample where those containers are populated — the inference is only as good as the evidence in the document.
- Every language gets a legal identifier plus a mapping back to the exact original key. TypeScript keeps the original key and simply quotes it when it is not a valid identifier. Python converts to snake_case and records the original via a Pydantic alias, or a comment in dataclass mode. Go converts to PascalCase with the original in the json tag. Kotlin converts to camelCase and adds a SerialName annotation whenever the two differ. Round-tripping your JSON is never broken by renaming.
- If "value" is a string in one array element and a number in another, TypeScript and Python get a genuine union (string | number, Union[str, float]) because those type systems express unions natively. Go and Kotlin have no untagged unions, so the field degrades to any / Any there — an honest admission that you will need a custom unmarshaller or a sealed hierarchy if you want stronger typing.
- 100% free, no account, no limits on how many payloads you convert. RECATOOLS is funded by contextual advertising, not paywalls or subscriptions. Because everything runs locally the tool also works offline once the page has loaded, and it never rate-limits you — convert as many API responses as your migration needs.
Related News
You may be interested in these recent stories from our newsroom.
-
npm v12 Is Here, and It Turns Off a Default That Has Run Arbitrary Code for a Decade
npm v12 went generally available on 8 July, flipping install scripts, Git dependencies and remote-URL packages from automatic to opt-in. The...
-
Apple Loses Its EU Gatekeeper Fight — What the DMA Ruling Actually Changes for Developers
On 8 July 2026, the EU General Court dismissed Apple's challenges to its Digital Markets Act gatekeeper designation for the App Store and iO...
-
DuneSlide: Two Cursor Flaws Turn a Zero-Click Prompt Injection Into Code Execution
Cato AI Labs has disclosed DuneSlide — two critical remote-code-execution flaws in Cursor (CVE-2026-50548 and CVE-2026-50549, CVSS 9.8) that...