Convertisseur .env vers JSON

Qu'est-ce qu'un fichier .env ?

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

Fonctionnalités clés

Exemples

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

Comment utiliser

1. 1

   Collez votre fichier .env

   Saisissez ou collez le contenu de votre .env dans le champ de saisie ci-dessus. Vous pouvez aussi cliquer sur « Charger un exemple » pour essayer un .env Node/Vite, un fichier env Docker Compose ou un modèle de secrets CI.

2. 2

   Voir la sortie JSON en direct

   Le JSON apparaît instantanément dans le panneau de sortie. Activez « Inférer les types » si vous voulez des nombres et des booléens plutôt que des chaînes, et choisissez une indentation de 2 ou 4 espaces.

3. 3

   Copier ou télécharger

   Cliquez sur Copier pour récupérer le JSON dans votre presse-papiers, ou Télécharger pour l'enregistrer en fichier .json — prêt pour un chargeur de configuration, un gestionnaire de secrets ou tout outil qui lit du JSON.

Pièges courants du .env

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

Cas d'usage courants

Alimenter une configuration dans un outillage basé sur JSON

Convertissez un fichier .env en JSON pour charger la configuration d'environnement dans des outils, scripts et SDK qui lisent du JSON plutôt que des variables d'environnement — validateurs de config, vérificateurs de schéma et générateurs de code.

Importer des secrets dans un gestionnaire

De nombreux gestionnaires de secrets (AWS Secrets Manager, Vault, Doppler) acceptent du JSON pour un import en masse. Convertissez d'abord un fichier .env en objet JSON, puis poussez l'ensemble en une seule opération plutôt qu'une variable à la fois.

Inspecter un long .env d'un coup d'œil

Transformez un fichier .env tentaculaire en JSON structuré et indenté pour parcourir les clés, repérer les doublons via l'avertissement et examiner la configuration dans un format lisible avant de valider des changements.

Générer des objets de config typés

Activez Inférer les types pour obtenir des nombres, booléens et null dans le JSON, puis alimentez-le dans une couche de config typée ou une étape JSON vers TypeScript pour dériver une interface de vos variables d'environnement.

Valider face à un JSON Schema

Convertissez le .env en JSON et passez-le dans un validateur JSON Schema pour imposer les clés requises, les formats de valeur et les énumérations autorisées en CI — détectant les environnements mal configurés avant le déploiement.

Migrer la configuration env_file de Docker Compose

Transformez l'env_file lu par votre pile Compose en JSON pour l'utiliser dans un autre outil d'orchestration, un serveur de config ou de la documentation — sans exposer de vrais identifiants à un service externe.

Détails techniques

Analyse ligne par ligne compatible dotenv

L'entrée est analysée ligne par ligne. Les lignes vides et les lignes de commentaire (premier caractère non blanc #) sont ignorées, un préfixe export optionnel est retiré, et chaque ligne restante est séparée au premier = en clé et valeur. Les clés sont nettoyées des espaces environnants. Les valeurs suivent les règles dotenv : les guillemets doubles traitent les échappements \n \t \r \\ \" et autorisent les valeurs multilignes, les guillemets simples sont littéraux, et les valeurs non entre guillemets retirent les espaces de fin et les commentaires en ligne.

Inférence de type optionnelle

Par défaut, toutes les valeurs sont émises comme chaînes JSON, ce qui correspond au comportement d'exécution de dotenv où les valeurs de process.env sont toujours des chaînes. Avec Inférer les types activé, les valeurs non entre guillemets sont promues : les chaînes numériques deviennent des nombres JSON, true/false deviennent des booléens, et les valeurs vides ou null deviennent null en JSON. Les valeurs entre guillemets ne sont jamais inférées — les guillemets les marquent comme chaînes explicites. Les clés en double se résolvent en dernier-gagne avec un avertissement.

Côté navigateur — aucun envoi, aucun serveur

Tout le traitement se déroule entièrement dans le moteur JavaScript de votre navigateur ; aucune donnée .env n'est transmise sur le réseau à aucun moment. Il n'y a aucune dépendance externe car l'analyseur est écrit en interne — la bibliothèque Node dotenv repose sur le système de fichiers et n'est pas sûre côté navigateur. Les entrées de plus de 200 Ko passent du mode direct au mode manuel (un clic explicite sur Convertir) pour garder le navigateur réactif.

Bonnes pratiques

Garder la sortie chaîne par défaut pour correspondre à dotenv

dotenv charge chaque valeur comme une chaîne, donc la sortie chaîne par défaut reflète exactement ce que votre application voit à l'exécution. N'activez Inférer les types que lorsque le consommateur en aval attend vraiment un JSON typé — sinon vous risquez un décalage où '0' ou 'false' se comporte différemment en JSON et dans votre application en cours d'exécution.

Mettre entre guillemets les valeurs contenant # ou des espaces

Sur les valeurs non entre guillemets, un espace suivi de # commence un commentaire en ligne, et les espaces de fin sont retirés. Si une valeur contient légitimement un # (couleurs hexadécimales, URL avec fragment) ou des espaces significatifs, mettez-la entre guillemets doubles pour qu'elle soit préservée telle quelle dans le JSON.

Résoudre les clés en double à la source

L'outil conserve la dernière valeur et vous avertit quand une clé est en double, mais un doublon dans un fichier .env est presque toujours une erreur. Retirez la ligne redondante pour qu'il n'y ait aucune ambiguïté sur le secret actif.

Ne jamais coller de secrets de production dans des convertisseurs côté serveur

Comme un fichier .env est de fait une liste d'identifiants, ne le convertissez que dans un outil qui s'exécute entièrement dans le navigateur. Ce convertisseur le fait — vérifiez zéro requête réseau dans les DevTools — donc il est sûr pour de vrais secrets, contrairement aux convertisseurs côté serveur ou adossés à une API.

Valider le JSON avant de l'utiliser en aval

Après conversion, passez le JSON dans le Formateur JSON pour confirmer la structure avant de l'alimenter dans un validateur de schéma, un import de gestionnaire de secrets ou un chargeur de config, afin qu'une surprise structurelle apparaisse tôt.

Questions fréquentes