.env to JSON Converter

What is a .env File?

// Parse a .env file to a JSON object in Node.js using dotenv
import { parse } from 'dotenv';

const envText = `# Database
DATABASE_URL=postgres://user:pass@localhost:5432/mydb
DEBUG=true`;

// dotenv.parse returns a plain object of string values
const parsed = parse(envText);

// Every value is a string, just like process.env
const json = JSON.stringify(parsed, null, 2);

console.log(json);
// {
//   "DATABASE_URL": "postgres://user:pass@localhost:5432/mydb",
//   "DEBUG": "true"
// }

Key Features

Examples

# Database
DATABASE_URL=postgres://user:pass@localhost:5432/mydb
DATABASE_POOL_SIZE=10

# Auth
JWT_SECRET="super secret value"
SESSION_TIMEOUT=3600

# Feature flags
ENABLE_SIGNUP=true
VITE_API_BASE=https://api.example.com

{
  "DATABASE_URL": "postgres://user:pass@localhost:5432/mydb",
  "DATABASE_POOL_SIZE": "10",
  "JWT_SECRET": "super secret value",
  "SESSION_TIMEOUT": "3600",
  "ENABLE_SIGNUP": "true",
  "VITE_API_BASE": "https://api.example.com"
}

POSTGRES_DB=mydb
POSTGRES_USER=admin
POSTGRES_PASSWORD=s3cr3t!
PGDATA=/var/lib/postgresql/data
TZ=UTC
NGINX_HOST=example.com
NGINX_PORT=80

{
  "POSTGRES_DB": "mydb",
  "POSTGRES_USER": "admin",
  "POSTGRES_PASSWORD": "s3cr3t!",
  "PGDATA": "/var/lib/postgresql/data",
  "TZ": "UTC",
  "NGINX_HOST": "example.com",
  "NGINX_PORT": "80"
}

export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
export AWS_REGION=us-east-1
export DEPLOY_ENV=production

{
  "AWS_ACCESS_KEY_ID": "AKIAIOSFODNN7EXAMPLE",
  "AWS_SECRET_ACCESS_KEY": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY",
  "AWS_REGION": "us-east-1",
  "DEPLOY_ENV": "production"
}

APP_NAME=My App                 # unquoted value, inline comment stripped
GREETING="Hello,\nWorld"        # double quotes: \n becomes a real newline
LITERAL='no \n escapes here'    # single quotes: kept literally
PRIVATE_KEY="-----BEGIN KEY-----
line two
line three
-----END KEY-----"
EMPTY=

{
  "APP_NAME": "My App",
  "GREETING": "Hello,\nWorld",
  "LITERAL": "no \\n escapes here",
  "PRIVATE_KEY": "-----BEGIN KEY-----\nline two\nline three\n-----END KEY-----",
  "EMPTY": ""
}

How to Use

1. 1

   Paste Your .env File

   Enter or paste your .env contents into the input field above. You can also click 'Load example' to try a Node/Vite .env, a Docker Compose env file, or a CI secrets template.

2. 2

   See Live JSON Output

   JSON appears instantly in the output panel. Toggle 'Infer types' if you want numbers and booleans instead of strings, and pick 2 or 4 space indentation.

3. 3

   Copy or Download

   Click Copy to grab the JSON to your clipboard, or Download to save it as a .json file — ready for a config loader, a secrets manager, or any tool that reads JSON.

Common .env Pitfalls

DATABASE_URL
DEBUG true

DATABASE_URL=
DEBUG=true

API_KEY = abc123

API_KEY=abc123

COLOR=#ff0000

COLOR="#ff0000"

GREETING='Hello\nWorld'

GREETING="Hello\nWorld"

KEY="-----BEGIN-----
line two

KEY="-----BEGIN-----
line two
-----END-----"

PORT=3000
PORT=8080

PORT=8080

Common Use Cases

Feed Config into JSON-Based Tooling

Convert a .env file to JSON to load environment configuration into tools, scripts and SDKs that read JSON rather than environment variables — config validators, schema checkers and code generators.

Import Secrets into a Manager

Many secret managers (AWS Secrets Manager, Vault, Doppler) accept JSON for bulk import. Convert a .env file to a JSON object first, then push the whole set in one operation instead of one variable at a time.

Inspect a Long .env at a Glance

Turn a sprawling .env file into structured, indented JSON so you can scan keys, spot duplicates via the warning, and review configuration in a readable format before committing changes.

Generate Typed Config Objects

Enable Infer types to get numbers, booleans and null in the JSON, then feed it into a typed config layer or a JSON-to-TypeScript step to derive an interface for your environment variables.

Validate Against a JSON Schema

Convert .env to JSON and run it through a JSON Schema validator to enforce required keys, value formats and allowed enums in CI — catching misconfigured environments before deploy.

Migrate Docker Compose env_file Config

Turn the env_file your Compose stack reads into JSON for use in another orchestration tool, a config server, or documentation — without exposing real credentials to any external service.

Technical Details

Line-by-Line dotenv-Compatible Parsing

Input is parsed line by line. Blank lines and comment lines (first non-whitespace character #) are skipped, an optional export prefix is removed, and each remaining line is split on the first = into key and value. Keys are trimmed of surrounding whitespace. Values follow dotenv rules: double quotes process \n \t \r \\ \" escapes and allow multi-line spans, single quotes are literal, and unquoted values strip trailing whitespace and inline comments.

Optional Type Inference

By default all values are emitted as JSON strings, matching dotenv's runtime behavior where process.env values are always strings. With Infer types enabled, unquoted values are promoted: numeric strings become JSON numbers, true/false become booleans, and empty or null values become JSON null. Quoted values are never inferred — the quotes mark them as explicit strings. Duplicate keys resolve last-wins with a warning.

Browser-Based — No Upload, No Server

All processing happens entirely in your browser's JavaScript engine; no .env data is transmitted over the network at any point. There are no external dependencies because the parser is written in-house — the Node dotenv library relies on the file system and is not browser-safe. Inputs larger than 200KB switch from live mode to manual mode (an explicit Convert click) to keep the browser responsive.

Best Practices

Keep the Default String Output to Match dotenv

dotenv loads every value as a string, so the default string output reflects exactly what your application sees at runtime. Only enable Infer types when the downstream consumer genuinely expects typed JSON — otherwise you risk a mismatch where '0' or 'false' behaves differently in JSON than in your running app.

Quote Values Containing # or Whitespace

On unquoted values a space followed by # starts an inline comment, and trailing whitespace is trimmed. If a value legitimately contains a # (hex colors, fragment URLs) or meaningful spaces, wrap it in double quotes so it is preserved verbatim in the JSON.

Resolve Duplicate Keys at the Source

The tool keeps the last value and warns you when a key is duplicated, but a duplicate in a .env file is almost always a mistake. Remove the redundant line so there is no ambiguity about which secret is active.

Never Paste Production Secrets into Server-Side Converters

Because a .env file is effectively a list of credentials, only convert it in a tool that runs entirely in the browser. This converter does — verify zero network requests in DevTools — so it is safe for real secrets, unlike server-side or API-backed converters.

Validate the JSON Before Using it Downstream

After converting, run the JSON through the JSON Formatter to confirm the structure before feeding it into a schema validator, a secrets manager import, or a config loader, so a structural surprise surfaces early.

Frequently Asked Questions