Skip to content

TOML naar JSON Converter

Plak TOML, krijg direct JSON in je browser. Klaar voor Cargo.toml, pyproject.toml en config.toml. Datums en geneste tabellen correct. 100% privé.

Geen tracking Draait in je browser Gratis
Opties · 2 spaties
Inspringing
0 tekens
JSON Uitvoer
0 regels
Beoordeeld op TOML 1.0.0-specificatieconformiteit, datumtijdgetrouwheid en veilige verwerking van grote gehele getallen — Go Tools Engineering Team · Jul 2, 2026

Wat is TOML en waarom omzetten naar JSON?

TOML (Tom's Obvious, Minimal Language) is een configuratiebestandsformaat gemaakt door Tom Preston-Werner om ondubbelzinnig te zijn, gemakkelijk leesbaar voor mensen en triviaal op een hashtabel te mappen. Het is het standaard configuratieformaat geworden voor het Rust-ecosysteem (Cargo.toml), moderne Python-packaging (pyproject.toml, gestandaardiseerd in PEP 518 en PEP 621) en tools zoals Hugo, Netlify, Poetry en Foundry. JSON daarentegen is het universele machine-uitwisselingsformaat — elke taal parseert het, elke API spreekt het. TOML naar JSON omzetten is daarom een veelvoorkomende taak: je schrijft configuratie in leesbare TOML en zet die vervolgens om naar JSON om een programma te voeden, het met JSON-tooling te inspecteren of het in een pijplijn te vergelijken.

Deze tool heeft verschillende onderscheidende eigenschappen die van belang zijn voor correctheid:

**1. Datumtijdgetrouwheid.** TOML heeft eersteklas datum- en tijdtypen — offset date-time, lokale date-time, lokale datum en lokale tijd — die JSON volledig mist. Naïeve converters platten ze allemaal af tot ISO-tijdstempels, zodat een lokale datum zoals 1979-05-27 wordt 1979-05-27T00:00:00Z, wat stilletjes een tijd en tijdzone verzint. Deze tool behoudt de exacte TOML-soort: lokale datums blijven kalenderdatums, lokale tijden blijven tijden, en alleen offset date-times dragen een tijdzone. Dat houdt je gegevens eerlijk en rondritten verliesvrij.

**2. Volledige TOML 1.0.0-ondersteuning.** Geneste tabellen, sleutels met puntnotatie, inline-tabellen en arrays van tabellen ([[section]]) worden allemaal correct geparseerd volgens de TOML 1.0.0-specificatie met de dependency-vrije smol-toml-bibliotheek. Echte Cargo.toml- en pyproject.toml-bestanden met gemengde inline- en standaardtabellen converteren precies zoals de specificatie vereist.

**3. Eerlijke verwerking van grote gehele getallen.** TOML-gehele getallen zijn 64-bits, maar browser-JavaScript kan gehele getallen alleen exact bevatten tot 2^53 - 1. In plaats van een grote waarde stilletjes te corrumperen of vast te lopen, converteert deze tool naar het dichtstbijzijnde JSON-getal en waarschuwt je, zodat je ervoor kunt kiezen de waarde in plaats daarvan als string op te slaan. Deze eerlijkheid over een fundamentele browserbeperking is iets waar de meeste converters overheen stappen.

**4. 100% browsergebaseerde privacy.** Je TOML — die registry-tokens, interne pakketbronnen of deployment-geheimen kan bevatten — verlaat nooit je browser. Geen upload, geen server, geen logging. Je kunt dit bevestigen in het tabblad Netwerk van je browser.

Heb je de omgekeerde richting nodig? Gebruik de JSON naar TOML Converter. Converteer je tussen andere configuratieformaten? Probeer de JSON naar YAML Converter en YAML naar JSON Converter, of valideer en pretty-print je JSON-uitvoer eerst met de JSON Formatter. TOML, JSON en YAML hebben elk hun plaats: TOML voor door mensen bewerkte applicatieconfiguratie, JSON voor machine-uitwisseling en YAML voor diep geneste infrastructuurmanifesten. Deze converter laat je zonder ook maar één regel code tussen de eerste twee bewegen.

// 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"] }
//   }
// }

Belangrijkste functies

Live conversie

De JSON-uitvoer wordt direct bijgewerkt terwijl je TOML typt of plakt — geen knop Converteren nodig. Grote invoer (>200 KB) schakelt automatisch over naar handmatige modus om de browser responsief te houden.

Datumtijdgetrouwheid

TOML offset date-times, lokale date-times, lokale datums en lokale tijden worden omgezet naar JSON-strings die de oorspronkelijke soort behouden — geen verzonnen middernacht-tijdstempels, zodat rondritten verliesvrij blijven.

Volledige TOML 1.0.0-ondersteuning

Geneste tabellen, sleutels met puntnotatie, inline-tabellen en arrays van tabellen ([[section]]) worden allemaal correct geparseerd via de dependency-vrije smol-toml-engine, conform de TOML 1.0.0-specificatie.

Klaar voor Cargo.toml en pyproject.toml

Geoptimaliseerd voor de meest voorkomende TOML-bestanden uit de praktijk — Rust-manifesten en Python-packaging-configuraties — inclusief inline-tabellen en arrays van tabellen. Laad een voorbeeld om de exacte JSON-structuur te zien.

Eerlijke waarschuwingen bij grote gehele getallen

Gehele getallen buiten het veilige bereik van JavaScript (2^53) kunnen niet exact in JSON worden weergegeven — de tool zet ze om naar het dichtstbijzijnde getal en waarschuwt je, in plaats van de waarde stilletjes te corrumperen.

100% browsergebaseerde privacy

Al het parseren draait lokaal in je browser. Je TOML — inclusief registry-tokens, privé pakketbronnen en deployment-geheimen — wordt nooit geüpload, opgeslagen of gelogd.

Voorbeelden

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"

Zet een Rust Cargo.toml-manifest om naar JSON — handig voor tooling, dependency-dashboards of om cargo-metadata te voeden aan scripts die JSON verwachten.

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

Zet een PEP 621 pyproject.toml om naar JSON om projectmetadata, dependencies en toolconfiguratie programmatisch te inspecteren.

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"

Zet een Netlify-buildconfiguratie om naar JSON om redirects en headers te controleren of de gelijkwaardige configuratie voor een ander platform te genereren.

Hugo config.toml

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

Zet een Hugo config.toml om naar JSON om instellingen te migreren, configuratie te vergelijken of een configuratie-UI aan te sturen.

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

Zet een platte rustfmt.toml om naar JSON — een goed voorbeeld van hoe sleutel-waardeparen op het hoogste niveau (zonder tabellen) rechtstreeks op een JSON-object worden gemapt.

App-config met datums en arrays van tabellen

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]

Laat zien hoe native TOML-datumtijden (offset date-time, lokale datum, lokale tijd) en arrays van tabellen netjes worden omgezet naar JSON-strings en arrays.

Hoe te gebruiken

  1. 1

    Plak je TOML

    Voer je TOML in of plak het in het invoerveld hierboven. Je kunt ook op 'Voorbeeld laden' klikken om een echte Cargo.toml, pyproject.toml of deployment-config te proberen.

  2. 2

    Bekijk live JSON-uitvoer

    JSON verschijnt direct in het uitvoerpaneel. Pas de optie Inspringing aan (2 of 4 spaties) om overeen te komen met je doelformaat. Datums, tabellen en arrays van tabellen worden automatisch verwerkt.

  3. 3

    Kopiëren of downloaden

    Klik op Kopiëren om de JSON naar je klembord te halen, of op Downloaden om het als .json-bestand op te slaan, klaar voor je programma, API of tooling.

Veelvoorkomende TOML-valkuilen

String-waarden zonder aanhalingstekens

In TOML moeten string-waarden tussen aanhalingstekens staan. Een kaal woord rechts van een isgelijkteken is alleen geldig voor booleans (true/false), getallen, datums of als onderdeel van een array. Zet je strings tussen dubbele of enkele aanhalingstekens.

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

Dubbele sleutels

TOML verbiedt het tweemaal definiëren van dezelfde sleutel binnen dezelfde tabel, en verbiedt het herdefiniëren van een tabel die al was gedefinieerd. Dit is een veelvoorkomende fout bij het samenvoegen van configuratiefragmenten. Elke sleutel en tabel moet uniek zijn.

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

Ongeldig datumtijdformaat

TOML-datumtijden volgen RFC 3339. Een datum heeft een volledig 4-cijferig jaar, 2-cijferige maand en 2-cijferige dag nodig; een date-time heeft een T-scheidingsteken (of spatie) nodig. Onjuist gevormde datums parseren niet.

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

Ontbrekend sluithaakje

Arrays, inline-tabellen en tabelkoppen moeten worden gesloten. Een ongesloten [ of { produceert een parseerfout die wijst naar de regel en kolom waar het probleem is gedetecteerd.

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

Geheel getal buiten het veilige bereik

TOML-gehele getallen zijn 64-bits, maar JSON-getallen in de browser zijn beperkt tot 2^53 - 1. Waarden daarbuiten worden tijdens de conversie afgerond en er verschijnt een waarschuwing. Sla zeer grote gehele getallen op als tussen aanhalingstekens geplaatste strings om ze exact te houden.

✗ Fout
snowflake = 1420070400000000000
✓ Correct
snowflake = "1420070400000000000"

Een tabel herdefiniëren

Zodra een tabel zoals [servers] is gedefinieerd, kun je die niet opnieuw openen met dezelfde kop. Gebruik in plaats daarvan een array van tabellen ([[servers]]) om meerdere items te hebben, die een JSON-array van objecten wordt.

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

Veelvoorkomende toepassingen

Rust Cargo-metadata
Zet Cargo.toml om naar JSON om dependency-dashboards te bouwen, crate-versies en -features te controleren of manifestgegevens te voeden aan scripts en CI die JSON verwachten in plaats van TOML.
Python-projectconfiguratie
Zet pyproject.toml om naar JSON om PEP 621-projectmetadata te inspecteren, dependency-lijsten te extraheren of tooling aan te sturen die packaging-configuratie programmatisch leest.
Deployment-config inspecteren
Zet netlify.toml, foundry.toml of andere platformconfiguraties om naar JSON om redirects, headers en buildinstellingen te controleren, of om gelijkwaardige configuratie voor een ander platform te genereren.
Migratie van configuratieformaat
Zet TOML-applicatieconfiguratie om naar JSON bij de overstap naar een systeem dat de voorkeur geeft aan JSON, of als tussenstap voordat je verder transformeert met JSON-tooling zoals jq.
Instellingen voor statische sites
Zet Hugo config.toml om naar JSON om site-instellingen te migreren, configuratie tussen omgevingen te vergelijken of een instellingen-UI te bouwen die door JSON wordt aangedreven.
Invoer voor API's en scripts
Verander door mensen geschreven TOML in JSON die een REST-API, serverless-functie of automatiseringsscript direct kan verwerken, en overbrug zo leesbare configuratie en machine-invoer.

Technische details

TOML 1.0.0-parsing via smol-toml
TOML wordt geparseerd met de smol-toml-bibliotheek, een dependency-vrije, volledig TOML 1.0.0-conforme parser. Deze verwerkt geneste tabellen, sleutels met puntnotatie, inline-tabellen, arrays van tabellen, multi-line strings en alle vier datumtijdtypen correct, en rapporteert parseerfouten met regel- en kolomposities.
Verliesvrije datumtijd- en veilige geheel-getal-verwerking
TOML-datumtijden worden geserialiseerd naar JSON-strings die hun exacte soort behouden (offset date-time, lokale date-time, lokale datum, lokale tijd). Gehele getallen buiten het veilige bereik van JavaScript (2^53 - 1) worden tijdens het parseren gepromoveerd tot BigInt en vervolgens omgezet naar het dichtstbijzijnde JSON-getal met een precisiewaarschuwing, zodat geldige TOML nooit faalt bij het converteren.
100% browsergebaseerd — geen upload, geen server
Alle verwerking gebeurt in de JavaScript-engine van je browser. Er worden op geen enkel moment gegevens verzonden. Invoer groter dan 200 KB schakelt over van live naar handmatige modus (een expliciete klik op Converteren) om de interface responsief te houden.

Best practices

Sla zeer grote gehele getallen op als strings
Als je TOML gehele getallen buiten 2^53 - 1 bevat (Snowflake-ID's, nanoseconde-tijdstempels, grote tellers), zet ze dan als strings tussen aanhalingstekens vóór het converteren. JSON-getallen in de browser kunnen ze niet exact bevatten, en de tool waarschuwt je wanneer het moet afronden.
Geef de voorkeur aan 2-spaties-inspringing voor JSON-uitvoer
Twee-spaties-inspringing is de meest gebruikte conventie voor JSON en produceert schone, leesbare uitvoer die goed samenwerkt met de meeste formatters en diff-tools. Reserveer 4-spaties-inspringing voor wanneer een stijlgids het vereist.
Valideer de JSON-uitvoer voordat je het gebruikt
Als je na het converteren van plan bent de JSON handmatig te bewerken of het ergens strengs in te voeren, haal het dan door onze JSON Formatter om te bevestigen dat het geldig en consistent geformatteerd is.
Bewaar TOML-commentaar apart
JSON heeft geen commentaarsyntaxis, dus TOML #-commentaar wordt bij de conversie weggelaten. Als het commentaar belangrijke documentatie is, bewaar dan de oorspronkelijke TOML in versiebeheer naast de gegenereerde JSON.
Gebruik arrays van tabellen voor herhaalde secties
Als je meerdere vergelijkbare secties hebt (servers, redirects, bins), schrijf ze dan als arrays van tabellen ([[section]]) in plaats van [section] te herhalen. Ze converteren naar een schone JSON-array van objecten in plaats van een fout over dubbele tabellen te veroorzaken.

Veelgestelde vragen

Hoe zet ik TOML online om naar JSON?
Plak je TOML in het invoerveld hierboven. De tool parseert het en produceert direct JSON in je browser — je hoeft nergens op te klikken. Je kunt de JSON-inspringing in het paneel Opties wisselen tussen 2 en 4 spaties. Zodra de JSON in het uitvoergebied verschijnt, klik je op Kopiëren om het naar je klembord te halen of op Downloaden om het als .json-bestand op te slaan. Alles draait lokaal, dus je TOML verlaat nooit je apparaat.
Wat is TOML en waarom zou je het naar JSON omzetten?
TOML (Tom's Obvious, Minimal Language) is een configuratiebestandsformaat dat is ontworpen om gemakkelijk leesbaar en schrijfbaar te zijn voor mensen, met duidelijke semantiek die ondubbelzinnig op een hashtabel wordt gemapt. Het drijft Rusts Cargo.toml, Pythons pyproject.toml, Hugo, Netlify en veel andere tools aan. Je zet TOML om naar JSON wanneer je configuratie moet voeden aan een programma of API die JSON verwacht, een configuratiebestand programmatisch wilt inspecteren, twee configuraties met JSON-tooling wilt vergelijken of een UI wilt aansturen. TOML wordt door mensen geschreven; JSON wordt door machines gelezen — deze converter overbrugt de twee.
Hoe worden TOML-datums en -tijden in JSON weergegeven?
JSON heeft geen native datumtype, dus TOML-datumtijden worden omgezet naar strings. Deze tool behoudt de exacte TOML-datumsoort: een offset date-time zoals 1979-05-27T07:32:00Z wordt "1979-05-27T07:32:00.000Z", een lokale datum zoals 1979-05-27 blijft "1979-05-27" (die wordt niet aangevuld tot een volledig tijdstempel), en een lokale tijd zoals 07:32:00 wordt "07:32:00.000". Veel converters platten lokale datums ten onrechte af tot middernacht-UTC-tijdstempels — deze behoudt de oorspronkelijke betekenis, zodat rondritten verliesvrij zijn.
Verwerkt deze tool Cargo.toml en pyproject.toml?
Ja. Cargo.toml en pyproject.toml zijn de twee meest voorkomende TOML-bestanden in de praktijk, en beide worden volledig ondersteund, inclusief geneste tabellen ([dependencies], [tool.ruff]), inline-tabellen (serde = { version = "1.0", features = ["derive"] }) en arrays van tabellen ([[bin]]). Laad het Cargo.toml- of pyproject.toml-voorbeeld hierboven om de exacte JSON-structuur te zien die wordt geproduceerd. Dit is handig voor build-dashboards, dependency-audits of elk script dat projectmetadata als JSON leest.
Hoe worden TOML-tabellen en arrays van tabellen omgezet?
Een TOML-tabelkop zoals [owner] wordt een genest JSON-object onder de sleutel "owner". Een tabel met puntnotatie zoals [tool.ruff] wordt geneste objecten: { "tool": { "ruff": { ... } } }. Een array van tabellen geschreven met dubbele haken — [[servers]] herhaald — wordt een JSON-array van objecten: { "servers": [ { ... }, { ... } ] }. Inline-tabellen ({ a = 1, b = 2 }) worden gewone JSON-objecten. De conversie volgt de TOML 1.0.0-specificatie exact.
Wat gebeurt er met zeer grote gehele getallen bij het omzetten van TOML naar JSON?
TOML ondersteunt 64-bits gesigneerde gehele getallen, maar JavaScript (en dus JSON in de browser) kan gehele getallen alleen exact weergeven tot 2^53 - 1 (9007199254740991). Als je TOML een geheel getal bevat dat groter is dan dat — bijvoorbeeld een Snowflake-ID of een nanoseconde-tijdstempel — kan het niet verliesvrij als een JSON-getal worden weergegeven, en wordt de waarde afgerond, met een waarschuwing. Dit is een fundamentele beperking van browser-JavaScript die elke browsergebaseerde converter treft. Bewaar dergelijke waarden voor exacte weergave als tussen aanhalingstekens geplaatste strings in je TOML.
Worden mijn TOML-gegevens naar een server gestuurd?
Nee. Al het parseren en converteren gebeurt volledig in je browser met JavaScript. Je TOML wordt nooit geüpload, nooit opgeslagen en nooit gelogd. Dit maakt de tool veilig voor Cargo.toml-bestanden met privé registry-tokens, pyproject.toml met interne pakketindexen, deployment-configuraties met geheimen en elke andere gevoelige configuratie. Je kunt dit verifiëren door het tabblad Netwerk van je browser te openen — het plakken van TOML activeert nul netwerkverzoeken.
Kan ik JSON terug omzetten naar TOML?
Ja. Gebruik de bijbehorende JSON naar TOML Converter voor de omgekeerde richting, of klik op de knop Richting omwisselen bovenaan deze tool om de invoer en uitvoer ter plekke om te draaien. Merk op dat JSON naar TOML een paar beperkingen heeft die TOML naar JSON niet heeft — het hoogste niveau moet een object zijn en null-waarden hebben geen TOML-equivalent — die de JSON-naar-TOML-tool voor je uitlegt en afhandelt.
Hoe zet ik TOML naar JSON om op de opdrachtregel?
Een populaire optie is de op Rust gebaseerde CLI 'toml' of de Go-tool 'yj' (yj -tj leest TOML en schrijft JSON). Met Python 3.11+ kun je uitvoeren: python3 -c "import tomllib, json, sys; print(json.dumps(tomllib.load(sys.stdin.buffer)))" < config.toml. Met Node.js: npx smol-toml (of een klein script met de smol-toml-bibliotheek). Voor een snelle eenmalige actie in de browser zonder iets te installeren is deze tool het snelste pad.
Hoe zet ik TOML naar JSON om in Python, Rust of Node.js?
In Python 3.11+: import tomllib, json; data = tomllib.load(open('config.toml','rb')); json.dump(data, open('config.json','w')). In Rust: gebruik de crates toml en serde_json — let value: toml::Value = toml::from_str(&text)?; let json = serde_json::to_string_pretty(&value)?. In Node.js: import { parse } from 'smol-toml'; const data = parse(text); const json = JSON.stringify(data, null, 2) — dit is dezelfde bibliotheek en aanpak die deze tool gebruikt.
Behoudt de converter de sleutelvolgorde, en hoe zit het met commentaar?
De sleutelvolgorde binnen een tabel blijft behouden: sleutels verschijnen in de JSON-uitvoer in dezelfde volgorde als in je TOML. Commentaar wordt echter weggelaten — JSON heeft geen commentaarsyntaxis, dus TOML #-commentaar kan de conversie niet overleven. Als je documentatie wilt behouden, voeg het dan toe als een JSON-vriendelijk veld of bewaar de oorspronkelijke TOML naast de gegenereerde JSON.
Is er een limiet op de bestandsgrootte voor TOML-invoer?
Er is geen harde limiet, maar invoer boven de 200 KB schakelt over van live-conversie naar handmatige modus: er verschijnt een knop Converteren en de conversie draait pas wanneer je erop klikt, zodat de browser responsief blijft. Typische configuratiebestanden — zelfs grote Cargo.toml-workspaces of multi-omgevings-deployment-configuraties — converteren in ruim onder de 50 milliseconden.

Gerelateerde tools

Alle tools bekijken →