JSON to XML Converter

Example Input

{
  "user": {
    "id": 1,
    "name": "Priya Singh",
    "email": "priya@learnhubly.com",
    "roles": ["admin", "developer"],
    "profile": {
      "bio": "Principal Software Engineer"
    }
  }
}

Example Output

<root>
  <user>
    <id>1</id>
    <name>Priya Singh</name>
    <email>priya@learnhubly.com</email>
    <roles>
      <role>admin</role>
      <role>developer</role>
    </roles>
    <profile>
      <bio>Principal Software Engineer</bio>
    </profile>
  </user>
</root>

Does it handle arrays?

Yes. JSON arrays are converted to sequences of sibling XML elements. A roles array containing ['admin', 'user'] becomes two role elements (using the singular of 'roles') inside a roles wrapper element. An array of objects becomes sibling elements, each containing the object's properties as child elements. The element name for array items is derived from the parent key — roles becomes role elements, items becomes item elements. If the target schema uses different element names for array items, edit the generated element tags before using the XML.

Can I customize the root tag?

The tool uses root as the default root element name. To change it, edit the opening and closing root tags in the generated XML output directly — replace root with your intended element name like Request, Response, User, or whatever the target schema expects. For SOAP, the generated XML does not go inside a root element at all — it goes inside the soapenv:Body element of the SOAP envelope, so remove the root wrapper and add the SOAP envelope structure around the converted content.

Is it safe for internal API payloads?

Yes. All conversion runs in your browser using JavaScript. Your JSON content — including any internal data model fields, sensitive values, or proprietary payload structures — never leaves your machine. This is relevant for enterprise integration work where the JSON you are converting may contain internal service URLs, authentication tokens, or other information you would not want transmitted to a third-party tool.

What is the difference between converting JSON to XML vs writing XML directly?

For complex schemas with namespace requirements, XML attributes, mixed content, and processing instructions, writing XML directly in a code editor with schema validation gives you more control and catches errors immediately. JSON-to-XML conversion is the right approach for exploratory work — quickly generating a plausible XML structure from a data object to understand the element hierarchy, compare to a schema, or generate a test fixture. For production code that constructs XML programmatically, use a proper XML library: JAXB in Java, lxml in Python, DOMDocument in PHP, the xml package in Go — these give you explicit control over attributes, namespaces, and schema compliance.

How do I convert JSON to XML in code?

In JavaScript (Node.js): use the xml2js package — const builder = new xml2js.Builder(); const xml = builder.buildObject(jsonObject). In Python: use the dicttoxml package — import dicttoxml; xml = dicttoxml.dicttoxml(json_dict, root=True). In Java: use JAXB — annotate a Java class with @XmlRootElement and @XmlElement, populate it from JSON, and use JAXBContext.newInstance(User.class).createMarshaller().marshal(user, System.out). In .NET: use Newtonsoft.Json — XDocument doc = JsonConvert.DeserializeXNode(jsonString, 'root'). Each library has different rules for attribute vs element mapping and array handling, so test with a sample before using in production.

Why does the XML for a SOAP service look different from the JSON I convert?

SOAP XML has structural requirements that the JSON data does not: the SOAP envelope with its soapenv: namespace prefix, the Body element, service-specific namespace declarations from the WSDL, and the exact element names and nesting that the service endpoint expects. Converting your data JSON to XML gives you the data structure in XML form, but the SOAP message structure is a wrapper around that data, not derived from it. Read the WSDL's message definitions and operation schemas to understand the exact XML structure the endpoint expects, use this tool to generate the data portion, then manually construct the SOAP envelope around it, or use a SOAP client library that handles the envelope construction automatically.

Does JSON have an equivalent to XML attributes?

No. XML has two ways to attach information to an element: child elements (content between the opening and closing tags) and attributes (key-value pairs in the opening tag). JSON has only one mechanism: object properties. When converting JSON to XML, all JSON properties become child elements — there is no automatic mapping to XML attributes because JSON has no concept of attributes. If you need XML attributes in the output (common in SOAP and many XML schemas), you must add them manually after the conversion or use a conversion library that has explicit rules for which JSON properties become attributes and which become elements — json2xml in Python has an attr_type option, and xml2js in Node.js has the headless and explicitArray options.

Can I convert XML back to JSON?

Yes — use the XML to JSON or the JSON Formatter tool on LearnHubly which handles XML input. Note that XML-to-JSON conversion is not a perfect inverse of JSON-to-XML — XML attributes become nested objects with a dollar-sign key convention in most libraries, XML text content mixed with child elements requires special handling, and XML namespaces have no natural JSON equivalent. For data that round-trips through both formats, it is better to define explicit transformation rules for each direction rather than relying on automatic conversion in both directions.