Input JSON

Java Output

Classes generated in your browser

Free Online JSON to Java Converter — No Signup Required

JSON to Java Online — Generate Java Classes from JSON

Paste a JSON sample and get clean Java classes ready for Jackson — nested objects become their own classes, arrays become List types, and every field carries a @JsonProperty tag. Fast, secure, and entirely in your browser.

Jackson POJOs Nested classes List & boxed types 100% browser-based

🔐

100% Browser-Based

Conversion runs locally. Your JSON never leaves your device.

⚙

Jackson-Ready

@JsonProperty tags and boxed nullable types out of the box.

📝

Clean POJOs

Nested classes, List types and the imports you need.

⚡

Fast & Free

Handles large payloads with no signup and no limits.

How It Works

Convert JSON to Java in 4 Steps

No installation, no signup. Results in milliseconds.

Paste JSON

Paste a representative JSON sample into the input panel.

Set Options

Name the root class and toggle Jackson annotations.

Convert

Click Convert and the classes appear instantly.

Copy or Download

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

The Basics

What Is a JSON to Java Converter?

A JSON to Java converter reads a sample of JSON and writes the Java classes, POJOs, that describe its shape, ready to deserialize with Jackson's ObjectMapper. Instead of hand-writing a class for every API response, you paste the response and get typed classes you can drop into your package.

Why generate classes from JSON

Java needs a concrete type to bind JSON to, and writing those classes by hand for a large payload is slow and error-prone, especially the annotations that map camelCase fields to the API's actual keys. Generating them from a real sample means the fields, types, and tags match the data exactly.

What the converter infers

A class per object, each nested object its own class.
List types for arrays (List<String>, List<Item>).
Boxed types (Long, Double, Boolean) so any field can be null.
A @JsonProperty tag per field, and the imports you need.

JSON in → Java out

JSON → Java

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

public class Root {
    @JsonProperty("id")
    public Long id;
    @JsonProperty("name")
    public String name;
}

Reference

How JSON Maps to Java

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

JSON	Becomes in Java
Object `{ }`	A `class` with one field per key.
Nested object	Its own named class, referenced from the parent field.
Array `[ ]`	A `List<T>` such as `List<String>` or `List<Item>`.
Whole number	`Long`.
Decimal number	`Double`.
string / boolean	`String` / `Boolean`.
null only / mixed types	`Object` (or `List<Object>` for a mixed array).

@JsonProperty and boxed types

Every field gets a @JsonProperty("key") annotation carrying the original JSON key, so a camelCase Java field maps to a snake_case or otherwise-named key without a custom naming strategy. Boxed wrapper types (Long, Double, Boolean) are used throughout, because a primitive like long cannot be null and so cannot represent a missing or null JSON value. Validate the JSON first with the JSON parser if it will not convert, or tidy it in the JSON formatter.

When you see `Object`

A field that is only ever null, an empty array, or holds more than one unrelated type has no single concrete Java type, so it falls back to Object. 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, annotated Java classes.

order.json

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

Order.java

public class Root {
    @JsonProperty("id")
    public String id;
    @JsonProperty("items")
    public List<Item> items;
    @JsonProperty("total")
    public Double total;
}

class Item {
    @JsonProperty("sku")
    public String sku;
    @JsonProperty("qty")
    public Long qty;
}

Notice three things: items became its own Item class and a List, total is a Double because the sample has a decimal, and every field carries its @JsonProperty tag. For the step-by-step reasoning, see our guide on converting JSON to Java classes.

Use Cases

When to Convert JSON to Java

Typed POJOs from real data, in seconds.

Deserialize API Responses

Generate the class a response binds to with Jackson, tags and all.

Spring Boot Clients

Model third-party payloads as request and response POJOs.

Config Binding

Type a JSON config so it binds to a checked class.

Kafka & Messaging

Model event and message payloads as Java types quickly.

Test Fixtures

Give fixtures matching classes for unit and integration tests.

Learning

See how JSON shapes map onto Java types and Jackson tags.

FAQ

Frequently Asked Questions

Everything developers ask about generating Java classes from JSON.

What does a JSON to Java converter do?▼

It reads a JSON sample and generates Java classes (POJOs) that describe its shape, ready to deserialize with Jackson. Nested objects become their own classes and arrays become List types. Everything runs in your browser.

Does it add Jackson annotations?▼

Yes, by default. Each field gets a @JsonProperty("key") annotation using the original JSON key, so a camelCase Java field still maps to a snake_case or otherwise-named key. You can turn the annotations off if you prefer plain fields.

How are numbers typed?▼

Whole numbers become Long and numbers with a decimal point become Double. Boxed types are used throughout so any field can be null, which is safer than primitives for JSON that may omit values.

Why boxed types like Long instead of long?▼

A primitive long cannot be null, so it cannot represent a missing or null JSON value. Boxed types (Long, Double, Boolean) can be null, which matches how JSON actually behaves and avoids surprises on deserialization.

Does it handle nested objects and arrays?▼

Yes. Each nested object becomes its own named class referenced from the parent, and arrays become List types such as List<String> or List<Item>, with the element type inferred from the items.

Why do some fields become Object?▼

A field that is only ever null, an empty array, or holds more than one unrelated type has no single concrete Java type, so it falls back to Object (or List<Object> 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?▼

Paste them into your project, keep the root class public in its own file, and deserialize with Jackson's ObjectMapper: mapper.readValue(json, Root.class). Add getters or Lombok if your style needs them.

Related Guides