Input JSON

Dart Output

Classes generated in your browser

Free Online JSON to Dart Converter — No Signup Required

JSON to Dart Online — Generate Dart Classes from JSON

Paste a JSON sample and get clean Dart classes with fromJson and toJson methods — nested objects become their own classes, arrays become List types, and nullable fields are inferred. Fast, secure, and entirely in your browser.

fromJson / toJson Nested classes Lists & nullables 100% browser-based

🔐

100% Browser-Based

Conversion runs locally. Your JSON never leaves your device.

⚙

No build_runner

Hand-written fromJson and toJson, no code-gen step.

📝

Null-Safe

required and nullable types inferred from your sample.

⚡

Fast & Free

Handles large payloads with no signup and no limits.

How It Works

Convert JSON to Dart in 4 Steps

No installation, no signup. Results in milliseconds.

Paste JSON

Paste a representative JSON sample into the input panel.

Name the Class

Set the root class name for the generated model.

Convert

Click Convert and the classes appear instantly.

Copy or Download

Copy the classes or download them as a .dart file.

The Basics

What Is a JSON to Dart Converter?

A JSON to Dart converter reads a sample of JSON and writes the Dart classes that describe its shape, each with a fromJson factory and a toJson method. Instead of hand-writing a model and its serialization for every API response, you paste the response and get ready-to-use classes for your Flutter or Dart app.

Why generate classes from JSON

Dart has no reflection-based JSON binding, so every model needs explicit fromJson and toJson code. Writing that by hand for a large payload is tedious and easy to get wrong. Generating it from a real sample means the types, the null-safety, and the serialization all match the data.

What the converter infers

A class per object, each nested object its own class.
List types for arrays (List<String>, List<Item>).
int vs double, and nullable (Type?) fields.
A fromJson factory and a toJson method on every class.

JSON in → Dart out

JSON → Dart

{ "id": 1, "name": "Ada" }

class Root {
  final int id;
  final String name;

  Root({required this.id, required this.name});

  factory Root.fromJson(Map<String, dynamic> json) => Root(
        id: json['id'] as int,
        name: json['name'] as String,
      );

  Map<String, dynamic> toJson() => {
        'id': id,
        'name': name,
      };
}

Reference

How JSON Maps to Dart

These are the inference rules the converter applies so the output is predictable.

JSON	Becomes in Dart
Object `{ }`	A `class` with a `fromJson` factory and a `toJson` method.
Nested object	Its own named class, referenced from the parent field.
Array `[ ]`	A `List<T>` such as `List<String>` or `List<Item>`.
Whole number	`int`.
Decimal number	`double`.
string / boolean	`String` / `bool`.
Missing key / null	A nullable type, such as `int?`.
null only / mixed types	`dynamic` (or `List<dynamic>` for a mixed array).

fromJson, toJson, and null safety

Every class gets a fromJson factory that reads each key from a Map<String, dynamic> with the right cast, and a toJson method that writes the map back. Non-nullable fields are required in the constructor; a field becomes nullable (Type?) when its key is missing from some records or its value is sometimes null. Validate the JSON first with the JSON parser if it will not convert, or tidy it in the JSON formatter.

When you see `dynamic`

A field that is only ever null, an empty array, or holds more than one unrelated type has no single Dart type, so it falls back to dynamic. Paste a representative sample with those fields populated to get precise types, and give an array of several records so every key is seen. For a deeply nested payload, expanding it in the JSON viewer first helps you confirm the shape.

Walkthrough

A Worked Example: Order Payload to Classes

See how a nested object with an array of items becomes clean Dart classes with serialization.

order.json

{
  "id": "A-1029",
  "items": [
    { "sku": "J-01", "qty": 2 }
  ],
  "total": 19.99
}

order.dart

class Root {
  final String id;
  final List<Item> items;
  final double total;

  Root({required this.id, required this.items, required this.total});

  factory Root.fromJson(Map<String, dynamic> json) => Root(
        id: json['id'] as String,
        items: (json['items'] as List<dynamic>)
            .map((e) => Item.fromJson(e as Map<String, dynamic>))
            .toList(),
        total: json['total'] as double,
      );
  // ... toJson() and class Item follow
}

Notice three things: items became its own Item class decoded with a .map() call, total is a double because the sample has a decimal, and each class carries both fromJson and toJson. For the step-by-step reasoning, see our guide on converting JSON to Dart classes.

Use Cases

When to Convert JSON to Dart

Typed, serializable models from real data, in seconds.

Flutter API Models

Generate the model a REST response decodes into, serialization included.

Decode Responses

Pair with jsonDecode to turn a response body into typed objects.

Local Storage

Serialize models to JSON for shared_preferences or a file.

State Management

Give blocs and providers typed data classes to work with.

Test Fixtures

Build models from fixture JSON for widget and unit tests.

Learning

See how JSON shapes map onto Dart classes and serialization.

FAQ

Frequently Asked Questions

Everything developers ask about generating Dart classes from JSON.

What does a JSON to Dart converter do?▼

It reads a JSON sample and generates Dart classes that describe its shape, each with a fromJson factory and a toJson method so you can decode and encode the data. Nested objects become their own classes and arrays become List types. Everything runs in your browser.

Does it generate fromJson and toJson?▼

Yes. Every class gets a fromJson factory constructor that builds it from a Map<String, dynamic>, and a toJson method that returns one, because Dart has no built-in reflection-based JSON binding and expects these methods.

How are numbers typed?▼

Whole numbers become int and numbers with a decimal point become double. Dart distinguishes the two, so a representative sample makes sure a field that can hold decimals is typed double.

How are optional and nullable fields handled?▼

A field becomes nullable (Type?) when its key is missing from some objects in an array or its value is sometimes null, and its constructor parameter drops the required keyword. Non-nullable fields are marked required.

Does it handle nested objects and arrays?▼

Yes. Each nested object becomes its own class with its own fromJson and toJson, referenced from the parent, and arrays become List types such as List<String> or List<Item>, decoded with a map call.

Why do some fields become dynamic?▼

A field that is only ever null, an empty array, or holds more than one unrelated type has no single Dart type, so it falls back to dynamic (or List<dynamic> for a mixed array).

Is my JSON uploaded anywhere?▼

No. Conversion runs entirely in your browser using JavaScript. Your JSON is never uploaded, never stored, and never logged, so it is safe for sensitive payloads.

How do I use the generated classes?▼

Decode a parsed map with Root.fromJson(jsonDecode(source) as Map<String, dynamic>), and encode back with jsonEncode(value.toJson()). No build_runner or code generation step is required.

Related Guides