Flatten ASP.NET Core appsettings.json into Section__Key environment variables for .env, Docker Compose, Kubernetes, Azure App Service, PowerShell, and bash — or rebuild the JSON from env vars.
Loading appsettings ↔ Env…
Loading appsettings ↔ Env…
ASP.NET Core reads configuration from several providers — appsettings.json, appsettings.{Environment}.json, user secrets, environment variables, command-line arguments — and later providers override earlier ones. That override order is why environment variables are the standard way to change a setting per container, per pod, or per App Service slot without rebuilding the image. The catch is the naming: every nested JSON key has to be flattened into one variable name, arrays need index segments, and the separator has to be __ on Linux because a colon is not a legal character in most shells. Doing that by hand for a 60-line appsettings.json is slow and easy to get wrong, especially the quoting — a connection string with a semicolon breaks an unquoted bash export, a dollar sign gets interpolated by Docker Compose, and $(…) gets expanded by Kubernetes. This converter applies the same flattening rules as Microsoft.Extensions.Configuration, then quotes each value correctly for the target you pick. It also works in reverse: paste the environment block from a Compose file, a Kubernetes manifest, Azure's Advanced edit JSON or a shell history, and it rebuilds the nested appsettings.json so you can see what a running container is actually configured with.
The input is parsed with a JSON reader that accepts // and /* */ comments and trailing commas, as .NET's JSON configuration provider does. Objects become Section:Key paths, array elements become Section:0, Section:1, and the path is joined with __ (or : for the colon output). Numbers keep their original text, so 1.0 stays 1.0 and a 19-digit ID is not rounded.
bash uses single quotes with ' written as '\''. PowerShell uses verbatim single-quoted strings and doubles both straight and curly quotes, which PowerShell also treats as delimiters. Docker Compose values are YAML double-quoted with $ escaped as $$. Kubernetes escapes $( as $$( so the kubelet does not expand it. .env values stay unquoted when safe and are single- or double-quoted otherwise.
Empty objects and arrays, null values, keys that already contain __ or :, and keys that collide when compared case-insensitively are all reported, because each of them changes what .NET will see. Names that bash cannot export — for example Microsoft.AspNetCore with its dots — are commented out in the bash output rather than emitted broken.
Each input style is parsed with its own quoting rules: dotenv escapes, bash quoting, PowerShell backtick escapes, YAML scalars in Compose and Kubernetes lists, and Azure's JSON array. Names are split on __ and :, merged case-insensitively as .NET does, and rebuilt into nested JSON. Optional type inference writes true, false and numbers as JSON literals.
Short answers for the things developers usually ask before trusting a tool.
No. Parsing and conversion run in your browser with JavaScript; nothing you paste is sent to a server. Because appsettings files often hold connection strings and keys, the Share button is switched off whenever the input contains secret-looking values.
Configuration keys are hierarchical and use a colon as the separator (Logging:LogLevel:Default), but most Linux shells and container runtimes reject a colon in a variable name. The environment variable provider in Microsoft.Extensions.Configuration replaces __ with : when it reads variables, so Logging__LogLevel__Default works on every platform.
Each element gets its index as a key segment: AllowedHosts__0=a.com and AllowedHosts__1=b.com. Arrays of objects nest further, for example Downstream__0__BaseUrl. When converting back, keys become a JSON array only if the indexes run 0, 1, 2… without gaps; otherwise they stay an object and the tool warns you.
Environment variables are always strings. Numbers and booleans are written as their JSON text (50, true), and .NET converts them back when it binds options. A null becomes an empty value, which .NET reads as an empty string rather than null. Empty objects and arrays produce no variables at all, and the tool lists the paths it dropped.
When you call AddEnvironmentVariables with a prefix, .NET only reads variables that start with it (matched case-insensitively) and strips the prefix before mapping __ to :. Enter the same prefix here and every generated name starts with it; in reverse mode, variables without the prefix are skipped and listed.
On Windows and in launchSettings.json, yes — the "Colon keys" output uses Section:Key. On Linux, in Docker and in Kubernetes, stick with __, because a colon is not a valid character in most shells' variable names.
.NET configuration keys are case-insensitive. Two JSON keys such as Logging and logging in the same object make the JSON provider throw "A duplicate key was found" at startup, and as Linux environment variables both names can exist at once while .NET silently keeps only one of them.
Useful follow-ups when one conversion usually turns into three more.
Convert .env files to Dockerfile, docker-compose, GitHub Actions, Vercel, Kubernetes ConfigMap, and more.
Format, validate, and minify JSON instantly with a browser-first editor.
Generate sample JSON from C# classes, including nested classes, dictionaries, and lists.
Want the background and worked examples? There's a longer write-up.
Read the appsettings ↔ Env guide