.env naar JSON Converter

Wat is een .env-bestand?

// 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"
// }

Belangrijkste functies

Voorbeelden

# 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": ""
}

Hoe te gebruiken

1. 1

   Plak je .env-bestand

   Voer je .env-inhoud in of plak die in het invoerveld hierboven. Je kunt ook op 'Voorbeeld laden' klikken om een Node/Vite .env, een Docker Compose env-bestand of een CI-secrets-sjabloon te proberen.

2. 2

   Bekijk live JSON-uitvoer

   JSON verschijnt direct in het uitvoerpaneel. Schakel 'Types afleiden' in als je getallen en booleans in plaats van strings wilt, en kies inspringing met 2 of 4 spaties.

3. 3

   Kopiëren of downloaden

   Klik op Kopiëren om de JSON naar je klembord te halen, of op Downloaden om het als .json-bestand op te slaan — klaar voor een config-loader, een secrets manager of elke tool die JSON leest.

Veelvoorkomende .env-valkuilen

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

Veelvoorkomende toepassingen

Config voeden aan JSON-gebaseerde tooling

Converteer een .env-bestand naar JSON om omgevingsconfiguratie te laden in tools, scripts en SDK's die JSON lezen in plaats van omgevingsvariabelen — config-validators, schema-checkers en codegeneratoren.

Geheimen importeren in een manager

Veel secret managers (AWS Secrets Manager, Vault, Doppler) accepteren JSON voor bulkimport. Converteer eerst een .env-bestand naar een JSON-object en push daarna de hele set in één bewerking in plaats van één variabele tegelijk.

Een lange .env in één oogopslag bekijken

Zet een uitgedijd .env-bestand om naar gestructureerde, ingesprongen JSON zodat je sleutels kunt scannen, duplicaten via de waarschuwing kunt opsporen en configuratie in een leesbaar formaat kunt nakijken voordat je wijzigingen vastlegt.

Getypeerde config-objecten genereren

Schakel Types afleiden in om getallen, booleans en null in de JSON te krijgen, en voer het daarna in een getypeerde config-laag of een JSON-naar-TypeScript-stap om een interface voor je omgevingsvariabelen af te leiden.

Valideren tegen een JSON Schema

Converteer .env naar JSON en haal het door een JSON Schema-validator om vereiste sleutels, waardeformaten en toegestane enums in CI af te dwingen — zo vang je verkeerd geconfigureerde omgevingen op vóór de deploy.

Docker Compose env_file-config migreren

Zet het env_file dat je Compose-stack leest om naar JSON voor gebruik in een andere orchestratietool, een config-server of documentatie — zonder echte inloggegevens aan een externe dienst bloot te stellen.

Technische details

Regel-voor-regel dotenv-compatibele parsing

Invoer wordt regel voor regel geparseerd. Lege regels en commentaarregels (eerste niet-witruimteteken #) worden overgeslagen, een optioneel export-prefix wordt verwijderd, en elke resterende regel wordt op het eerste = gesplitst in sleutel en waarde. Bij sleutels wordt omringende whitespace afgesneden. Waarden volgen de dotenv-regels: dubbele aanhalingstekens verwerken \n \t \r \\ \" escapes en staan multi-line-spans toe, enkele aanhalingstekens zijn letterlijk, en niet-aangehaalde waarden verwijderen trailing whitespace en inline-commentaar.

Optionele type-inferentie

Standaard worden alle waarden als JSON-strings uitgevoerd, wat dotenv's runtime-gedrag evenaart waarbij process.env-waarden altijd strings zijn. Met Types afleiden ingeschakeld worden niet-aangehaalde waarden gepromoveerd: numerieke strings worden JSON-getallen, true/false worden booleans, en lege of null-waarden worden JSON-null. Aangehaalde waarden worden nooit afgeleid — de aanhalingstekens markeren ze als expliciete strings. Dubbele sleutels worden opgelost volgens last-wins met een waarschuwing.

Browsergebaseerd — geen upload, geen server

Alle verwerking gebeurt volledig in de JavaScript-engine van je browser; er worden op geen enkel moment .env-gegevens over het netwerk verzonden. Er zijn geen externe afhankelijkheden omdat de parser in eigen huis is geschreven — de Node-dotenv-bibliotheek leunt op het bestandssysteem en is niet browserveilig. Invoer groter dan 200KB schakelt over van live-modus naar handmatige modus (een expliciete Converteren-klik) om de browser responsief te houden.

Best practices

Houd de standaard string-uitvoer aan om dotenv te evenaren

dotenv laadt elke waarde als een string, dus de standaard string-uitvoer weerspiegelt precies wat je applicatie tijdens runtime ziet. Schakel Types afleiden alleen in wanneer de downstream-consument echt getypeerde JSON verwacht — anders riskeer je een mismatch waarbij '0' of 'false' zich anders gedraagt in JSON dan in je draaiende app.

Zet waarden met # of whitespace tussen aanhalingstekens

Bij niet-aangehaalde waarden start een spatie gevolgd door # een inline-commentaar, en wordt trailing whitespace afgesneden. Als een waarde legitiem een # bevat (hex-kleuren, fragment-URL's) of betekenisvolle spaties, zet die dan tussen dubbele aanhalingstekens zodat die letterlijk in de JSON behouden blijft.

Los dubbele sleutels bij de bron op

De tool behoudt de laatste waarde en waarschuwt je wanneer een sleutel gedupliceerd is, maar een duplicaat in een .env-bestand is bijna altijd een vergissing. Verwijder de overbodige regel zodat er geen onduidelijkheid is over welk geheim actief is.

Plak nooit productiegeheimen in server-side converters

Omdat een .env-bestand in feite een lijst met inloggegevens is, converteer het alleen in een tool die volledig in de browser draait. Deze converter doet dat — verifieer nul netwerkverzoeken in DevTools — dus is hij veilig voor echte geheimen, anders dan server-side of API-gebaseerde converters.

Valideer de JSON voordat je die downstream gebruikt

Haal na het converteren de JSON door de JSON Formatter om de structuur te bevestigen voordat je die voedt aan een schema-validator, een secrets-manager-import of een config-loader, zodat een structurele verrassing vroeg aan het licht komt.

Veelgestelde vragen