JSON to Kotlin Data Class

I've been building Android apps since the days of Eclipse and Java. When Kotlin arrived in 2017, I was skeptical at first. But after writing my first data class, I was hooked. No more Lombok, no more boilerplate getters and setters, no more findViewById — Kotlin was a breath of fresh air.

But one thing that still annoyed me? Parsing JSON from REST APIs. Every new endpoint meant writing a new data class. Every API change meant updating fields. And with Kotlin's strict null safety, forgetting a ? could crash your app.

That's why I built this JSON to Kotlin data class converter. After working on a large e-commerce Android app with 50+ API endpoints, I knew there had to be a better way. This tool is the result — and it's saved me and my team hundreds of hours.

// JSON Input
{
  "id": 123,
  "name": "John Doe",
  "email": "john@example.com",
  "isActive": true
}

// Generated Kotlin Data Class
import kotlinx.serialization.Serializable

@Serializable
data class User(
    val id: Int,
    val name: String,
    val email: String,
    @SerialName("isActive") val isActive: Boolean
)

What Are Kotlin Data Classes?

Data classes in Kotlin are special classes designed to hold data. When you mark a class with the data keyword, Kotlin automatically generates:

• equals() and hashCode() methods
• toString() method
• copy() method for creating modified copies
• componentN() functions for destructuring declarations

Here's what a manual Java POJO looks like versus a Kotlin data class:

// Java (35+ lines)
public class User {
    private String name;
    private String email;
    
    public User(String name, String email) {
        this.name = name;
        this.email = email;
    }
    
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public String getEmail() { return email; }
    public void setEmail(String email) { this.email = email; }
    
    @Override
    public boolean equals(Object o) { ... }
    @Override
    public int hashCode() { ... }
    @Override
    public String toString() { ... }
}

// Kotlin (3 lines!)
data class User(
    val name: String,
    val email: String
)

That's 35+ lines of Java vs 3 lines of Kotlin. This is why Kotlin data classes are revolutionary.

JSON to Kotlin Type Mapping

Understanding how JSON types map to Kotlin types is crucial. Here's the complete mapping our converter uses:

Real-World Example: E-commerce Order

Let me show you a real example from an e-commerce Android app I worked on. Here's a typical order JSON from a REST API:

{
  "orderId": "ORD-12345",
  "customer": {
    "id": 1001,
    "name": "Jane Smith",
    "email": "jane@example.com"
  },
  "items": [
    {
      "productId": "P-100",
      "name": "Wireless Headphones",
      "quantity": 2,
      "unitPrice": 79.99,
      "totalPrice": 159.98
    }
  ],
  "totalAmount": 159.98,
  "status": "COMPLETED",
  "createdAt": "2024-03-20T10:15:00Z"
}

Our converter generates these Kotlin data classes:

import kotlinx.serialization.Serializable
import kotlinx.serialization.SerialName
import java.util.Date

@Serializable
data class Order(
    @SerialName("orderId") val orderId: String,
    val customer: Customer,
    val items: List<Item>,
    @SerialName("totalAmount") val totalAmount: Double,
    val status: String,
    @SerialName("createdAt") val createdAt: String
)

@Serializable
data class Customer(
    val id: Int,
    val name: String,
    val email: String
)

@Serializable
data class Item(
    @SerialName("productId") val productId: String,
    val name: String,
    val quantity: Int,
    @SerialName("unitPrice") val unitPrice: Double,
    @SerialName("totalPrice") val totalPrice: Double
)

This is production-ready code. Just add your serialization library dependency and you're done.

Kotlin Serialization Libraries: Which One to Choose?

kotlinx.serialization — The Official Choice

JetBrains' official serialization library. Zero reflection, compile-time safety, Kotlin Multiplatform support. This is what I recommend for most projects.

// build.gradle.kts
dependencies {
    implementation("org.jetbrains.kotlinx:kotlinx-serialization-json:1.6.0")
}

Moshi — Square's Alternative

Popular in Android development. Uses code generation for performance. Excellent if you're already using Retrofit or OkHttp.

// build.gradle.kts
dependencies {
    implementation("com.squareup.moshi:moshi:1.15.0")
    ksp("com.squareup.moshi:moshi-kotlin-codegen:1.15.0")
}

Gson — The Old Reliable

Google's library. Works, but uses reflection which is slower. Still widely used in older projects.

// build.gradle.kts
dependencies {
    implementation("com.google.code.gson:gson:2.10.1")
}

Null Safety: Kotlin's Superpower

One of Kotlin's best features is null safety. The type system distinguishes between nullable and non-nullable types. This eliminates NullPointerExceptions at compile time.

Our converter automatically detects which fields can be null in your JSON and adds the ? modifier accordingly. For example:

// JSON with optional fields
{
  "id": 1,
  "name": "John",
  "email": null,        // Can be null
  "middleName": null    // Can be null
}

// Generated Kotlin
data class User(
    val id: Int,           // Non-nullable (always present)
    val name: String,      // Non-nullable (always present)
    val email: String?,    // Nullable (can be null)
    val middleName: String? // Nullable (can be null)
)

Working with Nested JSON

Real-world APIs have nested objects. Our converter automatically generates inner data classes for nested structures:

// JSON with nesting
{
  "user": {
    "name": "John",
    "address": {
      "street": "123 Main St",
      "city": "Boston"
    }
  }
}

// Generated Kotlin
@Serializable
data class User(
    val name: String,
    val address: Address
) {
    @Serializable
    data class Address(
        val street: String,
        val city: String
    )
}

Handling Lists and Collections

JSON arrays become Kotlin Lists. Our converter uses immutable List by default (best practice), but you can choose MutableList if needed:

// JSON array
{
  "users": [
    {"id": 1, "name": "John"},
    {"id": 2, "name": "Jane"}
  ]
}

// Generated Kotlin
data class UserList(
    val users: List<User>  // Immutable list - recommended
)

// Alternative with mutable list
data class UserList(
    val users: MutableList<User>  // Mutable if you need modifications
)

Android Parcelable Support

In Android, if you need to pass data between Activities or Fragments, your data class needs to implement Parcelable. Our converter can add this automatically:

import android.os.Parcelable
import kotlinx.parcelize.Parcelize

@Parcelize
@Serializable
data class User(
    val id: Int,
    val name: String,
    val email: String
) : Parcelable

Add this to your module's build.gradle:

plugins {
    id("kotlin-parcelize")
}

Manual vs Automated Data Class Generation

I've done this both ways countless times. Here's the real difference:

Manual Process for a moderate API response (15 fields, nested objects):

• Write class definition and primary constructor (2-3 minutes)
• Add val/var for each field (2-3 minutes)
• Determine nullable types (1-2 minutes)
• Add @SerialName annotations for field mapping (2-3 minutes)
• Create nested data classes for objects (5-10 minutes)
• Handle arrays as List types (1-2 minutes)
• Test and fix compilation errors (2-5 minutes)
• Total: 15-30 minutes per class

Automated Process with this converter:

• Paste JSON → Click Convert → Copy Kotlin code (10 seconds)
• All fields with proper types generated automatically
• Null safety handled perfectly
• @SerialName annotations added when needed
• Nested data classes created automatically
• Lists with correct generic types
• Total: Less than 1 minute

Best Practices for Kotlin Data Classes

1. Use val for Immutability

Prefer val (read-only) over var (mutable) unless you have a good reason. Immutable data classes are thread-safe and easier to reason about.

2. Leverage Default Values

Add default values to prevent null issues and simplify instance creation:

data class User(
    val id: Int = 0,
    val name: String = "",
    val email: String = "",
    val isActive: Boolean = false
)

3. Use @SerialName for Field Mapping

When JSON uses snake_case (created_at) and Kotlin uses camelCase (createdAt), use @SerialName:

data class Post(
    @SerialName("created_at") val createdAt: String
)

4. Keep Data Classes Small

If your data class has more than 10-15 fields, consider splitting it into smaller classes.

5. Use Type Aliases for Complex Types

typealias UserId = Long
typealias ProductList = List<Product>

data class Order(
    val userId: UserId,
    val products: ProductList
)

Common Mistakes to Avoid

Forgetting Null Safety

Always mark fields that can be null with ?. Otherwise, your app will crash when JSON doesn't include that field.

Using var When val Works

Mutable data classes can lead to bugs. Use val by default, switch to var only when needed.

Not Adding Default Values

Default values prevent errors when creating instances manually and make testing easier.

Inconsistent Naming

Be consistent with camelCase for Kotlin properties, use @SerialName to map from snake_case JSON.

@Test
fun testUserSerialization() {
    val json = """{"id":1,"name":"John","email":"john@example.com"}"""
    val user = Json.decodeFromString<User>(json)
    assertEquals(1, user.id)
    assertEquals("John", user.name)
}

Frequently Asked Questions About JSON to Kotlin

Why use data classes instead of regular classes?

Data classes automatically generate equals(), hashCode(), toString(), and copy() methods. They're specifically designed for holding data and are perfect for JSON models.

What's the difference between val and var?

val is read-only (immutable) — you can't change the value after creation. var is mutable — you can change it. Use val unless you need mutation.

How does null safety work?

Kotlin distinguishes between String (cannot be null) and String? (can be null). The compiler forces you to handle null cases, preventing NullPointerException.

Can I use this for Android development?

Absolutely! Generate data classes for Retrofit, add Parcelable for passing data between components, and use with kotlinx.serialization or Moshi.

Does it support Kotlin Multiplatform?

Yes! The generated code works with Kotlin Multiplatform when using kotlinx.serialization, which is fully multiplatform.

Is my data secure?

Yes! All conversion happens in your browser. Your JSON never leaves your device. No servers, no tracking, no data collection.