Paste your JSON object or array below
Kotlin classes will appear here
Paste JSON and click Generate// turn json into kotlin data classes in one click
Convert JSON to Kotlin data classes instantly. Supports nullable fields, nested objects, arrays, and idiomatic Kotlin naming conventions. Free, browser-based.
Kotlin classes will appear here
Paste JSON and click GenerateDrop any JSON object or array into the left panel
Set root class name, nullability, and annotation style
Click Generate — copy individual classes or all at once
This tool converts any JSON structure into idiomatic Kotlin data class declarations. It infers types, converts snake_case keys to camelCase properties, handles nested objects by generating separate classes, and optionally adds @SerializedName annotations for Gson compatibility.
Yes. Nested JSON objects are extracted into separate Kotlin data classes. Each nested object gets a class name derived from its parent key in PascalCase. For example, a key user_address containing an object becomes a UserAddress data class.
JSON arrays become List<T> fields in Kotlin. If the array contains objects, the tool generates a class for the item type. Primitive arrays like string lists become List<String>. Empty arrays default to List<Any>.
When enabled, every generated field is marked as nullable (e.g. String? instead of String). This is useful when your API responses may omit fields, and you want to be safe without having default values.
When the "@SerializedName" option is enabled (default), the tool adds @SerializedName("original_key") annotations whenever the JSON key differs from the Kotlin property name — for example when snake_case is converted to camelCase.
Types are inferred from the JSON values: JSON booleans → Boolean, integers → Int, decimals → Double, strings → String, null values → Any?. Nested objects and arrays are handled recursively.
The generated classes are standard Kotlin data classes that work with any serialization library. The @SerializedName annotation is Gson-specific. For Moshi use @Json(name = "..."), and for kotlinx.serialization use @SerialName("...") — these are easy manual substitutions.
Yes — the "Root Class Name" input at the top lets you set any name for the top-level class. It will be converted to PascalCase automatically. Nested class names are inferred from their JSON key names.
Completely free — no sign-up required. All conversion happens client-side in your browser. Your JSON data is never sent to a server or stored anywhere.
Converting JSON API responses into strongly-typed Kotlin models is one of the most repetitive tasks in Android and Kotlin development. Whether you're building with Retrofit, Ktor, or plain HTTP clients, you need Kotlin data classes that accurately reflect your JSON schema. This tool automates that process, giving you clean, idiomatic Kotlin code in seconds.
💡 Looking for premium web development assets? MonsterONE offers unlimited downloads of templates, UI kits, and assets — worth checking out.
A data class in Kotlin is a special class designed to hold data. Unlike regular classes, the compiler automatically generates useful methods like equals(), hashCode(), toString(), and copy(). This makes them ideal for representing API responses, database records, and any value objects in your application.
When you receive JSON from a REST API, you typically want to deserialize it into a structured Kotlin model. Serialization libraries like Gson, Moshi, and kotlinx.serialization all work seamlessly with data class declarations.
One of Kotlin's standout features is its null safety system. Fields that may be absent in a JSON response should be declared as nullable types (e.g. String?) with a default value of null. The generator handles this in two ways:
null, it is automatically marked as nullable.Getting nullability right prevents NullPointerExceptions at runtime and makes your code more reliable. Kotlin forces you to handle null cases explicitly, which is a significant advantage over Java models.
Real-world JSON is rarely flat. A user object might contain an address object, which itself contains a city and country. This generator handles nested structures by creating separate data class declarations for each nested object. The class name is derived from the JSON key in PascalCase — so a field named shipping_address produces a ShippingAddress data class.
For arrays of objects, the generator infers the item type from the first element and produces a List<ClassName> field. This covers the majority of common API patterns.
JSON APIs commonly use snake_case keys (e.g. created_at, user_id), while Kotlin conventions prefer camelCase (e.g. createdAt, userId). The generator automatically converts all keys during class generation. When the @SerializedName option is enabled, an annotation is added to map the original key name to the renamed Kotlin property — ensuring Gson serializes correctly.
With the @SerializedName option enabled, the generated classes are ready to use directly with Gson:
val gson = Gson()
val user = gson.fromJson(jsonString, Root::class.java)The annotations ensure that even though your Kotlin properties use camelCase, Gson correctly maps them to and from the snake_case JSON keys.
For Moshi users, simply replace @SerializedName("key") with @Json(name = "key") and add the Moshi dependency. The rest of the data class structure is identical. Moshi also supports Kotlin's null safety more natively than Gson, making it a popular choice for modern Android projects.
If you're using the official Kotlin serialization library, add the @Serializable annotation to each class and replace @SerializedName with @SerialName. The generated structure maps directly to this pattern. kotlinx.serialization is the recommended approach for multiplatform Kotlin projects (KMP), as it works consistently on JVM, JS, and Native targets.
data class for all API response models — the auto-generated equals() and copy() methods are invaluable for testing and state management.Long instead of Int for ID fields to avoid overflow on large datasets.sealed class hierarchies to model discriminated union types in your API responses.@Parcelize (from the kotlin-parcelize plugin) to data classes that need to be passed between Android Activities or Fragments.Manual conversion from JSON to Kotlin data classes is tedious and error-prone. For a response with 20+ fields, you might spend 10 minutes writing the class, and another 10 debugging a typo in a field name. A generator eliminates this entirely — paste, click, done. It also ensures consistency in naming conventions across all your models, which matters in large codebases with multiple contributors.