JSON to Swift Codable generator

Paste a JSON response and get Swift structs that decode it with JSONDecoder. Keys become camelCase properties, and a struct whose keys differ gets a CodingKeys enum with the exact JSON names. Values that can be null or missing become optionals.

JSON sample

Propertiesletvar

Swift code

import Foundation

struct Root: Codable {
    let orderId: Int
    let customer: Customer
    let items: [Item]
    let paid: Bool

    enum CodingKeys: String, CodingKey {
        case orderId = "order_id"
        case customer
        case items
        case paid
    }
}

struct Customer: Codable {
    let name: String
    let email: JSONValue
}

struct Item: Codable {
    let sku: String
    let qty: Int
    let price: Double
    let giftNote: String?

    enum CodingKeys: String, CodingKey {
        case sku
        case qty
        case price
        case giftNote = "gift_note"
    }
}

enum JSONValue: Codable {
    case string(String)
    case number(Double)
    case bool(Bool)
    case object([String: JSONValue])
    case array([JSONValue])
    case null

    init(from decoder: Decoder) throws {
        let c = try decoder.singleValueContainer()
        if c.decodeNil() { self = .null }
        else if let v = try? c.decode(Bool.self) { self = .bool(v) }
        else if let v = try? c.decode(Double.self) { self = .number(v) }
        else if let v = try? c.decode(String.self) { self = .string(v) }
        else if let v = try? c.decode([JSONValue].self) { self = .array(v) }
        else { self = .object(try c.decode([String: JSONValue].self)) }
    }

    func encode(to encoder: Encoder) throws {
        var c = encoder.singleValueContainer()
        switch self {
        case .string(let v): try c.encode(v)
        case .number(let v): try c.encode(v)
        case .bool(let v): try c.encode(v)
        case .object(let v): try c.encode(v)
        case .array(let v): try c.encode(v)
        case .null: try c.encodeNil()
        }
    }
}

Runs in your browser: nothing you enter is sent anywhere.

How to use it

Paste a JSON sample with realistic data; several items per array help find optional keys.
Choose let (immutable) or var properties.
Copy the code into a .swift file and decode with try JSONDecoder().decode(Root.self, from: data).

How it works

The sample is read into a shape: every key with every type seen there. All objects of one array become one struct, so a key present in only some of them becomes optional. Codable decodes a missing optional key as nil.

Property names are camelCase: order_id → orderId; a Swift keyword such as default is written in backticks.
Struct names come from keys: items holds [Item], customer becomes Customer.
A top-level array gives a typealias, such as typealias Root = [RootItem].

Worked example

{"line_items":[{"sku":"A","note":null,"qty":1},{"sku":"B","note":"x"}]} with var gives:

import Foundation

struct Root: Codable {
    var lineItems: [LineItem]

    enum CodingKeys: String, CodingKey {
        case lineItems = "line_items"
    }
}

struct LineItem: Codable {
    var sku: String
    var note: String?
    var qty: Int?
}

Tips

Dates arrive as strings: change the type to Date and set decoder.dateDecodingStrategy (for example .iso8601) if you want them parsed.
Add Identifiable or Hashable conformance yourself where SwiftUI needs it.
For Kotlin or TypeScript models of the same JSON, use the neighbouring generators.

Frequently asked questions

How are JSON types mapped to Swift?

Strings become String, true and false Bool, whole numbers Int and other numbers Double (a mix of both becomes Double). Arrays become [T], objects become their own Codable structs, and null or a key missing from some objects makes the property optional (T?).

When is a CodingKeys enum added?

When at least one property name differs from its JSON key, for example orderId for order_id. Swift then needs a case for every property, so the enum lists them all, with the JSON name only where it differs.

What is JSONValue?

Codable has no built-in type for "any JSON". When a place holds different kinds of values, the generator uses a small enum JSONValue (string, number, bool, object, array, null) and appends its Codable code to the output.

Can I use convertFromSnakeCase instead?

Yes: with decoder.keyDecodingStrategy = .convertFromSnakeCase you can delete the CodingKeys enums for snake_case keys. Keep them if keys use other styles, such as first-name, that the strategy does not convert.

More in Developer

All tools in this category: Developer ·Updated November 4, 2026