XML to TOML Converter

Understanding XML and TOML

XML (Extensible Markup Language) is a verbose but powerful markup language for structured data. It uses paired opening and closing tags to define elements, supports attributes for metadata, and provides namespaces and schemas for rigorous validation. XML has been the foundation of enterprise configuration for decades — powering Java's Maven and Spring frameworks, .NET's app.config files, and Android manifest files. While XML's strictness enables formal validation with XSD schemas, its tag-heavy syntax makes configuration files lengthy and difficult to read. For a thorough introduction to XML features and patterns, visit our XML guide.

TOML (Tom's Obvious, Minimal Language) is a configuration file format designed to be easy to read due to its clear semantics. TOML uses square-bracketed table headers, dotted key paths, and typed values to express hierarchical configuration data. It is the official configuration format for Rust's Cargo package manager (Cargo.toml), Python's packaging system (pyproject.toml), Hugo static site generator, and many other modern tools. TOML distinguishes between strings, integers, floats, booleans, dates, arrays, and tables at the syntax level, eliminating the type ambiguity that plagues XML and YAML. For details on TOML syntax, data types, and table hierarchies, see our TOML guide.

Converting XML to TOML means moving from a tag-based, schema-validated format to a minimal, strongly-typed configuration language. The result is dramatically shorter and easier to maintain, though TOML's stricter type system means some XML patterns (such as mixed content and heterogeneous arrays) require careful handling.

Why Convert XML to TOML?

The migration from XML to TOML is increasingly common as projects adopt modern toolchains. Here are the primary scenarios where this conversion is valuable:

• Converting XML configs for Rust projects. Rust's entire ecosystem uses TOML for configuration — from Cargo.toml for package management to rustfmt.toml for code formatting. If your project has legacy XML configuration, converting to TOML aligns with Rust conventions and tooling expectations.
• Migrating Python project settings. Python's packaging ecosystem has standardized on pyproject.toml (PEP 518/621). Projects that previously stored configuration in XML files can convert to TOML for compatibility with pip, poetry, and other build tools.
• Simplifying application configuration. TOML's explicit type system and flat table structure make configuration files self-documenting. A TOML file is immediately clear about whether a value is a string, number, or boolean — something XML achieves only with external schemas.
• Reducing configuration file size. TOML files are typically 50-70% smaller than equivalent XML configurations because they eliminate opening/closing tags, angle brackets, and namespace declarations. This makes configuration files easier to review in pull requests and less error-prone to edit.

How the Conversion Works

Since XML and TOML have no direct conversion path, this converter uses JSON as an intermediate representation. The process follows a two-stage pipeline:

1. XML to JSON: The XML document is parsed by fast-xml-parser. Elements become JSON object keys, attributes are stored with an @_ prefix, text content goes into #text properties, and repeated sibling elements become JSON arrays.
2. JSON to TOML: The JSON intermediate is serialized to TOML by smol-toml. JSON objects become TOML tables (sections marked with [table] headers), nested objects become nested tables, arrays of objects become TOML arrays of tables ([[array]]), and primitive values are output with their TOML type representations.

The table below illustrates how common XML patterns translate into TOML constructs:

Before and After Example

Below is an XML application settings file and its TOML equivalent after conversion. Notice how XML element hierarchies translate cleanly into TOML table sections.

<?xml version="1.0" encoding="UTF-8"?>
<config>
  <package>
    <name>my-tool</name>
    <version>2.1.0</version>
    <authors>Alice,Bob</authors>
  </package>
  <database>
    <host>localhost</host>
    <port>5432</port>
    <name>appdb</name>
    <ssl>true</ssl>
  </database>
  <logging>
    <level>info</level>
    <file>/var/log/app.log</file>
  </logging>
</config>

[config.package]
name = "my-tool"
version = "2.1.0"
authors = "Alice,Bob"

[config.database]
host = "localhost"
port = "5432"
name = "appdb"
ssl = "true"

[config.logging]
level = "info"
file = "/var/log/app.log"

Each top-level XML element within <config> becomes a TOML table. Child elements are converted to key-value pairs within those tables. Note that all values remain strings since XML does not distinguish between types — you may want to manually adjust types like port to an integer and ssl to a boolean in the final TOML.

Tips and Best Practices

Related Tools

Explore other converters and resources that complement XML-to-TOML conversion: