Convertisseur XML vers JSON

Convertit des données XML en JSON. Transformez les réponses d'anciennes API XML, des messages SOAP ou des flux RSS/Atom en JSON — attributs sous @attributes, texte sous #text, éléments répétés en tableaux — directement dans le navigateur.

Convertir du XML en JSON

Il arrive que l'on veuille voir le contenu d'une vieille interface XML, d'un échange SOAP ou d'un flux RSS ou Atom sous la forme de JSON dont on a l'habitude. Cet outil convertit le XML que vous collez et mène tout le travail à son terme dans le navigateur, de sorte que rien de ce que vous collez ne quitte jamais votre appareil.

**Un ensemble de conventions s'impose précisément parce que XML et JSON conservent les données de manières foncièrement différentes.** Le XML distingue les attributs du texte et autorise un élément de même nom à paraître autant de fois qu'il le faut ; le JSON n'a ni l'un ni l'autre. Les attributs sont donc placés sous `@attributes`, la chaîne qu'un élément porte directement sous `#text`, et les éléments répétés deviennent des tableaux. **Ce à quoi l'on n'échappe pas, c'est l'ambiguïté qui naît lorsqu'un élément répétable ne paraît qu'une seule fois.** Dans le XML d'origine il demeure une occurrence de quelque chose de répétable, mais en JSON il ressemble à une valeur unique ; le code récepteur est donc plus sûr s'il est écrit pour traiter aussi bien un élément que plusieurs.

Comment s'en servir

  1. Collez le XML Une réponse SOAP ou un flux RSS s'y place exactement tel qu'il se présente.
  2. Parcourez la conversion **Les attributs se logent sous la clé `@attributes` et le texte sous `#text`.**
  3. Comparez les structures Placé à côté du XML d'origine, il permet de vérifier quel élément a abouti sous quelle clé.
  4. Copiez ou téléchargez le résultat Collez-le directement dans votre code ou enregistrez-le comme fichier.

Astuces pour en tirer le meilleur parti

  • Les éléments avec attributs sont regroupés dans un objet `@attributes`, séparé du texte ou des éléments enfants propres à l'élément.
  • Quand un élément mélange des attributs avec des éléments enfants ou du texte, la partie texte est stockée sous `#text`, afin de ne jamais être confondue avec une valeur d'attribut.
  • Les éléments frères qui partagent le même nom sont automatiquement regroupés en tableau : trois balises `` deviennent un tableau de 3 éléments, tandis qu'une seule reste un simple objet.
  • Un élément vide sans attribut, texte ni enfant (par exemple ``) devient `null`.
  • Les préfixes d'espace de noms comme `xmlns` ne sont pas séparés — un élément reste identifié par la clé `ns:tag`, préfixe inclus.

Dans quels cas s'en servir

Pour brancher une interface XML sur du code qui ne comprend que le JSON

Lorsque la partie réceptrice ne traite que du JSON, vous pouvez arrêter à l'avance la forme convertie.

Pour analyser un flux RSS ou Atom

Les entrées d'un flux passées en JSON se parcourent bien plus aisément avec un script, telles quelles.

Pour lire le contenu d'une réponse SOAP

**Le SOAP, malaisé à lire par son imbrication et ses espaces de noms, se suit bien mieux une fois la hiérarchie déployée en JSON.**

Pour bâtir des jeux de test

Vous pouvez tirer un simulacre en JSON d'une réponse XML réelle.

Vocabulaire de la convention de conversion

@attributes
**La clé qui accueille les attributs d'un élément XML.** Le JSON ignorant la notion d'attribut, on leur ménage une clé propre.
#text
La clé qui accueille la chaîne qu'un élément porte directement. Elle devient nécessaire pour un élément ayant à la fois des attributs et des éléments enfants.
Élément répété
Un élément paraissant plus d'une fois sous le même nom. **Il devient un tableau en JSON, mais une occurrence isolée figure comme valeur simple et non comme tableau à un élément.**
Préfixe d'espace de noms
La partie `soap:` de `soap:Body`. En JSON, il subsiste intact au sein du nom de la clé.
Contenu mixte
Du texte et des éléments enfants cohabitant dans un même élément. **Le JSON n'a pas de structure correspondante, et c'est là que l'information se perd le plus volontiers à la conversion.**
Élément racine
L'unique élément au sommet du XML. Il devient la clé la plus extérieure du JSON.

Questions fréquentes

Les attributs de chaque élément sont regroupés sous une clé `@attributes` contenant un objet. Par exemple, `` devient `{"@attributes": {"category": "fiction"}, ...}`, séparé de la valeur propre de l'élément (son texte ou ses enfants) afin que les deux ne soient jamais confondus.

Quand des éléments frères sous le même parent partagent un nom, ils sont automatiquement regroupés en tableau. Par exemple, deux balises `` produisent une clé `book` dont la valeur est un tableau de 2 éléments ; une seule `` reste un simple objet.

La cause la plus fréquente est une balise fermante manquante ou incohérente (fermée avec un nom différent de celui d'ouverture). Le XML exige aussi exactement un élément racine, donc coller plusieurs éléments de premier niveau comme `......` échouera également.

Cet outil ne prend en charge que le sens XML vers JSON. Si vous devez formater ou valider du JSON ou du XML séparément, consultez les autres outils de formatage de ce site.

Les préfixes d'espace de noms sont conservés tels quels plutôt que séparés, donc un élément reste identifié par la clé `ns:tag`. La résolution de l'espace de noms (associer le préfixe à son URI) n'est pas effectuée, donc un XML avec des espaces de noms complexes peut ne pas donner la structure attendue.
Tool-kun

Anecdote — Pourquoi il n'existe pas une seule façon "correcte" de transformer du XML en JSON

Contrairement à la simple correspondance ligne-vers-objet entre CSV et JSON, il n'existe pas de convention universellement admise pour convertir entre XML et JSON. Le XML permet aux attributs, aux nœuds de texte et aux éléments enfants de coexister au sein d'un même élément, alors que JSON ne connaît que de simples paires clé-valeur — une convention doit donc être choisie au moment de la conversion. Des implémentations majeures comme xml2json, xml-js et org.json ont chacune adopté des règles différentes sur la manière de représenter les attributs et de traiter le texte qui coexiste avec des éléments enfants.

Les développeurs continuent malgré tout de rencontrer souvent du XML. Les API web basées sur SOAP, les intégrations de systèmes vieilles de plusieurs décennies dans la finance, l'administration et la santé, les flux RSS/Atom et les fichiers de mise en page Android ne sont que quelques-uns des domaines où le XML reste aujourd'hui le format standard. Le besoin persiste de récupérer des données issues de ces systèmes hérités et de les injecter dans une chaîne d'outils moderne qui ne comprend que le JSON — en les traitant avec jq ou en les manipulant comme un simple objet en JavaScript.

La convention `@attributes`/`#text` adoptée par cet outil est un choix pratique et courant, plutôt qu'une notation chargée de symboles. Les éléments feuilles sans attribut sont convertis directement en leur valeur textuelle, ce qui garde lisibles en JSON simple des valeurs de configuration basiques ou un titre RSS, tandis que les éléments porteurs d'attributs sont explicitement isolés — un simple coup d'œil au résultat converti suffit alors à savoir quelles valeurs étaient à l'origine des attributs.