Why does a top-level JSON value have to be an object?

TOML documents are always a table (a set of key = value pairs and sections) at the root, with no equivalent to a bare top-level array or scalar the way JSON allows, so the converter requires a JSON object at the top level.

How are nested objects and arrays of objects represented?

A nested object becomes a [section] table using its dotted path as the header. An array whose items are all objects becomes repeated [[section]] array-of-tables blocks instead, one per item, which is how TOML represents a list of records.

Does this support the full TOML specification?

No, it covers the common subset needed to round-trip typical JSON config data: strings, numbers, booleans, inline scalar arrays, tables, and array-of-tables. TOML features like datetimes, inline tables, and dotted keys aren't produced.

What happens to an array that mixes scalars and objects?

Mixed arrays aren't representable in the table/array-of-tables model this converter targets, since TOML requires an array-of-tables to contain only tables; the converter treats such an array as a scalar array and stringifies any object items, so it's best to keep arrays consistently typed before converting.

JSON to TOML Converter - Convert JSON Online

Overview

Introduction

TOML is the config format Cargo, Poetry, and a growing number of CLI tools read, but data often starts life as JSON from an API response or a script. This tool converts that JSON straight into TOML's table-based syntax.

It handles the two structural translations that matter most: nested objects becoming [section] tables, and arrays of objects becoming [[section]] array-of-tables, which is how TOML represents a list of records.

What Is JSON to TOML Converter?

A converter that walks a parsed JSON object and re-serializes it using TOML's key = value, [section], and [[section]] syntax instead of JSON's braces and brackets.

It targets the common subset of TOML most tooling actually uses, rather than the format's full spec, which includes datetime types and inline tables this converter doesn't produce.

How JSON to TOML Converter Works

Top-level scalar keys become key = value lines. A nested object becomes a [section] header followed by that object's own keys. An array of objects becomes one [[section]] block per item, TOML's array-of-tables syntax.

Scalar arrays (arrays with no object items) are emitted inline as [a, b, c] on their own key = value line rather than exploded into separate table blocks.

When To Use JSON to TOML Converter

Use it when you have JSON data, an API response, a script's output, a converted YAML file, and need it as a TOML config for a Rust, Python, or CLI tool that expects that format.

It's also handy for previewing how a JSON structure would look as a Cargo.toml-style config before hand-writing one.

Often used alongside TOML to JSON Converter, JSON to YAML Converter and JSON to INI Converter.

Features

Advantages

Produces idiomatic TOML tables and array-of-tables instead of a flat, unreadable dump.
Handles arbitrarily nested objects, not just a single flat table.
Runs entirely client-side, so config data with secrets never leaves the browser.

Limitations

Doesn't produce TOML datetime types, inline tables, or dotted-key syntax.
Arrays that mix scalars and objects aren't representable and get stringified as a scalar array instead.
Every string is quoted with double quotes; TOML's literal (single-quoted) string style isn't used.

Examples

Nested config with an array of tables

Input

{"name":"api","servers":[{"host":"a.example.com"},{"host":"b.example.com"}]}

Output

name = "api"

[[servers]]
host = "a.example.com"

[[servers]]
host = "b.example.com"

The scalar key stays a key = value line; the array of objects becomes two [[servers]] array-of-tables blocks.

Best Practices & Notes

Best Practices

Keep arrays consistently typed (all scalars or all objects) before converting, since TOML can't mix the two in one array.
Review the output against your target tool's expected schema, since TOML tables are order-sensitive for some parsers.
For simple flat config, this produces the same result as hand-writing TOML; save it for genuinely nested structures.

Developer Notes

The converter delegates to a shared encodeToml() routine that also powers this site's XML-to-TOML converter: it recursively separates each object's entries into scalar key = value lines and nested table sections, joining sections with blank lines and using the accumulated dotted path as each table's header, so [servers.limits] style nested headers fall out naturally from recursion depth rather than needing separate handling.

JSON to TOML Converter Use Cases

Converting a JSON API response into a TOML config file for a Rust or Python tool
Turning a converted-from-YAML JSON document into TOML for comparison
Producing a Cargo.toml-style array-of-tables preview from JSON test data

Common Mistakes

Passing a top-level JSON array instead of an object; TOML has no bare top-level array.
Expecting datetime values to convert specially; they're emitted as plain quoted strings.
Mixing scalars and objects in one array and expecting a valid array-of-tables result.

Tips

If you only need a flat config, skip the nested structure and keep your JSON shallow before converting.
Pair with TOML to JSON to check the conversion round-trips the way you expect.

JSON to TOML Converter