ENV to JSON - Parse Environment Files

Convert .env files to JSON format in your browser. Parse Docker configs, Node.js environment variables, handle comments and quotes. Private, no uploads.

ENV Input

Paste your .env file content

Structure

Options

Mask sensitive values

JSON Output

ENV Format Reference

Basic Syntax

# Comment
KEY=value
QUOTED="value with spaces"
SINGLE='literal value'
export SHELL_VAR=value

Special Cases

MULTILINE="line1\nline2"
EMPTY=
WITH_EQUALS="key=value"
WITH_QUOTES="say \"hello\""
TRIM=  spaces removed

{% include "components/faq.njk" %}

Related Tools

REG to JSON - Windows Registry Parser

Crontab File Parser - Convert Jobs to JS…

INI to JSON - Migrate Windows Config Fil…

Hosts File to JSON - Parse System DNS Ov…

Cron Expression Parser - Validate Schedu…

HCL to JSON Converter - Terraform Config…

View all Config parsers →

Frequently Asked Questions

The .env file format is a simple text-based configuration format using KEY=VALUE pairs, one per line. It's widely used to store environment variables for applications, especially in Node.js projects, Docker containers, and 12-factor apps. The format supports comments (lines starting with #), quoted values, and variable references. It provides a clean way to separate configuration from code and manage different settings across development, staging, and production environments.

In Node.js, libraries like dotenv load .env files and populate process.env with the variables, making them accessible throughout the application. Docker uses .env files with docker-compose to set environment variables for containers via the env_file directive. Both ecosystems use this format because it's human-readable, version-control friendly (when not containing secrets), and provides a standard way to configure applications across different deployment environments without hardcoding values.

This converter focuses on parsing the raw .env syntax into JSON format. It does not perform variable expansion (like ${VAR} or $VAR references) or shell-style substitution. The variables are converted as literal strings. If your .env file contains variable references, they will appear in the JSON output as-is. For actual variable expansion, you would need runtime libraries like dotenv-expand that resolve references when the application loads.

The parser automatically strips comments from .env files. Lines starting with # are ignored entirely, and inline comments (# after a value) are removed unless the # appears inside quoted strings. This matches the behavior of most .env parsers and ensures that documentation comments in your configuration files don't pollute the JSON output. Comments provide a way to document configuration options without affecting the actual variable values.

Yes, the parser supports multiline values when they are properly enclosed in double quotes. In standard .env format, multiline strings must be wrapped in double quotes with literal newline characters or \n escape sequences. Single-line values don't require quotes. The converted JSON will preserve the multiline structure, representing newlines as \n escape sequences in the JSON string values.

The parser correctly handles both single-quoted and double-quoted strings. Double quotes allow escape sequences like \n (newline), \t (tab), and \" (literal quote). Single quotes treat everything literally except the closing quote. Unquoted values are trimmed of whitespace. Special characters like spaces, equals signs, and quotes within quoted values are preserved. This ensures that complex configuration values, including connection strings and formatted text, convert accurately to JSON.

Some .env files include the 'export' keyword before variable assignments (export KEY=value), making them compatible with shell scripts. This converter automatically strips the 'export ' prefix during parsing, treating 'export KEY=value' the same as 'KEY=value'. This makes the tool compatible with both pure .env files and shell-compatible environment files, providing flexibility for different workflows and deployment scripts.

Yes, the converter includes an option to mask sensitive values before conversion. When enabled, it detects common secret patterns in variable names (like PASSWORD, SECRET, API_KEY, TOKEN) and replaces their values with masked strings (e.g., '***'). This allows you to share configuration structure and validate .env file syntax without exposing actual credentials. All processing happens in your browser, so sensitive data never leaves your device.

The converter offers two output modes: flat and nested. Flat mode creates a simple JSON object with keys exactly as they appear in the .env file (DB_HOST, DB_PORT). Nested mode interprets underscore separators as hierarchy, converting DB_HOST and DB_PORT into nested structure: {"DB": {"HOST": "...", "PORT": "..."}}. You can choose single underscore (_) or double underscore (__) as the nesting delimiter. This helps organize complex configurations with many related variables.

Yes, the parser validates .env syntax and highlights common errors like unclosed quotes, invalid characters in variable names, or malformed assignments. If parsing fails, the tool displays a clear error message indicating the line number and issue type. This validation helps catch configuration problems before deployment. The parser follows standard .env conventions, requiring variable names to be alphanumeric with underscores, and values to be properly quoted if they contain special characters.