Conversor XML para JSON

O que é a Conversão XML para JSON e Como Funciona?

// Convert XML to JSON in Node.js using fast-xml-parser
import { XMLParser } from 'fast-xml-parser';

const xml = `<catalog>
  <product id="P01">
    <name>Wireless Headphones</name>
    <price currency="USD">79.99</price>
  </product>
</catalog>`;

const parser = new XMLParser({
  ignoreAttributes: false,      // preserve attributes
  attributeNamePrefix: '@_',    // @_ prefix for attributes
  textNodeName: '#text',        // #text for mixed element content
  parseAttributeValue: false,   // no type coercion on attributes
  parseTagValue: false,         // no type coercion on element text
});

const result = parser.parse(xml);
console.log(JSON.stringify(result, null, 2));
// {
//   "catalog": {
//     "product": {
//       "@_id": "P01",
//       "name": "Wireless Headphones",
//       "price": {
//         "@_currency": "USD",
//         "#text": "79.99"
//       }
//     }
//   }
// }

Recursos Principais

Exemplos

<?xml version="1.0" encoding="UTF-8"?>
<appConfig version="2.1" env="production">
  <database>
    <host>db.example.com</host>
    <port>5432</port>
    <name>myapp_prod</name>
    <pool max="10" min="2"/>
  </database>
  <cache enabled="true">
    <ttl>3600</ttl>
    <driver>redis</driver>
  </cache>
</appConfig>

<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://go-tools.org/tools/xml-to-json</loc>
    <lastmod>2026-05-29</lastmod>
    <changefreq>weekly</changefreq>
    <priority>0.8</priority>
  </url>
  <url>
    <loc>https://go-tools.org/tools/json-to-xml</loc>
    <lastmod>2026-05-29</lastmod>
    <changefreq>weekly</changefreq>
    <priority>0.8</priority>
  </url>
</urlset>

<item>
  <title>XML to JSON: A Practical Guide</title>
  <link>https://go-tools.org/blog/xml-to-json-guide</link>
  <pubDate>Thu, 29 May 2026 00:00:00 GMT</pubDate>
  <category>Developer Tools</category>
  <description>Learn how XML attributes map to @_ keys, how repeated elements become arrays, and why values stay strings in any XML-to-JSON conversion.</description>
  <guid isPermaLink="true">https://go-tools.org/blog/xml-to-json-guide</guid>
</item>

Como Usar

1. 1

   Cole seu XML

   Insira ou cole seu XML no campo de entrada acima. Você também pode clicar em 'Carregar exemplo' para experimentar uma amostra — um arquivo de configuração, um fragmento de sitemap ou um item RSS.

2. 2

   Veja a Saída JSON ao Vivo

   O JSON aparece instantaneamente no painel de saída. Os atributos tornam-se chaves com prefixo @_, o conteúdo de texto de elementos mistos torna-se #text e elementos irmãos repetidos tornam-se arrays. Ajuste a indentação (2 ou 4 espaços) conforme necessário.

3. 3

   Copie ou Baixe

   Clique em Copiar para pegar o JSON para a área de transferência ou em Baixar para salvá-lo como arquivo .json pronto para a sua aplicação, API ou pipeline de dados.

Armadilhas Comuns de Conversão

// XML: <timeout>30</timeout>
// JSON output: { "timeout": "30" }  ← string, not number
// Dangerous: comparing as-is
if (config.timeout > 25) { ... }  // "30" > 25 coerces, but fragile

// XML: <timeout>30</timeout>
// JSON output: { "timeout": "30" }
// Safe: explicit coercion where you know the type
if (parseInt(config.timeout, 10) > 25) { ... }

// XML with one item: <root><item>a</item></root>
// JSON: { "root": { "item": "a" } }  ← string, not array
result.root.item.forEach(i => console.log(i));  // TypeError: not a function

// Normalize to array regardless of count
const items = [].concat(result.root?.item ?? []);
items.forEach(i => console.log(i));  // safe for 0, 1, or many

// XML: <price currency="USD">29.99</price>
// JSON: { "price": { "@_currency": "USD", "#text": "29.99" } }
const amount = result.price;  // { "@_currency": "USD", "#text": "29.99" }, not "29.99"

// Handle both plain string and @_/#text object
const raw = result.price;
const amount = typeof raw === 'object' ? raw['#text'] : raw;  // "29.99"

<!-- Unescaped & — well-formedness error -->
<query>name = 'Alice' & role = 'admin'</query>

<!-- Escaped & — valid XML -->
<query>name = 'Alice' &amp; role = 'admin'</query>

// XML: <zipCode>01234</zipCode>
// This tool outputs: { "zipCode": "01234" }  ← correct
// But if a downstream schema coerces:
// { zipCode: z.number() }  → 1234  ← leading zero lost

// Declare ZIP codes and other padded identifiers as strings
// { zipCode: z.string() }  → "01234"  ← correct

Casos de Uso Comuns

Consumindo APIs SOAP / XML Legadas

Serviços corporativos legados (bancos, seguros, logística) frequentemente expõem APIs SOAP que retornam XML. Converta a resposta para JSON para trabalhar com os dados usando ferramentas JavaScript modernas, armazená-los em um banco de dados de documentos ou encaminhá-los para um consumidor de API REST.

Processando Feeds RSS e Atom

Feeds RSS 2.0 e Atom 1.0 são XML. Converta o XML do feed para JSON para extrair títulos, links, datas de publicação e descrições para agregadores de feed, pipelines de conteúdo e sistemas de notificação sem dependência de uma biblioteca de análise XML.

Analisando Arquivos de Sitemap

Arquivos sitemap.xml enumeram as URLs de um site com metadados. Converta um sitemap para JSON para analisar cobertura de URL, construir filas de rastreamento, comparar sitemaps entre ambientes ou alimentar URLs em um verificador de links ou ferramenta de auditoria SEO.

Transformando Arquivos de Configuração

Muitos sistemas corporativos (Spring, Maven, Ant, JBoss, Tomcat) usam arquivos de configuração XML. Converta-os para JSON para análise, scripts de migração, geração de documentação ou importação em ferramentas que usam JSON nativamente.

Desenvolvimento Mobile e Android

Recursos Android, arquivos de layout e AndroidManifest.xml são todos XML. Converta-os para JSON para scripts de análise, auditoria automatizada ou geração de documentação sobre permissões declaradas, atividades e valores de recursos.

Migração de Dados e ETL

Exportações de dados de sistemas corporativos (ERP, CRM, folha de pagamento) frequentemente chegam como XML. Converta para JSON como o primeiro passo em um pipeline ETL para carregar os dados em um repositório nativo de JSON como MongoDB, Firestore ou uma API REST.

Detalhes Técnicos

DOMParser do Navegador para Análise XML

A entrada XML é analisada usando o DOMParser nativo do navegador com o tipo MIME 'text/xml' — o mesmo mecanismo usado para renderizar SVG e XHTML. É totalmente compatível com XML 1.0 e reporta erros de boa formação com informações de linha e coluna. Essa abordagem lida corretamente com namespaces, seções CDATA, instruções de processamento e referências de entidade sem qualquer dependência de terceiros.

Serialização DOM para JSON Recursiva

Após a análise, a ferramenta percorre a árvore DOM recursivamente. Nós de elemento tornam-se objetos JSON; seus atributos tornam-se chaves com prefixo @_; elementos somente de texto tornam-se valores de string simples; elementos com tanto atributos quanto conteúdo de texto ganham uma chave #text para o conteúdo de texto. Elementos irmãos com o mesmo nome são coletados e enviados como um array JSON. Nós de texto somente com espaços em branco entre elementos são descartados.

Sem Coerção de Tipo — Preservação de Strings

Todos os valores de atributo e conteúdo de texto são escritos na saída JSON como strings. Nenhum parseInt, parseFloat ou análise de booleano é aplicado. Esta é uma escolha de design deliberada para prevenir corrupção silenciosa de dados para valores com zero à esquerda, decimais sensíveis à precisão e strings de aparência booleana. A coerção de tipo, quando necessária, deve ser aplicada explicitamente no código downstream.

100% Baseado no Navegador — Sem Upload, Sem Servidor

Todo o processamento é executado no mecanismo JavaScript do seu navegador. Nenhum dado é transmitido pela rede em nenhum momento. Entradas maiores que 200KB mudam automaticamente do modo ao vivo para o modo manual (exigindo um clique explícito em Converter) para manter o navegador responsivo e evitar o bloqueio da thread principal durante a travessia pesada do DOM.

Melhores Práticas

Valide a Boa Formação do XML Primeiro

Se a sua fonte XML é escrita à mão ou gerada por um sistema que ocasionalmente produz saída malformada, valide-a antes de converter. Use o botão Validar do Formatador XML para confirmar que o XML é bem formado e obter localizações precisas de erros para quaisquer problemas.

Normalize Campos de Um-ou-Vários para Arrays

Quando o seu esquema XML permite um ou vários elementos filhos com o mesmo nome, a saída JSON será um objeto para um elemento e um array para vários. Sempre normalize esses campos no seu código consumidor: const items = [].concat(result.items ?? []) — isso é seguro para zero, um ou vários e evita TypeErrors.

Aplique Coerção de Tipo Explicitamente e Seletivamente

Como esta ferramenta preserva todos os valores como strings, aplique coerção de tipo deliberadamente no seu código para os campos específicos que precisam dela. Usar parseInt(val, 10) para um campo inteiro conhecido é seguro. Aplicar coerção amplamente com Number(val) arrisca corromper valores com zero à esquerda, strings vazias e decimais sensíveis à precisão.

Verifique #text ao Acessar Valores de Elemento

Se um elemento pode ter atributos em alguns payloads e não em outros, seu valor JSON será uma string simples (sem atributos) ou um objeto com chaves @_ e uma chave #text (com atributos). Escreva acessores robustos: const val = typeof node === 'object' ? node['#text'] : node. Esse padrão lida com ambas as formas e evita valores undefined silenciosos.

Para Trabalho XML Sem Perdas, Use o Formatador XML

A conversão XML para JSON descarta comentários, instruções de processamento e semântica de namespace. Se você precisar preservar todo o conteúdo XML exatamente, use o Formatador XML para embelezar, minificar e validar sem nenhuma perda. Converta para JSON apenas quando precisar trabalhar com os dados em um contexto nativo de JSON.

Perguntas Frequentes