Skip to content
UtilPick.
My toolbox
All tools
Favorites
Saved tools

Loading…

Recently used

Tools you open will appear here.

Get the desktop app
Settings
UtilPick.
All tools
All tools/Config File Converter

Config File Converter

Convert between JSON, YAML and TOML and see exactly what gets lost. Nothing you enter is sent to a server.

Loading the tool…

User reviews

No reviews yet. If you’ve used this tool, be the first to leave one.

User reviews

No reviews yet.

Write a review

Checking your sign-in status…

    From first step to finished result

    Config File Converter: complete guide

    Walk through the steps and examples, or jump straight to the topic you need.

    How to use
    Examples & choices
    Troubleshooting
    FAQ

    At a glance

    Formats handled
    JSON, YAML and TOML, converting between any two.
    Source format
    Detected automatically, and you can also choose it yourself.
    What it refuses
    YAML anchors (&), aliases (*), merge keys (<<), tags (!!) and multiple documents (---).
    Losses it reports
    Comments disappear, dates become text, and large integers may change value.
    TOML limits
    It can't hold an empty value (null), so the conversion is blocked with a reason.
    YAML support
    Indented structure, lists, inline lists and tables, and multi-line values (| and >).
    TOML support
    Tables, arrays of tables ([[ ]]), dotted names, inline tables and multi-line strings.
    Size
    Up to 200,000 characters. Nothing is sent to a server.

    How to use Config File Converter

    1. 01

      Paste your config

      The format is detected automatically. If it detects it wrongly, choose the source format yourself.

    2. 02

      Choose the format to convert to

      Choose from JSON, YAML and TOML. The result appears as soon as you choose.

    3. 03

      Check what is lost

      If anything changes in the conversion, such as comments, dates or large numbers, it is shown in yellow text above the result. Decide whether you can use it as it is.

    4. 04

      Take it with you

      You can copy it or save it with the matching file extension. You can also move the result to the source and convert it to yet another format.

    What it’s good for

    A refusal is better than a wrong result

    YAML anchors (&), aliases (*), merge keys (<<) and tags (!!) are syntax for pulling a value in from somewhere else. If they are unrolled carelessly, you get a config file that looks fine but has different real values. A config file is more dangerous because a mistake doesn't show right away. So when this tool meets that syntax, it doesn't guess and instead tells you what the problem is.

    It doesn't hide what you lose

    Comments can't be moved to the same place in any format, so they disappear. Dates and times are handled differently by each format, so they are carried over as text. Very large integers can't be held exactly by the browser, so their values may change. TOML can't hold an empty value (null) at all. When any of this happens, the tool writes next to the result what was lost.

    Worked examples

    YAML to JSON

    Input and settings
    server:
      port: 8080
      tags:
        - web
    Result
    {
      "server": {
        "port": 8080,
        "tags": ["web"]
      }
    }
    The structure and types carry over as they are. Numbers stay numbers and lists become arrays.

    Syntax it can't handle

    Input and settings
    base: &b
      a: 1
    use: *b
    Result
    YAML anchors (&) and aliases (*) are not handled. Spell out the values and try again.
    Instead of producing a wrong result, it tells you what the problem is.

    What each format can hold

    Swipe the table sideways to see the rest.

    What each format can hold
    ItemJSONYAML / TOML
    CommentsCan't hold themYAML and TOML both can, but they are lost in conversion
    Empty value (null)AllowedAllowed in YAML, not in TOML
    Date typeNone (text)TOML has its own date type
    Large integersLimited precisionInherits the same limit

    When the result isn’t what you expected

    It refused because I use anchors

    Spell out the parts where you reused values with & and *. Unrolling them automatically could change the original meaning, so the tool blocks it on purpose.

    It says it can't convert to TOML

    It may contain an empty value (null), or the outermost level may be an array. TOML can't hold either. It also tells you which name is the problem.

    A number changed

    An integer longer than 16 digits can't be held exactly by the browser. If you need the exact value, wrap it in quotes and treat it as text.

    It says the indentation is off

    It tells you which line. YAML can't use tabs, so replace them with spaces.

    Key terms

    YAML anchors and aliases
    Syntax for pulling in a value written in one place and using it somewhere else.
    TOML array of tables
    A way to write several items of the same shape using [[name]].
    Safe integer
    The range of integers JavaScript can hold exactly.
    Inline table
    A group written on one line, like { x = 1, y = 2 }.

    Config File Converter FAQ

    Do comments disappear?

    Yes. JSON can't hold comments, and there is no way to know where a comment should go after conversion. If there are comments, you are told before converting.

    Can it handle all YAML?

    No. It handles widely used syntax, and does not handle anchors, aliases, merge keys, tags or multiple documents. For such files it tells you why, so spell out that part and try again.

    Is my config uploaded to a server?

    No. It is converted only inside this browser. You can paste a config that contains connection details as it is.

    Why does it refuse some files outright?

    A mistake in a config file doesn't show right away. Using a wrongly converted file as it is becomes a problem that is hard to find later, so when the tool isn't sure, it chooses not to convert.

    Is there no way to keep comments?

    No. JSON can't hold comments, and even in a format that can, there is no way to know which line a comment should go on after conversion. Instead, you are told in advance if there are comments.

    Can I convert the result again?

    Yes. Click "Use result as source" and the result moves to the left so you can convert it to another format.

    Jump to a topic

    • #JSON YAML conversion
    • #anchor refusal
    • #loss warning
    • #TOML limits
    • #large integers
    • #comments

    Reviewed 2026.09.09

    Related tools

    View all
    JSON FormatterDeveloper
    CSV to JSONDeveloper
    SQL FormatterDeveloper
    UtilPick

    Simple tools for a complicated day. A free collection of online utilities.

    Service

    About UtilPick Get the desktop app

    Help

    Request a toolReport a problemContactinfo@utilpick.com

    Policies

    Privacy Policy (Korean)Terms of Use (Korean)
    Business registration no. 365-47-00936 (Republic of Korea)
    © 2026 UtilPick
    Featured on Twelve ToolsUtilPick - Featured on Startup FameFazier badgeFeatured on LaunchIgniter
    HomeSearchSavedMore
    Convert config file formats

    Source

    Source format

    Detected as YAML. If that’s wrong, choose it above.

    Converted result

    YAML → JSON

    Target format
    • Comments can’t be carried over and are lost. Of JSON and TOML, only TOML supports comments, and even then their original position is unknown.
    {
      "server": {
        "host": "localhost",
        "port": 8080,
        "debug": true,
        "tags": [
          "web",
          "api"
        ]
      },
      "database": {
        "url": "postgres://localhost:5432/app",
        "pool": 10
      }
    }
    Supported syntax and what gets lost

    Common syntax is supported. Syntax that can’t be handled, such as YAML anchors (&), aliases (*), merge keys, and tags, isn’t guessed at; you’re told why instead. That’s better than silently producing a wrong config file.

    Each format can hold different things, so some information may be lost: comments disappear, dates become text, and very large integers may change. When that happens, you’re told along with the result.