Skip to content

Convertisseur TOML vers JSON

Collez du TOML, obtenez du JSON instantanément dans le navigateur. Cargo.toml, pyproject.toml, config.toml pris en charge. Dates et tables gérées. 100% privé.

Sans pistage Fonctionne dans le navigateur Gratuit
Options · 2 espaces
Indentation
0 caractères
JSON Sortie
0 lignes
Vérifié pour la conformité à la spécification TOML 1.0.0, la fidélité des date-heures et la gestion sûre des grands entiers — Équipe d'ingénierie Go Tools · 2 juil. 2026

Qu'est-ce que le TOML et pourquoi le convertir en JSON ?

TOML (Tom's Obvious, Minimal Language) est un format de fichier de configuration créé par Tom Preston-Werner pour être sans ambiguïté, facile à lire par des humains et trivialement associable à une table de hachage. Il est devenu le format de configuration par défaut de l'écosystème Rust (Cargo.toml), de l'empaquetage Python moderne (pyproject.toml, normalisé dans les PEP 518 et PEP 621) et d'outils comme Hugo, Netlify, Poetry et Foundry. JSON, en revanche, est le format d'échange machine universel — chaque langage l'analyse, chaque API le parle. Convertir le TOML en JSON est donc une tâche courante : vous rédigez la configuration en TOML lisible, puis la convertissez en JSON pour alimenter un programme, l'inspecter avec des outils JSON ou la comparer dans un pipeline.

Cet outil possède plusieurs différenciateurs qui comptent pour l'exactitude :

**1. Fidélité des date-heures.** TOML possède des types date et heure de première classe — date-heure avec décalage, date-heure locale, date locale et heure locale — que JSON n'a pas du tout. Les convertisseurs naïfs les aplatissent tous en horodatages ISO, si bien qu'une date locale comme 1979-05-27 devient 1979-05-27T00:00:00Z, inventant silencieusement une heure et un fuseau horaire. Cet outil préserve le type TOML exact : les dates locales restent des dates calendaires, les heures locales restent des heures, et seules les date-heures avec décalage portent un fuseau horaire. Vos données restent honnêtes et les allers-retours sans perte.

**2. Prise en charge complète de TOML 1.0.0.** Les tables imbriquées, les clés pointées, les tables en ligne et les tableaux de tables ([[section]]) sont tous analysés correctement selon la spécification TOML 1.0.0 à l'aide de la bibliothèque smol-toml sans dépendance. Les vrais fichiers Cargo.toml et pyproject.toml avec des tables mixtes en ligne et standard se convertissent exactement comme la spécification l'exige.

**3. Gestion honnête des grands entiers.** Les entiers TOML sont sur 64 bits, mais le JavaScript en navigateur ne peut contenir exactement que les entiers jusqu'à 2^53 - 1. Plutôt que de corrompre silencieusement une grande valeur ou de planter, cet outil convertit au nombre JSON le plus proche et vous avertit, afin que vous puissiez choisir de stocker la valeur sous forme de chaîne à la place. Cette honnêteté sur une limite fondamentale du navigateur est quelque chose que la plupart des convertisseurs passent sous silence.

**4. Confidentialité 100% dans le navigateur.** Votre TOML — qui peut contenir des jetons de registre, des sources de paquets internes ou des secrets de déploiement — ne quitte jamais votre navigateur. Aucun téléversement, aucun serveur, aucune journalisation. Vous pouvez le confirmer dans l'onglet Réseau de votre navigateur.

Besoin du sens inverse ? Utilisez le convertisseur JSON vers TOML. Vous convertissez entre d'autres formats de configuration ? Essayez le convertisseur JSON vers YAML et le convertisseur YAML vers JSON, ou validez et mettez en forme votre sortie JSON d'abord avec le formateur JSON. TOML, JSON et YAML ont chacun leur place : TOML pour la configuration d'application éditée par des humains, JSON pour l'échange machine, et YAML pour les manifestes d'infrastructure profondément imbriqués. Ce convertisseur vous permet de passer des deux premiers sans une seule ligne de code.

// Convert TOML to JSON in Node.js using the smol-toml library
import { parse } from 'smol-toml';

const toml = `
[package]
name = "my-app"
version = "1.0.0"

[dependencies]
serde = { version = "1.0", features = ["derive"] }
`;

const data = parse(toml);
const json = JSON.stringify(data, null, 2);

console.log(json);
// {
//   "package": { "name": "my-app", "version": "1.0.0" },
//   "dependencies": {
//     "serde": { "version": "1.0", "features": ["derive"] }
//   }
// }

Fonctionnalités clés

Conversion en direct

La sortie JSON se met à jour instantanément au fur et à mesure que vous saisissez ou collez du TOML — aucun bouton Convertir nécessaire. Les grandes entrées (>200 Ko) basculent automatiquement en mode manuel pour garder le navigateur réactif.

Fidélité des date-heures

Les date-heures avec décalage, date-heures locales, dates locales et heures locales de TOML sont converties en chaînes JSON qui préservent le type d'origine — pas d'horodatage minuit inventé, les allers-retours restent donc sans perte.

Prise en charge complète de TOML 1.0.0

Les tables imbriquées, les clés pointées, les tables en ligne et les tableaux de tables ([[section]]) sont tous analysés correctement via le moteur smol-toml sans dépendance, conforme à la spécification TOML 1.0.0.

Prêt pour Cargo.toml et pyproject.toml

Optimisé pour les fichiers TOML les plus courants dans la pratique — manifestes Rust et configurations d'empaquetage Python — y compris les tables en ligne et les tableaux de tables. Chargez un exemple pour voir la structure JSON exacte.

Avertissements honnêtes sur les grands entiers

Les entiers au-delà de la plage sûre de JavaScript (2^53) ne peuvent pas être représentés exactement en JSON — l'outil les convertit au nombre le plus proche et vous avertit, au lieu de corrompre silencieusement la valeur.

Confidentialité 100% dans le navigateur

Toute l'analyse s'exécute localement dans votre navigateur. Votre TOML — y compris les jetons de registre, les sources de paquets privées et les secrets de déploiement — n'est jamais téléversé, stocké ni journalisé.

Exemples

Cargo.toml (Rust)

[package]
name = "my-app"
version = "1.0.0"
edition = "2021"
authors = ["Jane Doe <jane@example.com>"]

[dependencies]
serde = { version = "1.0", features = ["derive"] }
tokio = { version = "1", features = ["full"] }

[dev-dependencies]
criterion = "0.5"

[[bin]]
name = "my-app"
path = "src/main.rs"

Convertissez un manifeste Cargo.toml de Rust en JSON — utile pour l'outillage, les tableaux de bord de dépendances ou pour alimenter les métadonnées de cargo dans des scripts qui attendent du JSON.

pyproject.toml (Python)

[build-system]
requires = ["hatchling"]
build-backend = "hatchling.build"

[project]
name = "my-package"
version = "0.3.1"
requires-python = ">=3.10"
dependencies = [
  "requests>=2.31",
  "pydantic>=2.0"
]

[project.optional-dependencies]
dev = ["pytest>=8.0", "ruff>=0.4"]

[tool.ruff]
line-length = 100

Convertissez un pyproject.toml PEP 621 en JSON pour inspecter les métadonnées du projet, les dépendances et la configuration des outils de façon programmatique.

netlify.toml

[build]
command = "npm run build"
publish = "dist"

[build.environment]
NODE_VERSION = "20"

[[redirects]]
from = "/old-path"
to = "/new-path"
status = 301
force = true

[[headers]]
for = "/*"

[headers.values]
X-Frame-Options = "DENY"

Convertissez une configuration de build Netlify en JSON pour auditer les redirections et les en-têtes, ou pour générer la configuration équivalente sur une autre plateforme.

config.toml de Hugo

baseURL = "https://example.org"
languageCode = "en-us"
title = "My Hugo Site"
theme = "ananke"

[params]
description = "A static site built with Hugo"
mainSections = ["posts", "docs"]

[[menu.main]]
name = "Blog"
url = "/posts/"
weight = 1

[[menu.main]]
name = "About"
url = "/about/"
weight = 2

Convertissez un config.toml de site Hugo en JSON pour migrer des réglages, comparer une configuration ou piloter une interface de configuration.

rustfmt.toml

edition = "2021"
max_width = 100
hard_tabs = false
tab_spaces = 4
newline_style = "Unix"
use_small_heuristics = "Default"
reorder_imports = true
reorder_modules = true

Convertissez un rustfmt.toml plat en JSON — un bon exemple de la façon dont les paires clé-valeur de premier niveau (sans tables) sont directement associées à un objet JSON.

Config d'application avec dates et tableaux de tables

title = "Deployment Log"
last_deployed = 1979-05-27T07:32:00Z
release_date = 1979-05-27
maintenance_window = 02:00:00

[[servers]]
name = "alpha"
ip = "10.0.0.1"
ports = [8001, 8002]

[[servers]]
name = "beta"
ip = "10.0.0.2"
ports = [9001]

Illustre comment les types date-heure natifs de TOML (date-heure avec décalage, date locale, heure locale) et les tableaux de tables se convertissent proprement en chaînes et tableaux JSON.

Comment l'utiliser

  1. 1

    Collez votre TOML

    Saisissez ou collez votre TOML dans le champ de saisie ci-dessus. Vous pouvez aussi cliquer sur « Charger un exemple » pour essayer un vrai Cargo.toml, pyproject.toml ou une config de déploiement.

  2. 2

    Voyez la sortie JSON en direct

    Le JSON apparaît instantanément dans le panneau de sortie. Ajustez l'option Indentation (2 ou 4 espaces) pour correspondre à votre format cible. Les dates, tables et tableaux de tables sont gérés automatiquement.

  3. 3

    Copiez ou téléchargez

    Cliquez sur Copier pour placer le JSON dans votre presse-papiers, ou sur Télécharger pour l'enregistrer en fichier .json prêt pour votre programme, votre API ou votre outillage.

Pièges TOML courants

Valeurs de chaîne sans guillemets

En TOML, les valeurs de chaîne doivent être entre guillemets. Un mot nu à droite d'un signe égal n'est valide que pour les booléens (true/false), les nombres, les dates, ou dans un tableau. Mettez vos chaînes entre guillemets doubles ou simples.

✗ Incorrect
name = my-app
✓ Correct
name = "my-app"

Clés en double

TOML interdit de définir deux fois la même clé au sein d'une même table, et interdit de redéfinir une table déjà définie. C'est une erreur fréquente lors de la fusion de fragments de configuration. Chaque clé et chaque table doit être unique.

✗ Incorrect
name = "a"
name = "b"
✓ Correct
name = "a"
alt_name = "b"

Format de date-heure invalide

Les date-heures TOML suivent la RFC 3339. Une date nécessite une année complète à 4 chiffres, un mois à 2 chiffres et un jour à 2 chiffres ; une date-heure nécessite un séparateur T (ou espace). Les dates mal formées échouent à l'analyse.

✗ Incorrect
released = 2026-7-2
✓ Correct
released = 2026-07-02

Crochet fermant manquant

Les tableaux, les tables en ligne et les en-têtes de table doivent être fermés. Un [ ou un { non fermé produit une erreur d'analyse pointant la ligne et la colonne où le problème a été détecté.

✗ Incorrect
ports = [8001, 8002
✓ Correct
ports = [8001, 8002]

Entier au-delà de la plage sûre

Les entiers TOML sont sur 64 bits, mais les nombres JSON dans le navigateur sont limités à 2^53 - 1. Les valeurs au-delà sont arrondies lors de la conversion et un avertissement s'affiche. Stockez les très grands entiers sous forme de chaînes entre guillemets pour les garder exacts.

✗ Incorrect
snowflake = 1420070400000000000
✓ Correct
snowflake = "1420070400000000000"

Redéfinir une table

Une fois qu'une table comme [servers] est définie, vous ne pouvez pas la rouvrir avec le même en-tête. Pour avoir plusieurs entrées, utilisez plutôt un tableau de tables ([[servers]]), qui devient un tableau JSON d'objets.

✗ Incorrect
[servers]
name = "a"
[servers]
name = "b"
✓ Correct
[[servers]]
name = "a"
[[servers]]
name = "b"

Cas d'usage courants

Métadonnées Cargo de Rust
Convertissez Cargo.toml en JSON pour construire des tableaux de bord de dépendances, auditer les versions et fonctionnalités des crates, ou alimenter les données de manifeste dans des scripts et de la CI qui attendent du JSON plutôt que du TOML.
Configuration de projet Python
Convertissez pyproject.toml en JSON pour inspecter les métadonnées de projet PEP 621, extraire les listes de dépendances, ou piloter un outillage qui lit la configuration d'empaquetage de façon programmatique.
Inspection de config de déploiement
Convertissez netlify.toml, foundry.toml ou d'autres configurations de plateforme en JSON pour auditer les redirections, les en-têtes et les réglages de build, ou pour générer une configuration équivalente sur une autre plateforme.
Migration de format de configuration
Convertissez une configuration d'application TOML en JSON lors du passage à un système qui préfère le JSON, ou comme étape intermédiaire avant une transformation plus poussée avec des outils JSON comme jq.
Réglages de site statique
Convertissez le config.toml de Hugo en JSON pour migrer les réglages du site, comparer la configuration entre environnements, ou construire une interface de réglages adossée à du JSON.
Entrée d'API et de scripts
Transformez du TOML rédigé par des humains en JSON qu'une API REST, une fonction serverless ou un script d'automatisation peut consommer directement, reliant configuration lisible et entrée machine.

Détails techniques

Analyse TOML 1.0.0 via smol-toml
Le TOML est analysé avec la bibliothèque smol-toml, un analyseur sans dépendance et entièrement conforme à TOML 1.0.0. Il gère correctement les tables imbriquées, les clés pointées, les tables en ligne, les tableaux de tables, les chaînes multi-lignes et les quatre types de date-heure, et il signale les erreurs d'analyse avec des positions de ligne et de colonne.
Date-heures sans perte et gestion sûre des entiers
Les date-heures TOML sont sérialisées en chaînes JSON qui préservent leur type exact (date-heure avec décalage, date-heure locale, date locale, heure locale). Les entiers au-delà de la plage sûre de JavaScript (2^53 - 1) sont promus en BigInt lors de l'analyse, puis convertis au nombre JSON le plus proche avec un avertissement de précision, si bien qu'un TOML valide n'échoue jamais à la conversion.
100% dans le navigateur — aucun téléversement, aucun serveur
Tout le traitement se déroule dans le moteur JavaScript de votre navigateur. Aucune donnée n'est transmise à aucun moment. Les entrées de plus de 200 Ko passent du mode direct au mode manuel (un clic explicite sur Convertir) pour garder l'interface réactive.

Bonnes pratiques

Stockez les très grands entiers sous forme de chaînes
Si votre TOML comporte des entiers au-delà de 2^53 - 1 (identifiants Snowflake, horodatages à la nanoseconde, grands compteurs), mettez-les entre guillemets comme chaînes avant la conversion. Les nombres JSON dans le navigateur ne peuvent pas les contenir exactement, et l'outil vous avertira lorsqu'il devra arrondir.
Préférez l'indentation à 2 espaces pour la sortie JSON
L'indentation à deux espaces est la convention la plus répandue pour le JSON et produit une sortie propre et lisible qui s'accorde bien avec la plupart des formateurs et outils de comparaison. Réservez l'indentation à 4 espaces aux cas où un guide de style l'exige.
Validez la sortie JSON avant de l'utiliser
Après la conversion, si vous prévoyez de modifier le JSON à la main ou de l'alimenter dans un système strict, passez-le dans notre formateur JSON pour confirmer qu'il est valide et formaté de façon cohérente.
Conservez les commentaires TOML à part
JSON n'a pas de syntaxe de commentaire, les commentaires # de TOML sont donc supprimés à la conversion. Si les commentaires constituent une documentation importante, gardez le TOML d'origine dans le gestionnaire de versions à côté du JSON généré.
Utilisez des tableaux de tables pour les sections répétées
Lorsque vous avez plusieurs sections similaires (serveurs, redirections, binaires), écrivez-les comme des tableaux de tables ([[section]]) plutôt que de répéter [section]. Elles se convertissent en un tableau JSON d'objets propre au lieu de provoquer une erreur de table en double.

Questions fréquentes

Comment convertir du TOML en JSON en ligne ?
Collez votre TOML dans le champ de saisie ci-dessus. L'outil l'analyse et produit du JSON instantanément dans votre navigateur — aucun clic sur un bouton n'est nécessaire. Vous pouvez basculer l'indentation du JSON entre 2 et 4 espaces dans le panneau Options. Une fois le JSON affiché dans la zone de sortie, cliquez sur Copier pour le placer dans votre presse-papiers ou sur Télécharger pour l'enregistrer en fichier .json. Tout s'exécute localement, votre TOML ne quitte donc jamais votre appareil.
Qu'est-ce que le TOML et pourquoi le convertir en JSON ?
TOML (Tom's Obvious, Minimal Language) est un format de fichier de configuration conçu pour être facile à lire et à écrire par des humains, avec une sémantique claire qui correspond sans ambiguïté à une table de hachage. Il alimente le Cargo.toml de Rust, le pyproject.toml de Python, Hugo, Netlify et bien d'autres outils. On convertit le TOML en JSON lorsqu'il faut fournir une configuration à un programme ou une API qui attend du JSON, inspecter un fichier de configuration de façon programmatique, comparer deux configurations avec des outils JSON ou piloter une interface. Le TOML est écrit par des humains ; le JSON est consommé par des machines — ce convertisseur relie les deux.
Comment les dates et heures TOML sont-elles représentées en JSON ?
JSON ne possède pas de type date natif, les date-heures TOML sont donc converties en chaînes. Cet outil préserve le type exact de la date TOML : une date-heure avec décalage comme 1979-05-27T07:32:00Z devient "1979-05-27T07:32:00.000Z", une date locale comme 1979-05-27 reste "1979-05-27" (elle n'est pas complétée en horodatage complet), et une heure locale comme 07:32:00 devient "07:32:00.000". De nombreux convertisseurs aplatissent à tort les dates locales en horodatages UTC à minuit — celui-ci conserve le sens d'origine, pour des allers-retours sans perte.
Cet outil gère-t-il Cargo.toml et pyproject.toml ?
Oui. Cargo.toml et pyproject.toml sont les deux fichiers TOML les plus courants dans la pratique, et tous deux sont entièrement pris en charge, y compris les tables imbriquées ([dependencies], [tool.ruff]), les tables en ligne (serde = { version = "1.0", features = ["derive"] }) et les tableaux de tables ([[bin]]). Chargez l'exemple Cargo.toml ou pyproject.toml ci-dessus pour voir la structure JSON exacte produite. C'est pratique pour les tableaux de bord de build, les audits de dépendances ou tout script qui lit les métadonnées de projet sous forme JSON.
Comment les tables et les tableaux de tables TOML sont-ils convertis ?
Un en-tête de table TOML comme [owner] devient un objet JSON imbriqué sous la clé "owner". Une table pointée comme [tool.ruff] devient des objets imbriqués : { "tool": { "ruff": { ... } } }. Un tableau de tables écrit avec des doubles crochets — [[servers]] répété — devient un tableau JSON d'objets : { "servers": [ { ... }, { ... } ] }. Les tables en ligne ({ a = 1, b = 2 }) deviennent de simples objets JSON. La conversion suit exactement la spécification TOML 1.0.0.
Qu'advient-il des très grands entiers lors de la conversion de TOML en JSON ?
TOML prend en charge les entiers signés 64 bits, mais JavaScript (et donc le JSON dans le navigateur) ne peut représenter exactement que les entiers jusqu'à 2^53 - 1 (9007199254740991). Si votre TOML contient un entier plus grand — par exemple un identifiant Snowflake ou un horodatage à la nanoseconde — il ne peut pas être représenté sans perte comme nombre JSON, et la valeur est arrondie, avec un avertissement affiché. C'est une limite fondamentale du JavaScript en navigateur qui touche tous les convertisseurs basés sur le navigateur. Pour une préservation exacte, gardez ces valeurs sous forme de chaînes entre guillemets dans votre TOML.
Mes données TOML sont-elles envoyées à un serveur ?
Non. Toute l'analyse et la conversion se déroulent entièrement dans votre navigateur à l'aide de JavaScript. Votre TOML n'est jamais téléversé, jamais stocké et jamais journalisé. Cela rend l'outil sûr pour des fichiers Cargo.toml contenant des jetons de registre privé, des pyproject.toml avec des index de paquets internes, des configurations de déploiement avec des secrets, et toute autre configuration sensible. Vous pouvez le vérifier en ouvrant l'onglet Réseau de votre navigateur — coller du TOML ne déclenche aucune requête réseau.
Puis-je reconvertir du JSON en TOML ?
Oui. Utilisez le convertisseur JSON vers TOML associé pour le sens inverse, ou cliquez sur le bouton Inverser le sens en haut de cet outil pour permuter l'entrée et la sortie sur place. Notez que la conversion JSON vers TOML comporte quelques contraintes que TOML vers JSON n'a pas — le niveau supérieur doit être un objet, et les valeurs null n'ont pas d'équivalent TOML — que l'outil JSON vers TOML explique et gère pour vous.
Comment convertir du TOML en JSON en ligne de commande ?
Une option populaire est la CLI Rust « toml » ou l'outil Go « yj » (yj -tj lit du TOML et écrit du JSON). Avec Python 3.11+, vous pouvez exécuter : python3 -c "import tomllib, json, sys; print(json.dumps(tomllib.load(sys.stdin.buffer)))" < config.toml. Avec Node.js : npx smol-toml (ou un petit script utilisant la bibliothèque smol-toml). Pour un usage ponctuel rapide dans le navigateur sans rien installer, cet outil est le chemin le plus court.
Comment convertir du TOML en JSON en Python, Rust ou Node.js ?
En Python 3.11+ : import tomllib, json; data = tomllib.load(open('config.toml','rb')); json.dump(data, open('config.json','w')). En Rust : utilisez les crates toml et serde_json — let value: toml::Value = toml::from_str(&text)?; let json = serde_json::to_string_pretty(&value)?. En Node.js : import { parse } from 'smol-toml'; const data = parse(text); const json = JSON.stringify(data, null, 2) — c'est la même bibliothèque et la même approche que celles utilisées par cet outil.
Le convertisseur préserve-t-il l'ordre des clés, et qu'en est-il des commentaires ?
L'ordre des clés au sein d'une table est préservé : les clés apparaissent dans la sortie JSON dans le même ordre que dans votre TOML. Les commentaires, en revanche, sont supprimés — JSON n'a pas de syntaxe de commentaire, les commentaires # de TOML ne peuvent donc pas survivre à la conversion. Si vous devez conserver de la documentation, ajoutez-la dans un champ compatible JSON ou gardez le TOML d'origine à côté du JSON généré.
Y a-t-il une limite de taille de fichier pour l'entrée TOML ?
Il n'y a pas de limite stricte, mais les entrées de plus de 200 Ko passent de la conversion en direct au mode manuel : un bouton Convertir apparaît et la conversion ne s'exécute que lorsque vous cliquez, ce qui garde le navigateur réactif. Les fichiers de configuration typiques — même de grands espaces de travail Cargo.toml ou des configurations de déploiement multi-environnements — se convertissent en bien moins de 50 millisecondes.