Conversor de JSON a .env

¿Qué es un archivo .env?

// Generate .env lines from a JSON object in Node.js
const config = {
  DATABASE_URL: 'postgres://user:pass@localhost:5432/mydb',
  PORT: 8080,
  DEBUG: true,
  NOTE: 'value with spaces',
};

const needsQuotes = (s) => /[\s#"'\n]/.test(s);

const env = Object.entries(config)
  .map(([key, value]) => {
    if (typeof value === 'string') {
      return needsQuotes(value)
        ? `${key}=${JSON.stringify(value)}`
        : `${key}=${value}`;
    }
    return `${key}=${value ?? ''}`; // null -> empty value
  })
  .join('\n');

console.log(env);
// DATABASE_URL=postgres://user:pass@localhost:5432/mydb
// PORT=8080
// DEBUG=true
// NOTE="value with spaces"

Características clave

Ejemplos

{
  "DATABASE_URL": "postgres://user:pass@localhost:5432/mydb",
  "PORT": 8080,
  "DEBUG": true,
  "LOG_LEVEL": "info",
  "API_KEY": "sk_live_abc123"
}

DATABASE_URL=postgres://user:pass@localhost:5432/mydb
PORT=8080
DEBUG=true
LOG_LEVEL=info
API_KEY=sk_live_abc123

{
  "GREETING": "Hello, World",
  "MOTD": "line one\nline two",
  "COLOR": "#ff0000",
  "NOTE": "value with # hash",
  "EMPTY": null
}

GREETING="Hello, World"
MOTD="line one\nline two"
COLOR="#ff0000"
NOTE="value with # hash"
EMPTY=

{
  "databaseUrl": "postgres://localhost/mydb",
  "poolSize": 10,
  "enable-signup": true
}

DATABASE_URL=postgres://localhost/mydb
POOL_SIZE=10
ENABLE_SIGNUP=true

{
  "APP_NAME": "my-app",
  "FEATURES": { "signup": true, "beta": false },
  "REGIONS": ["us-east-1", "eu-west-1"]
}

APP_NAME=my-app
FEATURES="{\"signup\":true,\"beta\":false}"
REGIONS="[\"us-east-1\",\"eu-west-1\"]"

Cómo usar

1. 1

   Pega tu objeto JSON

   Introduce o pega un objeto JSON plano en el campo de entrada de arriba. También puedes pulsar 'Cargar ejemplo' para probar un objeto de configuración, valores que necesitan comillas o un objeto anidado.

2. 2

   Mira la salida .env en vivo

   El archivo .env aparece al instante en el panel de salida. Activa 'Normalizar claves' para nombres en UPPER_SNAKE_CASE, o 'Añadir prefijo export' si el archivo se va a cargar con source en un shell.

3. 3

   Copia o descarga

   Pulsa Copiar para llevar el .env al portapapeles, o Descargar para guardarlo como archivo .env, listo para colocar en tu proyecto y cargar con dotenv.

Errores comunes de JSON

["a", "b", "c"]

{"ITEMS": "a,b,c"}

{'PORT': 8080,}

{"PORT": 8080}

{"DB": {"host": "localhost", "port": 5432}}

{"DB_HOST": "localhost", "DB_PORT": 5432}

{"2fa-enabled": true}

{"TWO_FA_ENABLED": true}

{"MSG": Hello World}

{"MSG": "Hello World"}

Casos de uso comunes

Generar .env a partir de una exportación de configuración

Toma una exportación de configuración JSON de una API, un panel de ajustes o un gestor de secretos y conviértela en un archivo .env listo para usar en desarrollo local o un contenedor.

Crear plantillas .env

Construye un objeto JSON que describa las variables que necesita un nuevo servicio, conviértelo a un .env y confirma un .env.example para que tus compañeros sepan exactamente qué claves rellenar.

Conectar herramientas configuradas con JSON a dotenv

Algunas herramientas emiten configuración como JSON mientras que tu entorno de ejecución espera un .env. Convierte la salida JSON al formato dotenv para que ambas mitades del flujo coincidan en las mismas variables.

Producir archivos env de shell cargables con source

Activa el prefijo export para generar un archivo que puedas cargar directamente con source en un shell o un paso de CI, convirtiendo un bloque de configuración JSON en variables de entorno exportadas en un solo pegado.

Configuración de ida y vuelta

Combina esto con el Conversor de .env a JSON para editar la configuración como JSON estructurado y volver a escribirla en .env: el entrecomillado seguro para idas y vueltas garantiza que los valores sobreviven en ambas direcciones.

Normalizar claves de mayúsculas y minúsculas mixtas

Convierte un objeto JSON con claves en camelCase o kebab-case en un .env con nombres de variable coherentes en UPPER_SNAKE_CASE usando la opción Normalizar claves, coincidiendo con las convenciones de variables de entorno.

Detalles técnicos

Entrada solo de objeto con serialización tipada

La entrada se analiza con el JSON.parse() nativo del navegador y debe ser un objeto de nivel superior; los arreglos y escalares se rechazan con un error claro. Cada propiedad de nivel superior se serializa según su tipo: los números y booleanos se escriben sin comillas, null se convierte en un valor vacío (CLAVE=), y las cadenas se escriben directamente salvo que contengan un espacio, salto de línea, # o comilla, en cuyo caso se ponen entre comillas dobles y se escapan para la seguridad en idas y vueltas.

Valores anidados y normalización de claves

Los objetos y arreglos anidados se serializan con un JSON.stringify compacto, se ponen entre comillas dobles y se escapan, con una advertencia que nombra las claves aplanadas. El paso opcional Normalizar claves convierte las claves a UPPER_SNAKE_CASE, resolviendo la mayoría de nombres no válidos; cuando las claves se mantienen textualmente, cualquier clave que no coincida con [A-Za-z_][A-Za-z0-9_]* dispara una advertencia de nombre no válido. Se puede añadir un prefijo export opcional a cada línea.

Basado en el navegador: sin subidas, sin servidor

Todo el procesamiento ocurre por completo en el motor JavaScript de tu navegador; ningún dato JSON se transmite por la red en ningún momento. El serializador está escrito internamente sin dependencias externas, ya que la biblioteca Node dotenv no es segura para el navegador. Las entradas mayores de 200 KB cambian del modo en vivo al modo manual (un clic explícito en Convertir) para mantener el navegador receptivo.

Buenas prácticas

Mantén las claves textualmente salvo que necesites convenciones env

Deja Normalizar claves desactivado cuando la aplicación consumidora ya espera los nombres de clave exactos de tu JSON, para que nada se renombre inesperadamente. Actívalo solo cuando quieras específicamente la convención UPPER_SNAKE_CASE que las variables de entorno usan por convención.

Aplana el anidamiento de forma intencionada, no accidental

Un valor anidado se convierte en una cadena JSON opaca en el .env, que la mayoría de aplicaciones no pueden analizar de vuelta automáticamente. Cuando veas la advertencia de aplanamiento, es preferible reorganizar el JSON en claves planas con prefijo (DB_HOST, DB_PORT) antes de convertir, o elegir un formato estructurado como YAML.

Confía en el entrecomillado automático para las idas y vueltas

Deja que la herramienta decida cuándo entrecomillar: pone entre comillas dobles y escapa solo los valores que lo necesitan. Esto mantiene el .env legible al tiempo que garantiza que los valores con espacios, saltos de línea o # sobrevivan sin cambios a una ida y vuelta de regreso por el Conversor de .env a JSON.

Genera secretos solo en una herramienta exclusiva del navegador

El JSON que conviertes aquí es en la práctica un conjunto de credenciales. Genera un .env solo en una herramienta que se ejecute por completo en el navegador; verifica cero peticiones de red en las DevTools. Este conversor cumple, a diferencia de los generadores del lado del servidor o respaldados por API.

Valida primero la entrada JSON

Si el JSON está escrito a mano o ensamblado por un script, valídalo primero con el Formateador JSON para detectar comas finales o claves sin comillas, así obtienes un .env limpio en lugar de un confuso error de análisis.

Preguntas frecuentes