JSON vers TOML

Cliquez pour convertir JSON en TOML

Convertisseur gratuit en ligne JSON vers TOML qui transforme automatiquement les objets JSON en configuration conforme à la spécification TOML v1.0. Il prend en charge les tables imbriquées ([section]), les sous-tables ([a.b]) et les tableaux de tables ([[items]]), et peut générer directement des fichiers Cargo.toml / pyproject.toml. Tout le traitement s'effectue localement.

Recommandations connexes

JSON vers YAML

Réparer JSON

Validateur JSON Schema

Trier JSON

Formatage JSON

JSON vers TypeScript

Qu'est-ce que TOML ? Pourquoi convertir JSON en TOML ?

TOML, abréviation de Tom's Obvious, Minimal Language, est un format de fichier de configuration publié en 2013 par Tom Preston-Werner, cofondateur de GitHub. Ses objectifs de conception sont : syntaxe évidente (obvious), minimaliste (minimal), facile à lire pour les humains, explicite et sans ambiguïté. TOML 1.0 est devenu une version stable en 2021 (toml-lang/toml) et est aujourd'hui le format de configuration par défaut de nombreux outils : Cargo de l'écosystème Rust, PEP 621 (pyproject.toml) pour Python, Hugo, Prettier, Deno, Taplo, etc.

TOML présente plusieurs avantages clairs sur JSON et YAML dans le contexte des fichiers de configuration : ① pas de piège d'indentation comme YAML — YAML utilise l'indentation pour exprimer la hiérarchie, et une erreur d'indentation peut totalement changer le sens de la configuration (par exemple une liste devenant une chaîne) ; TOML utilise des [table] explicites, sans ambiguïté ; ② plus adapté que JSON aux configurations — les guillemets et accolades de JSON deviennent vite verbeux dans des configurations complexes, alors que la syntaxe key = value de TOML est plus claire, avec support natif des commentaires ; ③ système de types explicite — TOML distingue integer/float/string/boolean/datetime/array/table, sans l'ambiguïté de JSON sur le statut entier/flottant d'un nombre, ni le problème « Norway » de YAML 1.1 (NO interprété comme booléen false).

La structure de TOML repose sur quatre éléments : ① les paires clé-valeur (key = value) pour les options de base ; ② les tables (Table), déclarées par [name], représentant des groupes nommés, avec support de l'imbrication ([a.b.c]) ; ③ les tableaux de tables (Array of Tables), déclarés par [[name]], pour des listes d'objets homogènes, souvent utilisés pour les configurations multi-environnements, listes de plugins, listes de dépendances ; ④ les tableaux (Array), avec deux écritures : en ligne pour les types primitifs ([1, 2, 3]) ou multi-lignes. Notre outil détecte intelligemment la structure JSON et choisit la syntaxe TOML la plus appropriée.

Les motivations courantes pour convertir JSON en TOML sont multiples : ① un projet migre de l'écosystème Node.js vers les écosystèmes Rust/Python et doit unifier le format de configuration sur TOML ; ② une équipe décide d'unifier la gestion de configurations JSON dispersées en TOML, pour profiter des [section] hiérarchiques et éviter la charge de lecture liée aux imbrications profondes JSON ; ③ remplacer YAML par TOML pour éliminer des bugs étranges dus à l'indentation ; ④ dans une chaîne CI/CD, convertir en TOML des métadonnées JSON fournies en amont pour les outils en aval. Cet outil couvre tous ces cas d'usage.

Le processus de conversion est essentiellement une transformation d'arbre syntaxique : JSON.parse() convertit le texte en objet JavaScript (AST), puis chaque nœud est parcouru récursivement — chaînes, nombres, booléens, null mappés vers les scalaires TOML correspondants ; les tableaux répartis en tableaux en ligne ou tableaux de tables selon le type d'éléments ; les objets imbriqués mappés vers des tables ou sous-tables. Le texte final est émis selon la spécification TOML. Cette transformation structurée garantit que le résultat est 100 % valide syntaxiquement, sans aucune erreur de format.

Cas d'utilisation

Préparer un Cargo.toml pour un projet Rust : convertir les configurations JSON de style package.json / tsconfig.json au format TOML adapté à la chaîne d'outils Cargo
Générer un pyproject.toml pour un projet Python : convertir les métadonnées JSON de style setup.py / setup.cfg au format pyproject.toml conforme à la PEP 621
Configuration Hugo / Deno / Prettier : migrer des configurations d'outils JSON vers le format TOML pour bénéficier de la structure de tables plus claire
Migration de chaîne d'outils DevOps : unifier le format lors du passage de configurations CI/CD de JSON à TOML, réduisant les coûts de maintenance pour l'équipe
Revue de format de fichiers de configuration : convertir rapidement une configuration JSON en TOML pour comparer les formats et choisir le plus adapté au projet
Apprentissage de la syntaxe TOML : quand on dispose d'une structure JSON existante et qu'on souhaite voir concrètement comment TOML représente les tables imbriquées et les tableaux de tables

Comment utiliser

Collez le contenu JSON dans l'éditeur de gauche, ou cliquez sur le bouton d'import pour sélectionner un fichier .json / .txt ; vous pouvez aussi cliquer sur « Exemple » pour charger un exemple complet imbriqué
L'outil analyse le JSON en temps réel et génère le code de configuration TOML conforme à la norme v1.0 à droite ; paires clé-valeur, tables imbriquées et tableaux de tables utilisent automatiquement la syntaxe correspondante
En cas d'erreur de syntaxe JSON, un message d'erreur rouge s'affiche ; vous pouvez cliquer pour accéder à l'outil de réparation JSON qui complète automatiquement les virgules finales et autres erreurs courantes
Une fois le résultat satisfaisant, cliquez sur « Copier » pour copier le contenu TOML, ou sur « Télécharger » pour l'enregistrer en fichier config.toml pour votre projet

Fonctionnalités

Sortie conforme à la spécification TOML v1.0 : les fichiers générés sont directement utilisables par Cargo, Poetry, Hugo, Prettier et tout outil supportant TOML
Mappage automatique des objets imbriqués : les JSON à plusieurs niveaux d'imbrication sont automatiquement convertis en tables TOML ([a]) et sous-tables ([a.b.c]), avec une hiérarchie claire et lisible
Reconnaissance intelligente des tableaux de tables : les tableaux d'objets (comme les listes de connexions à une base de données) sont automatiquement convertis en tableaux de tables TOML ([[items]]), conformément à la spécification officielle
Échappement sécurisé des chaînes : les guillemets doubles, barres obliques inverses, sauts de ligne, tabulations et autres caractères spéciaux sont automatiquement échappés selon les règles TOML, évitant les échecs d'analyse dus à des caractères invalides
Mappage automatique des types : les chaînes/nombres/booléens/null du JSON correspondent aux string/integer/float/boolean du TOML, les null étant convertis en chaîne vide
Édition bidirectionnelle en temps réel : collez le JSON à gauche et visualisez instantanément le résultat TOML à droite, conversion automatique sans clic
Exemple prêt à l'emploi : chargez en un clic un exemple complet contenant objets imbriqués, tableaux et tableaux de tables pour visualiser immédiatement le résultat TOML
Import et téléchargement de fichiers : prise en charge des fichiers .json/.txt en lecture, et téléchargement en un clic du résultat en fichier config.toml
Panneaux redimensionnables et historique : sur PC, la largeur des panneaux gauche/droite est ajustable par glissement, et les 200 dernières conversions sont sauvegardées pour retour rapide
Redirection vers le formatage JSON : après conversion, accédez en un clic à l'outil de formatage JSON pour embellir, valider ou minifier la source JSON
Traitement 100 % local en front-end : toute l'analyse et la conversion s'effectuent en JavaScript dans le navigateur, aucune donnée (mots de passe, chaînes de connexion) n'est envoyée

FAQ

Comment convertir du JSON en fichier de configuration TOML ?

Collez le contenu JSON dans le champ de saisie à gauche, l'outil analyse automatiquement l'objet JSON et le convertit au format de fichier de configuration selon la spécification TOML v1.0. Les paires clé-valeur deviennent key = value, les objets imbriqués deviennent des tables TOML ([section]) et sous-tables ([a.b]), et les tableaux sont automatiquement répartis en tableaux en ligne ou en tableaux de tables ([[items]]) selon leur contenu. Cliquez sur le bouton d'exemple pour charger un exemple imbriqué et visualiser le résultat, que vous pouvez télécharger directement en fichier config.toml pour votre projet.

Quels sont les usages appropriés de TOML, YAML et JSON ?

JSON convient à l'échange de données via API et au transfert front-end/back-end, étant le standard de fait des interfaces REST ; YAML convient aux structures de données complexes et configurations CI/CD (GitHub Actions, Ansible, Kubernetes), avec une grande lisibilité, support des commentaires et multi-documents ; TOML convient aux fichiers de configuration clairs (Rust/Cargo, Python pyproject, Hugo, Prettier), avec une syntaxe concise, peu d'ambiguïté et sans pièges d'indentation. Aucun des trois n'est strictement meilleur que les autres, l'important est d'adapter le format au contexte : TOML pour les fichiers de configuration, YAML pour les configurations CI/CD, JSON pour les données d'API.

Comment représenter un objet JSON imbriqué en TOML ?

TOML utilise des tables pour représenter les structures imbriquées. Une imbrication à un niveau comme {"database": {"host": "localhost"}} devient [database] host = "localhost" ; une imbrication à plusieurs niveaux comme {"server": {"ssl": {"enabled": true}}} devient [server.ssl] enabled = true. Cet outil identifie automatiquement le niveau d'imbrication et génère les en-têtes de table correspondants, sans ajustement manuel.

Comment convertir un tableau JSON en TOML ?

TOML distingue deux syntaxes de tableau : ① les tableaux de types primitifs (comme ["a", "b", 1, 2]) deviennent un tableau en ligne key = ["a", "b", 1, 2], entouré de crochets avec virgules comme séparateurs ; ② les tableaux d'objets (comme [{"name": "primary"}, {"name": "replica"}]) deviennent des tableaux de tables [[items]], chaque objet étant précédé d'un en-tête [[items]] avec ses champs placés en dessous. L'outil détecte automatiquement le type de tableau et choisit la syntaxe TOML la plus appropriée.

Le TOML généré est-il directement utilisable comme Cargo.toml ?

Oui. L'outil suit strictement la spécification officielle TOML v1.0 (github.com/toml-lang/toml), et la sortie est directement utilisable par Cargo (gestionnaire de paquets Rust), Poetry/pyproject (gestionnaire de paquets Python), Hugo (sites statiques), Prettier, Deno, Taplo et tout autre outil supportant TOML. À noter : si vous avez besoin des sections spécifiques [package] / [dependencies] de Cargo, ajoutez les champs requis selon la spécification Cargo (name, version, edition, tables de dépendances, etc.).

Que devient la valeur null en JSON ?

TOML n'a pas de type null, donc les valeurs null du JSON sont converties en chaîne vide "" (l'équivalent le plus courant). Si votre consommateur TOML a des exigences particulières pour les champs null (par exemple un champ optional dans [dependencies]), ajustez manuellement la ligne correspondante après conversion.

Comment sont traités les guillemets doubles et sauts de ligne dans les chaînes ?

Les chaînes TOML doivent être entourées de guillemets doubles ; les guillemets doubles internes, barres obliques inverses, sauts de ligne (\n), retours chariot (\r) et tabulations (\t) doivent être échappés selon les règles TOML. L'outil gère automatiquement ces échappements : par exemple, He said "Hello" en JSON devient He said \"Hello\" en TOML, et les sauts de ligne dans les chaînes multi-lignes deviennent \n. Aucun échappement manuel n'est nécessaire, la sortie est directement lisible par tout analyseur TOML.

Le TOML généré gère-t-il les types date/heure ?

L'outil accepte uniquement du texte JSON en entrée, or la norme JSON n'a pas de type date/heure natif (l'usage courant est une chaîne ISO 8601 comme "2026-01-01T00:00:00Z"). Le TOML converti conservera ces valeurs sous forme de chaîne (key = "2026-01-01T00:00:00Z"). Si vous avez besoin des types TOML natifs local datetime / offset datetime, remplacez manuellement la chaîne par un littéral de date TOML nu (comme 2026-01-01T00:00:00).

En traitement local dans le navigateur, les données de configuration sont-elles envoyées ?

Non. Toute l'analyse JSON, génération TOML et échappement des chaînes s'effectue dans le moteur JavaScript local de votre navigateur, sans aucun envoi vers un serveur ; l'outil fonctionne même sans connexion. Vous pouvez convertir en toute confiance des fichiers JSON contenant des mots de passe de base de données, clés d'API, adresses intranet ou autres données sensibles.

Dépannage

Erreur JSON « Unexpected token », comment résoudre ?

Il s'agit d'une erreur de syntaxe JSON. Causes courantes : ① virgule finale en trop (trailing comma), comme {"a":1,} ; ② chaînes entourées de guillemets simples, comme {'a':1} (JSON exige des guillemets doubles) ; ③ noms de clés sans guillemets, comme {a:1} ; ④ commentaires // ou /* */ (la norme JSON ne les supporte pas). Utilisez l'outil de réparation JSON du site pour corriger automatiquement ces erreurs courantes, puis recollez le résultat dans cet outil pour la conversion.

Erreur « invalid TOML » dans Cargo après conversion ?

Il s'agit généralement d'un conflit de noms de champs ou de champs obligatoires manquants. L'analyseur TOML est strict sur les chemins d'en-têtes de tables, noms de clés en doublon et échappement des caractères. Vérifiez : ① absence de noms de clés en doublon dans le même scope ; ② échappement correct des caractères spéciaux dans les chaînes (guillemets doubles, barres obliques inverses, sauts de ligne) ; ③ profondeur d'imbrication non excessive (TOML 1.0 recommande max 5 niveaux) ; ④ absence de sections Cargo obligatoires comme [package]. La syntaxe produite par cet outil est 100 % valide ; le problème vient généralement du consommateur (par exemple conformité des noms de champs à la spec Cargo).

Un tableau d'objets a été converti en tableau en ligne au lieu d'un tableau de tables ?

Un tableau JSON n'est converti en tableau en ligne ["a","b"] que si tous ses éléments sont des types primitifs (chaîne/nombre/booléen/null) ; les tableaux d'objets (comme [{"name":"x"}]) deviennent des tableaux de tables [[items]]. Si votre tableau d'objets est identifié par erreur comme un tableau en ligne, cela signifie qu'il contient des éléments non-objet. Vérifiez vos données : ① mélange de chaînes ou nombres dans le tableau ; ② rupture de la hiérarchie d'imbrication.

Certains noms de clés sont entourés de guillemets après conversion, comment les retirer ?

TOML impose que les noms de clés ne contiennent que lettres, chiffres, soulignés et tirets ([A-Za-z0-9_-]). Si une clé JSON contient des caractères spéciaux (espace, point, caractères non latins, emoji, mot réservé), l'outil l'entoure automatiquement de guillemets pour garantir la validité TOML, par exemple {"my key": 1} devient "my key" = 1. Si votre outil en aval n'accepte pas les clés avec guillemets, renommez manuellement la clé JSON avec des caractères valides (A-Z a-z 0-9 _ -) avant de reconvertir.

Ralentissements du navigateur lors de la conversion de gros fichiers ?

L'outil est optimisé pour la conversion en temps réel (conversion à chaque saisie), mais les très gros fichiers (>1 Mo, centaines de milliers de lignes) peuvent poser problème. Conseils : ① vérifier d'abord la validité JSON avec l'outil de formatage JSON ; ② convertir par lots (par exemple en découpant par clé de premier niveau) ; ③ s'assurer que le navigateur dispose de suffisamment de mémoire ; ④ pour les très gros fichiers de configuration (10 Mo+), privilégier des outils en ligne de commande comme taplo ou tomlq — cet outil est conçu pour les configurations quotidiennes (de quelques Ko à quelques centaines de Ko).

Glossaire

TOML: Tom's Obvious, Minimal Language : langage de format conçu pour les fichiers de configuration, à la syntaxe concise et sans ambiguïté ; format par défaut de Cargo (Rust), pyproject (Python) et Hugo.
Table: Groupe nommé déclaré par [name] en TOML, équivalent à un objet en JSON, supportant l'imbrication par points comme [server.ssl].
Array of Tables (tableau de tables): Liste d'objets homogènes déclarée par [[name]] en TOML, chaque section [[name]] contenant tous les champs d'un objet ; équivalent à un tableau d'objets en JSON.
Inline Table (table en ligne): Syntaxe supportée par TOML 1.0, déclarant un objet simple sur une seule ligne avec { key = value, key = value }, adaptée aux objets plats sans nom explicite.
Cargo.toml: Fichier de configuration standard d'un projet Rust, définissant les métadonnées package, dependencies, dev-dependencies, features, etc., au format TOML.
pyproject.toml: Fichier de configuration standard d'un projet Python (PEP 621), définissant build-system, métadonnées project, dependencies et configurations d'outils (black/pytest/mypy, etc.).
TOML v1.0: Version stable officiellement publiée en 2021 de TOML ; cet outil suit strictement cette spécification (github.com/toml-lang/toml/blob/main/toml.md).
Objet imbriqué JSON: Objet JSON contenant d'autres objets, correspondant à une Table TOML ([section]) ou une sous-table ([a.b.c]).
Échappement TOML: Les caractères spéciaux dans une chaîne TOML (guillemets doubles, barres obliques inverses, sauts de ligne, etc.) doivent être échappés par barre oblique inverse (\", \\, \n) ; l'outil gère cela automatiquement.
Fichier de configuration: Fichier de paramètres lu au démarrage d'une application, séparé du code pour faciliter les modifications. TOML est l'un des standards de fait pour les fichiers de configuration.

Table de correspondance des types JSON vers TOML

Cet outil convertit les types JSON en types TOML selon les règles suivantes :

Type JSON	Type TOML	Syntaxe TOML	Remarque
string	string	`key = "value"`	Les chaînes TOML doivent être entourées de guillemets doubles
integer	integer	`key = 8080`	Les entiers n'ont pas de point décimal
float	float	`key = 3.14`	Les flottants doivent avoir un point décimal
boolean	boolean	`key = true`	TOML n'accepte que true / false en minuscules
null	string (vide)	`key = ""`	TOML n'a pas de type null, conversion en chaîne vide
array[primitive]	array	`key = ["a", "b"]`	Les tableaux de types primitifs utilisent la notation en ligne entre crochets
array[object]	array of tables	`[[items]] key = value`	Les tableaux d'objets utilisent la syntaxe [[name]]
object	table	`[name] key = value`	Les objets sont déclarés par une table [name]

Table d'échappement des chaînes TOML

Caractères spéciaux qui doivent être échappés dans une chaîne TOML :

Caractère d'origine	Après échappement TOML	Nom	Exemple d'usage
`"`	`\"`	Guillemet double	Guillemet double imbriqué dans une chaîne
`\`	`\\`	Barre oblique inverse	Chemin Windows C:\Users
`saut de ligne`	`\n`	Newline	Compression de chaînes multi-lignes
`tabulation`	`\t`	Tab	Champs tabulés
`retour chariot`	`\r`	Carriage Return	Saut de ligne Windows CRLF
`\b`	`\b`	Backspace	Caractère de retour arrière
`\f`	`\f`	Form Feed	Saut de page
`U+0000`	`\u0000`	Unicode 0	Les caractères de contrôle doivent être échappés via \u

Exemples comparés de conversion JSON vers TOML

Sortie TOML correspondant à des entrées JSON de structures complexes :

Structure	Exemple
Entrée JSON	`{ "name": "app", "port": 8080 }`
Sortie TOML	`name = "app" port = 8080`
Entrée JSON	`{ "server": { "host": "0.0.0.0", "port": 443 } }`
Sortie TOML	`[server] host = "0.0.0.0" port = 443`
Entrée JSON	`{ "hosts": [{"ip":"10.0.0.1"},{"ip":"10.0.0.2"}] }`
Sortie TOML	`[[hosts]] ip = "10.0.0.1" [[hosts]] ip = "10.0.0.2"`

Privacy & Security

Toutes les opérations de cet outil — analyse JSON, génération TOML, échappement de chaînes, lecture de fichiers — s'exécutent localement en JavaScript dans votre navigateur. Le contenu JSON et la configuration TOML générée ne sont jamais envoyés sur un réseau, ni enregistrés ni analysés. Vous pouvez convertir en toute confiance des fichiers JSON contenant des mots de passe de bases de données, clés d'API, adresses intranet ou autres données sensibles. L'historique local est uniquement conservé dans le localStorage de votre propre navigateur ; il disparaît à la fermeture du navigateur ou en vidant le cache.

Authoritative References

toml-langSpécification officielle TOML v1.0
GitHubDépôt GitHub TOML
WikipédiaTOML — Wikipédia
Rust officielRéférence des champs Cargo.toml