XML to YAML Converter

Understanding XML and YAML

XML (Extensible Markup Language) has been the dominant format for structured data exchange in enterprise environments for over two decades. It uses opening and closing tags to define elements, supports attributes for metadata, and allows namespaces and schemas for validation. XML powers SOAP web services, Maven and Ant build configurations, Android layout files, and countless legacy integration systems. Its strict structure makes it ideal for scenarios demanding formal validation, but the verbosity of opening/closing tags and angle brackets makes it difficult to read and maintain by hand. For a detailed overview of XML syntax and best practices, visit our XML guide.

YAML (YAML Ain't Markup Language) is a human-friendly data serialization format that uses indentation rather than tags to convey structure. It has become the standard configuration format for cloud-native tools including Kubernetes, Docker Compose, Ansible, GitHub Actions, and GitLab CI/CD. YAML supports scalars, sequences (lists), and mappings (dictionaries), with optional type annotations and multi-line string literals. Its clean, whitespace-based syntax makes it easy to read, write, and diff in version control. For more on YAML features including anchors, aliases, and multi-document streams, see our YAML guide.

Converting XML to YAML means replacing verbose tag-based markup with clean indentation-based structure. The result is typically 40-60% shorter by character count, dramatically improving readability for human operators while preserving the same hierarchical data relationships.

Why Convert XML to YAML?

The shift from XML to YAML is one of the most common configuration modernization patterns in software engineering. Here are the primary use cases:

• Modernizing Spring XML configs to Kubernetes manifests. Legacy Java applications often use Spring XML bean definitions. When containerizing these applications for Kubernetes, teams need to express the same configuration in YAML — the native format for Kubernetes Deployments, Services, and ConfigMaps.
• Processing XML data with YAML-based DevOps tools. CI/CD pipelines (GitHub Actions, GitLab CI, CircleCI) are configured in YAML. When build or deployment metadata is stored as XML, converting it to YAML enables seamless integration into modern pipelines.
• Simplifying configuration file maintenance. YAML files are easier to read in code reviews, produce cleaner diffs in Git, and require less typing than equivalent XML. Teams migrating to YAML reduce configuration errors caused by mismatched closing tags or forgotten angle brackets.
• Migrating from SOAP to REST. Organizations replacing SOAP services (which use XML payloads and WSDL definitions) with REST APIs often adopt YAML-based OpenAPI specifications. Converting existing XML schemas to YAML is a common first step.

How the Conversion Works

This is a cross-format conversion that uses JSON as an intermediate representation. The process involves two distinct stages:

1. XML to JSON: The XML document is parsed by fast-xml-parser. Each XML element becomes a JSON object key, attributes are stored with an @_ prefix, and text content is placed in a #text property. Sibling elements with the same tag name are automatically grouped into JSON arrays.
2. JSON to YAML: The JSON intermediate is serialized to YAML by js-yaml. JSON objects become YAML mappings, JSON arrays become YAML sequences, and primitive values (strings, numbers, booleans, null) are output with appropriate YAML scalar representations.

The table below shows how XML constructs map to their YAML equivalents:

Before and After Example

Below is an XML application configuration and its YAML equivalent after conversion. Notice how XML tags and attributes map cleanly to YAML keys and indented structures.

<?xml version="1.0" encoding="UTF-8"?>
<application>
  <server port="8080">
    <host>localhost</host>
    <ssl enabled="true">
      <cert>/etc/ssl/cert.pem</cert>
      <key>/etc/ssl/key.pem</key>
    </ssl>
  </server>
  <database>
    <host>db.example.com</host>
    <port>5432</port>
    <name>myapp_prod</name>
  </database>
  <logging>
    <level>info</level>
    <output>stdout</output>
  </logging>
</application>

application:
  server:
    "@_port": "8080"
    host: localhost
    ssl:
      "@_enabled": "true"
      cert: /etc/ssl/cert.pem
      key: /etc/ssl/key.pem
  database:
    host: db.example.com
    port: "5432"
    name: myapp_prod
  logging:
    level: info
    output: stdout

The XML attributes like port="8080" and enabled="true" are preserved as @_port and @_enabled keys in the YAML output. The hierarchical nesting of elements translates directly to YAML indentation, producing a compact and readable result.

Tips and Best Practices

Related Tools

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