XML to Java

Generate Java classes/structs automatically from an XML document.

100% Client-Side Local Execution

Upload Data

Class Name:

<user>
  <id>1</id>
  <name>Omni</name>
  <isActive>true</isActive>
</user>

<user>
  <id>1</id>
  <name>Omni</name>
  <isActive>true</isActive>
</user>

import java.util.List;
public class ResponseData {
  private ResponseDataUser user;
  public ResponseDataUser getUser() {
    return this.user;
  }
  public void setUser(ResponseDataUser user) {
    this.user = user;
  }
  public static class ResponseDataUser {
    private int id;
    private String name;
    private boolean isActive;
    public int getId() {
      return this.id;
    }
    public void setId(int id) {
      this.id = id;
    }
    public String getName() {
      return this.name;
    }
    public void setName(String name) {
      this.name = name;
    }
    public boolean isActive() {
      return this.isActive;
    }
    public void setIsActive(boolean isActive) {
      this.isActive = isActive;
    }
  }
}

import java.util.List;
public class ResponseData {
  private ResponseDataUser user;
  public ResponseDataUser getUser() {
    return this.user;
  }
  public void setUser(ResponseDataUser user) {
    this.user = user;
  }
  public static class ResponseDataUser {
    private int id;
    private String name;
    private boolean isActive;
    public int getId() {
      return this.id;
    }
    public void setId(int id) {
      this.id = id;
    }
    public String getName() {
      return this.name;
    }
    public void setName(String name) {
      this.name = name;
    }
    public boolean isActive() {
      return this.isActive;
    }
    public void setIsActive(boolean isActive) {
      this.isActive = isActive;
    }
  }
}

What is XML to Java?

This free online tool turns a sample XML document into a ready-to-use POJO (Plain Old Java Object) for Java, so you can use this xml to java class generator tool to go straight from raw XML to a typed POJO class without writing the boilerplate yourself. It is built around Java's actual idiom — a POJO — rather than a generic one-size-fits-all class, and pairs naturally with JAXB for real-world (de)serialization. Use it for xml to pojo or any time you need jaxb xml to java online, whether you're scaffolding a new Java project or mapping an existing API response.

Technical Execution

Paste or upload a sample XML document and the tool walks its structure field by field, inferring a concrete Java type for each value — mapping basic XML types to `String`, `int`/`Integer`, `boolean`/`Boolean`, and `double`/`Double` as appropriate. For nested data, it maps nested XML elements to nested POJOs and repeated sibling elements to `List<T>`, while XML attributes become simple typed fields alongside child-element fields. On the naming side, it converts snake_case or kebab-case keys (like `first_name`) into Java's camelCase field convention (`firstName`), adding a `@JsonProperty("first_name")` annotation so Jackson still serializes back to the original key. For optional data, fields that show up as `null`, or are missing from some sample records, are typed as boxed wrapper types (`Integer`, `Boolean`, `Double`) instead of Java primitives so they can legitimately hold a null value, and are optionally annotated with `@Nullable`.

Zero Data Storage Guarantee

Everything runs client-side in your browser: the sample XML you paste in — which may contain real field names, endpoint shapes, or structure from a private API or project — is parsed and converted entirely on your device and is never uploaded to any server. Nothing you enter is logged, stored, or transmitted anywhere, so you can safely paste a real payload from an internal or unreleased API to generate an accurate POJO. Closing or refreshing the tab clears everything, since no copy of your data ever left your machine in the first place.

How to Use XML to Java (Step-by-Step Guide)

Copy a representative sample of your XML (the more fields and nested objects it includes, the more complete the generated POJO class will be).
Paste it into the input panel of the XML to Java tool, or click "Upload" to load it from a xml file.
Review the auto-detected root name, and rename it if you want the generated POJO to use a specific class or type name instead of the default.
Click "Generate" to produce the Java POJO class, which appears instantly in the output panel with syntax highlighting.
Click "Copy" to copy the generated code to your clipboard, or "Download" to save it as a `.java` file.
Paste the result into your Java project and adjust field names or types if your data has edge cases the sample didn't cover.

Frequently Asked Questions (FAQ)

Q: How does this tool handle nested objects and arrays when converting XML to Java?

A: The tool maps nested XML elements to nested POJOs and repeated sibling elements to `List<T>`, while XML attributes become simple typed fields alongside child-element fields That keeps the generated code organized the way a Java developer would structure it by hand, instead of flattening everything into one giant POJO class.

Q: What happens to fields that are nullable or missing from some records?

A: For optional data, fields that show up as `null`, or are missing from some sample records, are typed as boxed wrapper types (`Integer`, `Boolean`, `Double`) instead of Java primitives so they can legitimately hold a null value, and are optionally annotated with `@Nullable`. If your sample only has one example object, fields that could be null in other records might not be detected as optional — paste a few varied samples (or an array of objects) for the most accurate result.

Q: Is this better than writing the POJO class by hand?

A: For anything beyond a trivial, flat payload, yes — manually transcribing every field, getter, setter, equals/hashCode, and constructor for a deeply nested API response is slow and is exactly where typos and mismatched types creep in. The generator produces the same result in seconds and gives you a correct starting point to refine, rather than a blank page.

Q: Is my XML data safe to paste into this tool, especially if it's from a private API?

A: Yes. Everything runs client-side in your browser: the sample XML you paste in — which may contain real field names, endpoint shapes, or structure from a private API or project — is parsed and converted entirely on your device and is never uploaded to any server. Nothing you enter is logged, stored, or transmitted anywhere, so you can safely paste a real payload from an internal or unreleased API to generate an accurate POJO. Closing or refreshing the tab clears everything, since no copy of your data ever left your machine in the first place.

Q: Can I use this as a convert xml to java object?

A: Yes — the tool is commonly used as a convert xml to java object, and works the same way whether you're converting a one-off response for a prototype or generating model code for a production project.

Q: Does the tool rename fields to match Java naming conventions?

A: Yes. It converts snake_case or kebab-case keys (like `first_name`) into Java's camelCase field convention (`firstName`), adding a `@JsonProperty("first_name")` annotation so Jackson still serializes back to the original key, so the generated code reads naturally in Java while still deserializing the original XML correctly.

Q: What Java library does the generated code work with?

A: The output is written to pair cleanly with JAXB, the most common choice for Java developers handling XML, so you can drop it into an existing project without changing your serialization setup.

Q: Does this tool work for deeply nested or large XML samples?

A: Yes. The tool recurses through every level of nesting it finds and generates a complete set of linked POJO class definitions, not just the top level — though for very large samples, trimming it down to one representative record per array is usually enough to get an accurate result.

Report an issue with this tool