Skip to content

Convertidor JSON a YAML

Convierte JSON a YAML al instante en tu navegador. Listo para K8s y Compose, sangría 2/4 espacios, protección Norway automática. 100% privado, sin carga.

Sin rastreo Se ejecuta en el navegador Gratis
Opciones · 2 espacios · auto · bloque
Sangría
Estilo
0 caracteres
YAML Salida
0 líneas
Revisado para conformidad RFC 8259, salida conforme a la especificación YAML 1.2 y corrección en el manejo del problema Norway — Go Tools Engineering Team · May 4, 2026

¿Qué es YAML y por qué convertir desde JSON?

YAML (YAML Ain't Markup Language) es un formato de serialización de datos legible por humanos diseñado para archivos de configuración, infraestructura como código y cualquier lugar donde un humano escribe datos que una máquina va a leer. Su sintaxis basada en sangría no requiere llaves ni corchetes, lo que lo hace mucho más legible que JSON para estructuras anidadas complejas. Kubernetes, Helm, Ansible, Docker Compose, GitHub Actions, CircleCI y prácticamente todas las herramientas nativas de la nube usan YAML como su formato de configuración principal. Por lo tanto, convertir JSON a YAML es una de las tareas más comunes en DevOps y desarrollo backend — recibes una definición de recurso de una API en JSON y necesitas un manifiesto YAML para confirmar en el control de versiones.

Esta herramienta tiene cuatro diferenciadores importantes en comparación con los conversores online típicos:

**1. Problema Norway — Entrecomillado Automático Seguro.** El mayor riesgo en la conversión de JSON a YAML es el problema Norway de YAML. En YAML 1.1 (que millones de parsers en producción aún usan, incluidos Kubernetes antiguo, PyYAML, Ansible y Psych de Ruby), las cadenas simples yes, no, on, off, y y n se interpretan como valores booleanos true/false. Esto afectó de forma famosa al código ISO del país Noruega ("NO" → false) y ha causado interrupciones reales en producción en configuraciones de Kubernetes. YAML 1.2 corrigió esto, pero es posible que tus parsers no estén en 1.2. El modo Auto de comillas predeterminado de esta herramienta usa la librería eemeli/yaml con el esquema YAML 1.1, por lo que envuelve automáticamente cualquier cadena con el problema Norway entre comillas, garantizando conversiones seguras tanto por parsers YAML 1.1 como 1.2. Aprende más en nuestro artículo complementario en El problema Norway de YAML y las diferencias JSON-YAML.

**2. Preservación del orden de las claves.** A diferencia de algunos conversores que ordenan las claves alfabéticamente, esta herramienta preserva el orden de inserción original de las claves de tu JSON — coincidiendo con el comportamiento de JSON.parse() en todos los motores JavaScript modernos. Esto importa para los manifiestos de Kubernetes (donde apiVersion y kind se esperan primero por convención), las especificaciones OpenAPI (donde info aparece antes que paths) y cualquier configuración donde el orden de los campos sea significativo para la legibilidad o las diferencias.

**3. Advertencia de Precisión de Números Grandes.** Los números JSON mayores que 2^53 - 1 (9007199254740991) no pueden representarse exactamente en el float de doble precisión IEEE 754 de JavaScript. Cuando JSON.parse() lee un entero grande como un campo resourceVersion de Kubernetes (que es un entero de 64 bits en el servidor), lo trunca silenciosamente. Esta es una limitación fundamental del JavaScript del navegador que afecta a todas las herramientas JSON basadas en navegador, incluida esta. La solución segura es asegurarte de que los enteros grandes se almacenen como cadenas en tu JSON antes de convertir. Esta herramienta documenta este comportamiento honestamente en el error común de Pérdida de Precisión de Números a continuación.

**4. Privacidad 100% Basada en el Navegador.** Tus datos JSON — que a menudo contienen claves de API, credenciales de bases de datos, configuraciones de servicios internos y secretos de producción — nunca salen de tu navegador. No se envían datos a ningún servidor. Puedes verificarlo en la pestaña Red de tu navegador. Esta es la única forma segura de manejar datos de configuración sensibles en una herramienta online. Consulta nuestra herramienta complementaria para la dirección inversa en Convertidor YAML a JSON, y nuestro Formateador JSON si necesitas validar y embellecer JSON antes de convertir.

La naturaleza legible por humanos de YAML viene con una compensación: tiene más casos límite de análisis que JSON. Más allá del problema Norway, YAML tiene peculiaridades con números octales (0777 se interpreta como 511 en YAML 1.1), sintaxis de cadenas multilínea (| para literal, > para plegado), referencias de ancla y alias (&ancla y *alias) y soporte para múltiples documentos (separador ---). JSON no tiene ninguna de estas complejidades — es un formato estricto y mínimo con solo seis tipos de datos. Para el intercambio de datos entre máquinas, JSON es casi siempre la mejor opción. Para archivos de configuración editados por humanos donde importan la legibilidad y los comentarios, YAML gana. Este conversor te da lo mejor de ambos mundos: usa JSON programáticamente, convierte a YAML para tu infraestructura.

// Convert JSON to YAML in Node.js using the eemeli/yaml library
import { Document } from 'yaml';

const data = JSON.parse('{"apiVersion":"apps/v1","kind":"Deployment"}');

// version: '1.1' ensures Norway-problem strings (yes/no/on/off/y/n)
// are automatically quoted in the output for YAML 1.1 parser safety
const doc = new Document(data, { version: '1.1' });

const yamlString = doc.toString({
  indent: 2,
  lineWidth: 0,         // disable line wrapping
  defaultStringType: 'PLAIN',   // Auto mode: only quote when needed
});

console.log(yamlString);
// apiVersion: apps/v1
// kind: Deployment

Características principales

Conversión en vivo

La salida YAML se actualiza al instante mientras escribes o pegas JSON — no se necesita botón Convertir. Las entradas grandes (>200 KB) cambian automáticamente al modo manual para mantener el navegador con capacidad de respuesta.

Sangría de 2 o 4 espacios

Cambia entre sangría de 2 espacios (estándar para Kubernetes, Docker Compose y GitHub Actions) y 4 espacios (convención de Ansible). Las tabulaciones están prohibidas en YAML — esta herramienta siempre usa espacios.

Entrecomillado automático seguro (protección Norway)

El modo Auto predeterminado usa el esquema YAML 1.1 para entrecomillar automáticamente cadenas como "no", "yes", "on", "off", "y" y "n" que serían leídas incorrectamente como booleanos por los parsers YAML 1.1, evitando configuraciones incorrectas en producción.

Estilos Bloque y Flujo

El estilo Bloque produce YAML con sangría, legible por humanos, ideal para manifiestos y archivos de configuración. El estilo Flujo produce YAML compacto en línea similar a JSON — útil para fragmentos de documentación o herramientas que prefieren una salida mínima.

Privacidad 100% en el navegador

Toda la conversión se ejecuta localmente en tu navegador usando JavaScript. Tus datos JSON — incluidas claves de API, credenciales y configuraciones de producción — nunca se envían a ningún servidor, nunca se registran y nunca se almacenan.

Compatible con K8s, Compose y Terraform

Optimizado para casos de uso reales de DevOps: manifiestos de Kubernetes, stacks de Docker Compose, valores de charts Helm, workflows de GitHub Actions, especificaciones OpenAPI y salidas de planes JSON de Terraform — con ejemplos para cada uno.

Ejemplos

Deployment de Kubernetes

{"apiVersion":"apps/v1","kind":"Deployment","metadata":{"name":"my-app","namespace":"production","labels":{"app":"my-app","version":"1.0.0"}},"spec":{"replicas":3,"selector":{"matchLabels":{"app":"my-app"}},"template":{"metadata":{"labels":{"app":"my-app"}},"spec":{"containers":[{"name":"my-app","image":"my-app:1.0.0","ports":[{"containerPort":8080}],"resources":{"requests":{"memory":"64Mi","cpu":"250m"},"limits":{"memory":"128Mi","cpu":"500m"}}}]}}}}

Convierte un manifiesto de Deployment de Kubernetes del formato de respuesta JSON de la API a YAML para aplicarlo con kubectl apply -f

Docker Compose

{"version":"3.9","services":{"web":{"image":"nginx:1.25-alpine","ports":["80:80","443:443"],"environment":{"NGINX_HOST":"example.com","NGINX_PORT":"80"},"depends_on":["db"],"restart":"unless-stopped"},"db":{"image":"postgres:16-alpine","environment":{"POSTGRES_DB":"mydb","POSTGRES_USER":"admin","POSTGRES_PASSWORD":"secret"},"volumes":["pgdata:/var/lib/postgresql/data"]}},"volumes":{"pgdata":{}}}

Convierte una definición de servicio de Docker Compose de JSON al formato YAML requerido por docker compose up

Workflow de GitHub Actions

{"name":"CI","on":{"push":{"branches":["main"]},"pull_request":{"branches":["main"]}},"jobs":{"build":{"runs-on":"ubuntu-latest","steps":[{"uses":"actions/checkout@v4"},{"name":"Set up Node.js","uses":"actions/setup-node@v4","with":{"node-version":"20","cache":"pnpm"}},{"name":"Install dependencies","run":"pnpm install --frozen-lockfile"},{"name":"Run tests","run":"pnpm test"}]}}}

Convierte una definición de workflow de CI de GitHub Actions de JSON a YAML para confirmar en .github/workflows/

Especificación OpenAPI

{"openapi":"3.0.3","info":{"title":"User API","version":"1.0.0","description":"Manage application users"},"paths":{"/users":{"get":{"summary":"List users","operationId":"listUsers","parameters":[{"name":"limit","in":"query","schema":{"type":"integer","default":20}}],"responses":{"200":{"description":"Success","content":{"application/json":{"schema":{"type":"array","items":{"$ref":"#/components/schemas/User"}}}}}}}},"/users/{id}":{"get":{"summary":"Get user","operationId":"getUser","parameters":[{"name":"id","in":"path","required":true,"schema":{"type":"string"}}],"responses":{"200":{"description":"Success"}}}}},"components":{"schemas":{"User":{"type":"object","properties":{"id":{"type":"string"},"name":{"type":"string"},"email":{"type":"string","format":"email"}}}}}}

Convierte una especificación OpenAPI 3.0 de JSON a YAML — el formato preferido por Swagger UI, Redoc y la mayoría de herramientas de API

package.json

{"name":"my-app","version":"1.0.0","description":"A sample Node.js application","private":true,"scripts":{"dev":"vite","build":"tsc && vite build","preview":"vite preview","test":"vitest","lint":"eslint . --ext .ts,.tsx"},"dependencies":{"react":"^18.3.0","react-dom":"^18.3.0"},"devDependencies":{"typescript":"^5.4.0","vite":"^5.2.0","vitest":"^1.5.0","eslint":"^8.57.0","@types/react":"^18.3.0"},"engines":{"node":">=20.0.0","pnpm":">=9.0.0"}}

Convierte un package.json típico de Node.js a YAML — útil para migrar la configuración del proyecto a herramientas que prefieren YAML

Plan JSON de Terraform

{"format_version":"1.0","terraform_version":"1.7.4","variables":{"region":{"value":"us-east-1"}},"planned_values":{"root_module":{"resources":[{"address":"aws_s3_bucket.main","mode":"managed","type":"aws_s3_bucket","name":"main","values":{"bucket":"my-app-assets","force_destroy":false,"tags":{"Environment":"production","ManagedBy":"terraform"}}}]}},"resource_changes":[{"address":"aws_s3_bucket.main","mode":"managed","type":"aws_s3_bucket","name":"main","change":{"actions":["create"],"before":null,"after":{"bucket":"my-app-assets","force_destroy":false}}}]}

Convierte la salida del plan JSON de Terraform a YAML para revisión humana, auditorías GitOps y pipelines de CI/CD — una diferenciación que la mayoría de conversores omiten

Cómo usar

  1. 1

    Pega tu JSON

    Introduce o pega tus datos JSON en el campo de entrada de arriba. También puedes hacer clic en 'Cargar ejemplo' para probar un ejemplo como un Deployment de Kubernetes, un archivo de Docker Compose o un plan de Terraform.

  2. 2

    Observa la salida YAML en vivo

    El YAML aparece instantáneamente en el panel de salida. Ajusta las Opciones (sangría 2/4, comillas Auto/Dobles/Simples, estilo Bloque/Flujo) para cumplir los requisitos de tu herramienta de destino.

  3. 3

    Copia o Descarga

    Haz clic en Copiar para llevar el YAML al portapapeles, o en Descargar para guardarlo como archivo .yaml listo para kubectl apply, docker compose up o cualquier otra herramienta.

Errores comunes de conversión

Comas finales

JSON no permite una coma después del último elemento en un objeto o array. Esto es muy común al copiar desde código JavaScript, que sí permite comas finales. Elimina la coma final antes de convertir.

✗ Incorrecto 
{"name": "Alice", "role": "admin",}
✓ Correcto 
{"name": "Alice", "role": "admin"}

Comillas simples

JSON requiere comillas dobles para todos los valores de cadena y claves de objeto. Las comillas simples son válidas en JavaScript y Python, pero son un error de sintaxis en JSON.

✗ Incorrecto 
{'name': 'Alice', 'active': true}
✓ Correcto 
{"name": "Alice", "active": true}

Claves sin comillas

Todas las claves de objetos JSON deben ir entre comillas dobles. Las claves sin comillas son válidas en los literales de objetos de JavaScript, pero causarán un error de análisis en JSON estricto.

✗ Incorrecto 
{name: "Alice", role: "admin"}
✓ Correcto 
{"name": "Alice", "role": "admin"}

Comentarios no permitidos

El JSON estándar no admite comentarios de ningún tipo — ni //, /* */, ni #. Si necesitas comentarios en la configuración, usa YAML (que admite comentarios con #) o JSONC (JSON con comentarios, utilizado por VS Code). Elimina todos los comentarios antes de usar los datos como JSON.

✗ Incorrecto 
{"port": 8080 // HTTP port}
✓ Correcto 
{"port": 8080}

Problema Norway de YAML (gestionado automáticamente en modo Auto)

En los parsers YAML 1.1 (usados por Kubernetes, Ansible, PyYAML, Ruby Psych), las cadenas simples yes, no, on, off, y y n se interpretan como booleanos true/false en lugar de cadenas. El modo Auto de esta herramienta entrecomilla automáticamente estos valores en la salida YAML para garantizar conversiones seguras a través de cualquier parser YAML 1.1 o 1.2. Si seleccionas el modo de comillas Dobles o Simples, todas las cadenas se entrecomillan explícitamente, lo que también evita el problema — pero el modo Auto es la salida de aspecto más natural.

✗ Incorrecto 
# JSON input: {"country": "no", "enabled": "yes"}
# YAML without quoting (dangerous):
country: no
enabled: yes
# YAML 1.1 parser reads: country=false, enabled=true
✓ Correcto 
# YAML with Auto quoting (safe):
country: 'no'
enabled: 'yes'
# YAML 1.1 parser reads: country="no", enabled="yes"

Pérdida de precisión en enteros grandes

JavaScript solo puede representar enteros exactamente hasta 2^53 - 1 (9007199254740991). Los enteros JSON mayores que esto — como los campos resourceVersion de Kubernetes (que son int64 en el servidor) — se redondean silenciosamente cuando JSON.parse() los analiza. Este número truncado aparece luego en la salida YAML. Esta es una limitación fundamental del JavaScript del navegador que afecta a todas las herramientas JSON basadas en navegador. La solución segura es almacenar los enteros grandes como cadenas en tu JSON antes de convertir.

✗ Incorrecto 
// JSON input (resourceVersion is int64 on K8s server)
{"resourceVersion": 9007199254740993}
// JavaScript reads it as: 9007199254740992 (precision lost)
// YAML output will contain the wrong number
✓ Correcto 
// Store large integers as strings to preserve precision
{"resourceVersion": "9007199254740993"}
// YAML output: resourceVersion: '9007199254740993' (exact)

Casos de uso comunes

Manifiestos de Kubernetes
Convierte respuestas JSON de la API de kubectl get -o json o la API de Kubernetes en manifiestos YAML para flujos de trabajo GitOps, superposiciones de Kustomize y despliegues con kubectl apply -f.
Archivos de Docker Compose
Transforma la salida JSON de docker inspect o configuraciones de servicios generadas programáticamente en archivos docker-compose.yaml compatibles con docker compose up y despliegues de Docker Stack.
Valores de Charts Helm
Convierte exportaciones de configuración JSON en archivos de valores YAML para despliegues de charts Helm, habilitando la configuración de infraestructura versionada con sintaxis YAML limpia.
Workflows de GitHub Actions
Construye definiciones de workflows de GitHub Actions programáticamente en JSON y conviértelas al formato .github/workflows/*.yaml requerido por el runner de GitHub Actions.
Especificaciones OpenAPI
Convierte especificaciones OpenAPI/Swagger del formato JSON devuelto por muchos frameworks (FastAPI, SpringDoc) al formato YAML preferido por Swagger UI, Redoc y herramientas de API gateway.
Migración de configuración
Migra la configuración de aplicaciones almacenada en JSON (appsettings.json, config.json) al formato YAML para herramientas que requieren o prefieren YAML, añadiendo la posibilidad de usar comentarios como documentación.

Detalles técnicos

Análisis JSON conforme a RFC 8259
La entrada JSON se analiza usando el JSON.parse() nativo del navegador, que es completamente conforme a RFC 8259. Esto proporciona mensajes de error de sintaxis precisos incluyendo información de posición (números de línea y columna aproximados) y maneja todos los tipos de datos JSON: cadenas, números, booleanos, null, arrays y objetos.
Salida YAML 1.2 mediante la API Document de eemeli/yaml con esquema YAML 1.1
El YAML se genera usando la librería eemeli/yaml (v2.8+, segura frente a CVE) a través de su API Document con version: '1.1'. Esta combinación produce una salida conforme a YAML 1.2 mientras aplica las reglas de entrecomillado de YAML 1.1 — lo que significa que las cadenas con el problema Norway (yes/no/on/off/y/n) se entrecomillan automáticamente en la salida, haciéndola segura tanto para parsers YAML 1.1 como 1.2. El ajuste de líneas está desactivado (lineWidth: 0) para preservar las cadenas largas intactas.
100% en el navegador — Sin carga, Sin servidor
Todo el procesamiento ocurre completamente en el motor JavaScript de tu navegador. No se transmiten datos por la red en ningún momento. Las entradas mayores de 200 KB cambian automáticamente del modo en vivo al modo manual (requiriendo un clic explícito en Convertir) para mantener el navegador con capacidad de respuesta y evitar el bloqueo del hilo principal durante la serialización intensiva.

Buenas prácticas

Usa siempre el modo Auto de comillas para configuraciones DevOps
Al convertir JSON para usar en Kubernetes, Helm, Ansible, Docker Compose o GitHub Actions, usa siempre el modo de comillas Auto predeterminado (seguro para Norway). Los parsers YAML 1.1 en estas herramientas interpretarán silenciosamente incorrectamente las cadenas simples yes, no, on, off, y y n como booleanos — el modo Auto lo evita de forma transparente.
Usa sangría de 2 espacios para herramientas nativas de la nube
Kubernetes, Docker Compose, GitHub Actions y Helm usan todos sangría de 2 espacios por convención. Usar sangría de 4 espacios en estos archivos es YAML válido, pero creará inconsistencias con los ejemplos de la comunidad, las configuraciones generadas automáticamente y los manifiestos existentes de tu equipo.
Almacena los enteros grandes como cadenas antes de convertir
Los campos resourceVersion, uid y otros campos int64 de Kubernetes del servidor de API pueden exceder el rango de enteros seguros de JavaScript (2^53 - 1). Si necesitas precisión numérica exacta, almacena estos valores como cadenas JSON antes de convertir. Esto es especialmente importante para la salida de kubectl get -o json que incluye campos generados en el lado del servidor.
Valida el JSON primero
Si tu fuente JSON está escrita a mano o proviene de un sistema que ocasionalmente produce salidas inválidas (comas finales, claves sin comillas, comentarios), valídalo con un formateador JSON antes de convertir. Usa nuestro Formateador JSON para detectar y corregir errores de sintaxis primero, luego convierte el JSON limpio a YAML.
Prefiere el estilo Bloque para archivos que van al control de versiones
El YAML de estilo Bloque produce diferencias limpias y legibles por humanos en Git porque cada campo aparece en su propia línea. El estilo Flujo (compacto, en línea) hace que las diferencias sean más difíciles de leer y revisar. Reserva el estilo Flujo para incrustar fragmentos YAML cortos en documentación o para herramientas que requieran una salida compacta.

Preguntas frecuentes

¿Cómo convierto JSON a YAML online?
Pega tu JSON en el campo de entrada de arriba. La herramienta lo convierte a YAML al instante en tu navegador — sin necesidad de hacer clic en ningún botón. Puedes ajustar la sangría (2 o 4 espacios), el estilo de comillas (Auto, Dobles o Simples) y el estilo de salida (Bloque o Flujo) desde el panel de Opciones. Una vez que el YAML aparezca en el área de salida, haz clic en Copiar para llevarlo al portapapeles o en Descargar para guardarlo como archivo .yaml. Todo se ejecuta localmente — tus datos nunca salen de tu dispositivo.
¿Qué es el problema Norway de YAML y cómo lo gestiona esta herramienta?
El problema Norway de YAML hace referencia a una peculiaridad de la especificación YAML 1.1 donde cadenas simples como "no", "yes", "on", "off", "y" y "n" se interpretan como valores booleanos (false/true) en lugar de cadenas. Esto causó un famoso problema real donde el código ISO del país Noruega ("NO") era leído como el booleano false en playbooks de Ansible y configuraciones de Kubernetes. En YAML 1.2 esto se corrigió — las cadenas simples siempre son cadenas. Sin embargo, millones de parsers en producción (versiones antiguas de Kubernetes, PyYAML, Ansible, Psych de Ruby) aún usan YAML 1.1. El modo Auto de esta herramienta (el predeterminado) envuelve automáticamente cualquier cadena problemática entre comillas para que se procesen correctamente tanto por parsers YAML 1.1 como 1.2. Cuando se detectan cadenas con el problema Norway en tu entrada, un aviso lista exactamente qué valores fueron entrecomillados automáticamente.
¿Por qué importa el problema Norway para Kubernetes y DevOps?
Los manifiestos YAML de Kubernetes, los valores de charts Helm, los playbooks de Ansible y los workflows de GitHub Actions son parseados por herramientas que históricamente usaban YAML 1.1. Si tienes una clave de configuración con el valor "no" (por ejemplo, un código de país, un indicador de habilitación en forma de cadena, o un campo personalizado similar a booleano), un parser YAML 1.1 lo convertirá silenciosamente al booleano false. Esto puede causar configuraciones incorrectas del servicio extremadamente difíciles de depurar porque el YAML parece correcto cuando se visualiza como texto pero se comporta de forma diferente al parsearse. Usa siempre el modo Auto de comillas cuando conviertas JSON para usarlo en Kubernetes o cualquier cadena de herramientas DevOps para garantizar conversiones seguras.
¿Debo usar sangría de 2 o 4 espacios para YAML?
Usa sangría de 2 espacios para manifiestos de Kubernetes, valores de Helm, archivos de Docker Compose y workflows de GitHub Actions — estas herramientas están diseñadas con YAML de 2 espacios y es la convención de la comunidad. Usa sangría de 4 espacios para playbooks de Ansible (que siguen una convención de 4 espacios) y cuando tu equipo u organización tenga una guía de estilo que lo requiera. YAML prohíbe completamente las tabulaciones — toda la sangría debe ser con espacios. Esta herramienta usa 2 espacios por defecto, que es la elección correcta para la gran mayoría de casos de uso nativos en la nube.
¿Cómo uso esta herramienta para crear un manifiesto de Kubernetes?
Si tienes una definición de recurso de Kubernetes en JSON (de kubectl get deployment my-app -o json, una respuesta de API o un bloque de recurso de Terraform), pégala en el campo de entrada. Selecciona la sangría de 2 espacios (predeterminada) y comillas Auto (predeterminada, que gestiona el problema Norway). El resultado YAML está inmediatamente listo para kubectl apply -f. También puedes hacer clic en Descargar para guardar el archivo con extensión .yaml y conectarlo directamente a kubectl apply -f -. El ejemplo de Deployment de K8s de arriba muestra un manifiesto de deployment completo que puedes cargar y modificar.
¿Cómo convierto un JSON de Docker Compose a YAML?
Pega tu JSON de Docker Compose en el campo de entrada. Usa sangría de 2 espacios (convención de Docker Compose) y estilo Bloque. El YAML resultante es compatible con docker compose up, docker compose config y Docker Stack. Un escenario habitual es exportar la configuración de un stack en ejecución con docker inspect y luego convertirla de vuelta a un archivo compose.yaml. El ejemplo de Docker Compose de arriba incluye definiciones de servicios con puertos, variables de entorno, volúmenes y depends_on.
¿Pueden los números JSON mayores que 2^53 perder precisión al convertirse a YAML?
Sí. Esta es una limitación fundamental de JavaScript: el float de doble precisión IEEE 754 utilizado por el tipo Number de JavaScript solo puede representar enteros exactamente hasta 2^53 - 1 (9007199254740991). Cualquier entero más allá de eso — como los campos resourceVersion de Kubernetes (que son int64 en el servidor) — será redondeado silenciosamente cuando JSON.parse() los analice. Por ejemplo, el valor 9007199254740993 se convierte en 9007199254740992 en JavaScript, y ese número truncado aparecerá en tu salida YAML. Esto afecta a todas las herramientas JSON basadas en navegador, no solo a esta. La solución segura es almacenar los enteros grandes como cadenas en tu JSON ("resourceVersion": "9007199254740993") — aparecerán como cadenas YAML sin ninguna pérdida de precisión.
¿El conversor preserva el orden original de las claves de mi JSON?
Sí. La librería eemeli/yaml utilizada por esta herramienta preserva el orden de inserción, que coincide con el comportamiento de JSON.parse() en todos los motores JavaScript modernos (V8, SpiderMonkey, JavaScriptCore). Las claves aparecen en la salida YAML en el mismo orden en que aparecían en la entrada JSON. Esto es importante para los manifiestos de Kubernetes y las especificaciones OpenAPI donde el orden de los campos suele ser significativo para la legibilidad y las diferencias.
¿Cuándo debo usar JSON frente a YAML?
Usa JSON cuando: estés construyendo APIs y servicios web (JSON es el formato universal de intercambio), cuando la velocidad de análisis por máquinas importe, cuando necesites seguridad de tipos estricta, o cuando el consumidor sea una aplicación JavaScript/TypeScript. Usa YAML cuando: escribas archivos de configuración destinados a la edición humana (manifiestos de Kubernetes, pipelines de CI/CD, playbooks de Ansible, valores de Helm), cuando quieras comentarios en tu configuración, o cuando la legibilidad sea más importante que la estrictez. Una regla útil: si una máquina lo escribe o lo lee primero, usa JSON; si un humano lo escribe y una máquina lo lee, usa YAML.
¿Cómo puedo convertir JSON a YAML en la línea de comandos?
El enfoque más popular es combinar yq y jq. Instala yq (la versión de Mike Farah, no la de Python): brew install yq en macOS o wget https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 -O /usr/local/bin/yq para Linux. Luego ejecuta: cat input.json | yq -P para imprimir en formato YAML. Alternativamente: yq -o yaml input.json o cat input.json | python3 -c "import sys, json, yaml; yaml.dump(json.load(sys.stdin), sys.stdout, default_flow_style=False)". Para Kubernetes específicamente: kubectl get deployment my-app -o yaml convierte directamente desde la API del clúster.
¿Cómo convierto JSON a YAML en Python, Node.js o Go?
En Python: import json, yaml; yaml.dump(json.load(open('input.json')), open('output.yaml', 'w'), default_flow_style=False) usando PyYAML, o ruamel.yaml para mayor fidelidad en conversiones de ida y vuelta. En Node.js: import { Document } from 'yaml'; const doc = new Document(JSON.parse(input), { version: '1.1' }); const result = doc.toString({ indent: 2, lineWidth: 0 }) — esta es la misma librería y enfoque utilizados por esta herramienta. En Go: import gopkg.in/yaml.v3; json.Unmarshal(jsonBytes, &data); yaml.Marshal(data) — nota que Go YAML v3 usa YAML 1.1 por defecto, por lo que las cadenas con el problema Norway serán entrecomilladas automáticamente.
¿Se envían mis datos JSON a algún servidor cuando uso esta herramienta?
No. Toda la conversión ocurre completamente en tu navegador usando JavaScript. Tus datos JSON nunca se transmiten por la red, nunca se almacenan en ningún servidor, y nunca se registran ni analizan. Esto hace que la herramienta sea segura para usar con claves de API, credenciales de bases de datos, archivos de configuración internos, manifiestos de producción de Kubernetes y cualquier otro dato sensible. Puedes verificarlo abriendo la pestaña Red de tu navegador — verás cero solicitudes generadas al pegar JSON.
¿Existe un límite de tamaño de archivo para la entrada JSON?
No hay un límite de tamaño de archivo estricto, pero las entradas grandes (más de 200 KB) cambian automáticamente del modo en vivo al modo manual. En el modo manual, aparece un botón Convertir y la conversión se ejecuta solo cuando lo haces clic — esto evita que el hilo principal del navegador se bloquee durante 200-500 ms en cada pulsación de tecla. Para archivos JSON muy grandes (varios megabytes), considera usar herramientas de línea de comandos como yq o jq para mejor rendimiento. La herramienta gestiona eficientemente cargas de trabajo reales típicas como exportaciones completas de namespaces de Kubernetes, grandes especificaciones OpenAPI y archivos de Docker Compose con múltiples servicios.

Herramientas relacionadas

Ver todas las herramientas →

Decodificador y Codificador Base64

Codificación y Formato

Decodifica y codifica Base64 online de forma gratuita. Conversión en tiempo real con soporte completo de UTF-8 y emojis. 100% privado — funciona en tu navegador. Sin registro.

Formateador y Validador JSON

Codificación y Formato

Formatea, valida y embellece JSON al instante en tu navegador. Herramienta gratuita con validación sintáctica, detección de errores, minificación y copia con un clic. 100% privado.

Codificador y Decodificador URL con Analizador Integrado

Codificación y Formato

Pega una URL para decodificarla o codificarla al instante. Analizador integrado descompone protocolo, host, ruta y parámetros en campos editables. Modos encodeURI y encodeURIComponent. 100% navegador — sin envío de datos.

Convertidor YAML a JSON

Codificación y Formato

Convierte YAML a JSON al instante en tu navegador. Compatible con manifiestos K8s, specs OpenAPI y valores Helm. Sin servidor, 100% privado.

Conversor de Bases — Binario, Hex, Decimal, Octal

Herramientas de Conversión

Convierte números entre binario, hexadecimal, decimal, octal y cualquier base personalizada (2-36) al instante. Gratis, privado, sin registro — todo el procesamiento ocurre en tu navegador.

Comprimir Imágenes Online — JPEG, PNG y WebP

Herramientas de Conversión

Reduce el tamaño de las imágenes hasta un 80% — comprime JPEG, PNG y WebP en tu navegador, sin subir archivos. Lotes de 20 imágenes, ajusta la calidad, compara antes y después. Gratis y privado.