TOML naar JSON

De Cargo.toml van Rust, de pyproject.toml van Python, de config.toml van Hugo: TOML is overal in de moderne configuratiewereld, terwijl veel tools nog altijd alleen JSON spreken. Plak je TOML hier en krijg netjes opgemaakte JSON terug: [tabel]-secties worden geneste objecten, [[arrays van tabellen]] worden arrays van objecten, en datums gaan ongewijzigd als strings mee. De parser dekt de dagelijkse kern van TOML; de echte beperkingen (meerregelige waarden, inline-tabellen, keys met punten) staan hieronder open en eerlijk op een rij.

Zo werkt de conversie

  1. 1

    Plak je TOML

    Zet de tekst in het invoerveld en klik op Converteren naar JSON. Commentaarregels die met # beginnen worden automatisch overgeslagen.

  2. 2

    Tabellen worden objecten

    Een `[server.database]`-header wordt een set geneste JSON-objecten, een niveau per naam met punt.

  3. 3

    Arrays van tabellen worden arrays

    `[[users]]`-blokken bouwen een JSON-array met een object per blok.

  4. 4

    Scalaire waarden houden hun type

    Strings tussen aanhalingstekens, gewone decimale gehele en kommagetallen en true/false worden native JSON-types; datums blijven strings, precies zoals geschreven.

  5. 5

    Kopieer de JSON

    Het resultaat is opgemaakt met een inspringing van 4 spaties, met de keys in hun oorspronkelijke volgorde, klaar om te kopiëren.

Zo worden de types omgezet

TOML-waarde JSON-waarde Voorbeeld
String (basic of literal) String "hello" → "hello"
Geheel getal (gewoon decimaal) Number 42 → 42
Float (gewoon decimaal) Number 3.14 → 3.14
Boolean Boolean true → true
Array (op een regel) Array [1, 2, 3] → [1, 2, 3]
Tabel met keys Object [server] + port = 8080 → "server": {"port": 8080}
Array van tabellen Array van objecten [[users]] + name = "alice" → "users": [{"name": "alice"}]
Datum/tijd String, zoals geschreven 2026-04-18T10:00:00Z → "2026-04-18T10:00:00Z"

De uitvoer wordt altijd opgemaakt met 4 spaties inspringing, dus arrays en objecten beslaan meerdere regels; de tabel hierboven toont de waarden op een regel voor de leesbaarheid. De volgorde van de keys blijft exact zoals in je TOML.

Uitgewerkt voorbeeld

title = "My App"

[server]
host = "localhost"
port = 8080

[[users]]
name = "alice"
admin = true

wordt:

{
    "title": "My App",
    "server": {
        "host": "localhost",
        "port": 8080
    },
    "users": [
        {
            "name": "alice",
            "admin": true
        }
    ]
}

Ondersteunde TOML en de echte beperkingen

Ondersteund: [tabel]-headers inclusief sectienamen met punten, [[arrays van tabellen]], key = value-paren op een regel, basic strings "..." met de escapes \n, \t en \", literal strings '...', gewone decimale gehele en kommagetallen, true/false, arrays op een regel (nesten mag), commentaarregels met #, en datums die als strings doorgegeven worden.

Niet ondersteund, en wat je in plaats daarvan doet:

  • Meerregelige strings (""" of ''') en meerregelige arrays stoppen de parser met een foutmelding. Zet de waarde eerst op een regel.
  • Inline-tabellen worden niet uitgevouwen: point = { x = 1, y = 2 } komt eruit als de string "{ x = 1, y = 2 }", niet als object. Herschrijf hem als eigen [point]-sectie. Dependency-regels in Cargo.toml, zoals serde = { version = "1.0" }, zijn het klassieke geval.
  • Keys met punten links van het isgelijkteken blijven een platte key: server.host = "a" levert de key "server.host" op, zonder nesting. Gebruik in plaats daarvan een [server]-header. [sectie.namen] met punten in headers nesten wel correct.
  • Commentaar achter een waarde wordt niet weggehaald: port = 8080 # main wordt de string "8080 # main". Houd commentaar op eigen regels.
  • Getalnotaties buiten gewone decimalen worden niet herkend: 1_000, 0xFF, 5e2, +99, inf en nan komen eruit als strings tussen aanhalingstekens. Schrijf 1000, 255, 500, 99.
  • \uXXXX-escapes in basic strings worden niet gedecodeerd. Plak in plaats daarvan het echte teken.

Voor een volledig TOML 1.0-document gebruik je een commandline-converter zoals toml2json, of laad je het bestand met Pythons tomllib en schrijf je van daaruit JSON weg.

Waar dit handig is

  • Snel een TOML-fragment inspecteren als JSON tijdens het debuggen.
  • Eenvoudige configuratiewaarden doorgeven aan linters, scripts of inventoritools die alleen JSON accepteren.
  • JSON-testfixtures genereren uit TOML-notities die makkelijker met de hand te schrijven zijn.
  • Kleine, platte configuratiebestanden migreren, wat veel config.toml-bestanden van Hugo zijn.

Opmerkingen over heen en terug

  • Commentaar overleeft nooit: JSON kent simpelweg geen commentaarsyntaxis.
  • Datums blijven strings; code verderop moet ze weer naar datumobjecten parsen.
  • Grote getallen: gehele getallen blijven 64-bits waarden in de JSON-tekst, maar JavaScript-consumers verliezen precisie boven 2^53. Let op timestamps in nanoseconden en numerieke ID’s.
  • De volgorde van keys blijft bij deze converter zoals geschreven; andere JSON-tools kunnen keys hersorteren wanneer ze het document opnieuw wegschrijven.

Omgekeerde richting

JSON → TOML is de lastige kant op, want JSON heeft structuren (diepe anonieme nesting, null) die TOML niet heeft of anders behandelt. De meeste heen-en-terugscenario’s vragen handmatig bijwerken aan de TOML-kant.

Veelgestelde vragen

Nee. JSON kent geen commentaarsyntaxis, dus regels die met # beginnen worden gewoon overgeslagen. Let op: commentaar achter een waarde wordt niet weggehaald, dus port = 8080 # main wordt de string “8080 # main”. Zet commentaar op eigen regels voordat je converteert.

Nee. Hij dekt de dagelijkse kern: tabellen met sectienamen met punten, arrays van tabellen, key = value-paren op een regel, strings tussen aanhalingstekens, gewone decimale getallen, booleans, arrays op een regel en commentaarregels. Meerregelige strings en arrays, inline-tabellen, keys met punten en getalnotaties zoals 1_000 of 0xFF worden niet ondersteund. Gebruik voor documenten volgens de volledige specificatie een CLI-tool zoals toml2json of Pythons tomllib.

Gangbare configuratiebestanden converteren direct. De conversie draait op onze server, dus enorme documenten worden begrensd door de maximale requestgrootte; voor TOML van meerdere megabytes past een commandline-converter beter.

Ja, deze converter werkt op de server: de TOML gaat via HTTPS naar onze server, wordt daar geconverteerd en komt in hetzelfde antwoord terug. De inhoud wordt daarna niet bewaard; alleen een anonieme gebruiksteller blijft over. Plak geen geheimen zoals wachtwoorden of API-keys.

Gerelateerde tools

Tool beschikbaar in andere talen