Convertir YAML a JSON — Python, yq, navegador (evita 8 trampas)

TL;DR — elige un método en 10 segundos

• Lo necesitas ahora mismo, sin instalar nada → FormatArc YAML a JSON (en el navegador, sin subir archivos, valida mientras convierte, errores con número de línea)
• CLI / one-liner → yq -o=json '.' file.yaml (la opción por defecto en DevOps)
• Script o pipeline de Python → python3 -c 'import sys, yaml, json; json.dump(yaml.safe_load(sys.stdin), sys.stdout, indent=2)' < file.yaml
• Aplicación Node.js → js-yaml (yaml.load) + JSON.stringify
• Servicio en Go → gopkg.in/yaml.v3 + encoding/json
• Ida y vuelta en Kubernetes → kubectl get ... -o json | yq -P '.' (de vuelta a YAML)
• YAML multidocumento (separadores ---) → yq -o=json '.' file.yaml (yq lo divide por defecto) o salida NDJSON

La mayor parte de la conversión de YAML a JSON es una sola línea de código. Lo difícil son las 8 trampas (el problema de Noruega, la pérdida de comentarios, el manejo de multidocumento, la inseguridad de yaml.load, las claves enteras que se vuelven cadenas, la expansión de anclas, 1.0 que se vuelve float, las sorpresas de la inferencia de tipos) que esta guía explica con ejemplos verificados de antes y después.

¿Por qué convertir YAML a JSON?

Algunos escenarios habituales:

• Envío a la API de Kubernetes: tienes un manifiesto YAML, pero necesitas hacer un POST a través de la API de Kubernetes, que solo acepta cuerpos codificados en JSON.
• Depurar la estructura de un YAML: el anidamiento basado en la indentación de YAML a veces resulta ambiguo; convertirlo a JSON deja la estructura sin ambigüedades. Un - mal colocado o una indentación incorrecta saltan a la vista de inmediato en JSON.
• Herramientas que solo aceptan JSON: tu herramienta posterior (un parser de JSON en otro lenguaje, una base de datos que almacena JSON, un bus de eventos con un validador de JSON Schema) no acepta YAML.
• Auditoría de configuración: convierte configuraciones YAML de un repositorio a JSON para analizar diffs, validarlas contra JSON Schema o alimentar escáneres de seguridad.
• Contexto para LLMs: pasa las configuraciones a un LLM como JSON; el modelo trata los límites de los objetos JSON con más fiabilidad que la indentación de YAML, especialmente en estructuras anidadas. Consulta Markdown vs HTML para LLMs para conocer el criterio de elección de formato.

Entender las diferencias entre YAML y JSON ayuda a evitar sorpresas durante la conversión. Consulta YAML vs JSON para una comparación a fondo.

Método 1: herramienta de navegador FormatArc (sin subir archivos)

Para conversiones rápidas y puntuales sin instalar nada, el conversor de YAML a JSON es la opción más sencilla. Funciona por completo en tu navegador: ningún dato sale de tu equipo.

1. Abre la herramienta YAML a JSON.
2. Pega tu YAML en el panel izquierdo.
3. Haz clic en Convertir. La salida JSON aparece en el panel derecho.

La herramienta valida tu YAML mientras convierte. Los errores de sintaxis (indentación incorrecta, dos puntos que faltan, tabulaciones donde se esperan espacios) se notifican con número de línea, lo que la hace útil para depurar archivos YAML incluso cuando la conversión no es el objetivo principal.

La conversión en el navegador importa cuando el YAML contiene datos sensibles: Secrets de Kubernetes (sí, los datos están codificados en base64, pero siguen siendo confidenciales), credenciales de proveedores de nube en archivos vault de Ansible, configuraciones internas de CI con tokens de API. Nada sale de la pestaña.

Esto no es una preocupación teórica. En noviembre de 2025, la empresa de seguridad watchTowr descubrió que los populares sitios de formateo JSONFormatter y CodeBeautify habían expuesto más de 5 GB de datos guardados por los usuarios (incluidas credenciales, claves privadas y tokens de API) a través de una función de guardado que dejaba la entrada almacenada visible públicamente (informe de watchTowr). Una herramienta que funciona en el navegador no tiene nada que exponer porque nunca almacena ni transmite tu entrada.

Consulta ¿Son seguros los conversores de JSON en línea? para saber cómo comprobarlo antes de pegar nada.

La herramienta de navegador maneja: cadenas multilínea (tanto el estilo de escalar de bloque | como el de escalar plegado >), anclas y alias (expandidos en línea), estructuras anidadas de profundidad arbitraria, arrays de tipos mixtos, valores null, booleanos y tipos numéricos.

Método 2: yq (la opción por defecto en DevOps)

yq es un procesador de YAML por línea de comandos ligero; piensa en jq pero para YAML. Es con diferencia la herramienta más habitual para convertir YAML a JSON en pipelines de DevOps.

# Conversión básica
yq -o=json '.' input.yaml

# Tubería desde stdin
cat config.yaml | yq -o=json '.'

# Guardar en archivo
yq -o=json '.' config.yaml > config.json

# Salida compacta (una sola línea)
yq -o=json -I=0 '.' config.yaml

# Extraer un subárbol al convertir
yq -o=json '.spec.template' deployment.yaml

# Convertir y aplicar un filtro
yq -o=json '.items[] | select(.kind == "ConfigMap")' multi.yaml

Instalación:

# macOS
brew install yq

# Linux (snap)
snap install yq

# Linux (descarga del binario)
sudo wget -qO /usr/local/bin/yq https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64
sudo chmod +x /usr/local/bin/yq

# Go install
go install github.com/mikefarah/yq/v4@latest

Nota: existen dos herramientas distintas que se llaman yq. Esta guía usa el yq de Mike Farah, basado en Go (el que se usa en todo el ecosistema de Kubernetes / CNCF). El yq de Python, de kislyuk, usa una sintaxis diferente; ambos funcionan, pero la versión en Go es el estándar de facto en 2026.

yq con JSON Lines (YAML multidocumento)

# Archivo YAML multidocumento (varios documentos separados por ---)
yq -o=json '.' multi.yaml          # emite un documento JSON por cada documento de entrada
yq -o=json -I=0 '.' multi.yaml      # NDJSON (compacto, uno por línea)
yq eval-all '[.]' -o=json multi.yaml  # envuelve todos los documentos en un único array JSON

Esta es la forma más limpia de convertir archivos de Kubernetes con una "lista de recursos" en un único array JSON para operaciones por lotes contra la API.

Método 3: Python (el más flexible)

Python incluye un módulo JSON en su biblioteca estándar, y pyyaml está instalado por defecto en la mayoría de los sistemas (o mediante pip install pyyaml).

One-liner de Python

python3 -c 'import sys, yaml, json; json.dump(yaml.safe_load(sys.stdin), sys.stdout, indent=2)' < input.yaml > output.json

Esto lee YAML desde stdin, lo parsea con yaml.safe_load y escribe JSON formateado en stdout. El argumento indent=2 produce una salida legible.

Script de Python (multidocumento, manejo de errores)

import sys
import yaml
import json

with open("config.yaml") as f:
    data = yaml.safe_load(f)  # usa safe_load_all() para multidocumento

with open("config.json", "w") as f:
    json.dump(data, f, indent=2, ensure_ascii=False)

yaml.safe_load es importante: evita la ejecución arbitraria de código que yaml.load permite. Usa siempre la variante segura salvo que tengas un motivo concreto para no hacerlo (consulta la trampa n.º 4 más abajo).

Python con ruamel.yaml (preserva más estructura)

Para necesidades más avanzadas, ruamel.yaml preserva el estilo de comillas, el orden de las claves e incluso los comentarios (aunque los comentarios igualmente no pueden sobrevivir al pasar a JSON):

from ruamel.yaml import YAML
import json
import sys

yaml_parser = YAML(typ="safe")
data = yaml_parser.load(open(sys.argv[1]))
json.dump(data, sys.stdout, indent=2, ensure_ascii=False)

Para la mayoría de los casos de uso, pyyaml.safe_load es suficiente. Usa ruamel.yaml si necesitas preservar el formato de YAML en la ida y vuelta.

Método 4: Node.js (js-yaml)

El paquete js-yaml es la opción estándar para aplicaciones Node.js.

const fs = require("fs");
const yaml = require("js-yaml");

// Documento único
const doc = yaml.load(fs.readFileSync("config.yaml", "utf8"));
fs.writeFileSync("config.json", JSON.stringify(doc, null, 2));

// Multidocumento
const docs = yaml.loadAll(fs.readFileSync("multi.yaml", "utf8"));
fs.writeFileSync("multi.json", JSON.stringify(docs, null, 2));

Instalación: npm install js-yaml o yarn add js-yaml.

Para entradas YAML no confiables, usa yaml.load(text, { schema: yaml.JSON_SCHEMA }) para restringir la conversión solo a tipos compatibles con JSON. El DEFAULT_SCHEMA predeterminado incluye algunas peculiaridades de YAML 1.1, como el problema de Noruega.

Método 5: Go (gopkg.in/yaml.v3)

package main

import (
    "encoding/json"
    "fmt"
    "os"

    "gopkg.in/yaml.v3"
)

func main() {
    data, _ := os.ReadFile("config.yaml")
    var obj interface{}
    yaml.Unmarshal(data, &obj)
    result, _ := json.MarshalIndent(obj, "", "  ")
    fmt.Println(string(result))
}

yaml.v3 es la versión mantenida por go-yaml (la que usa el propio Kubernetes). Una advertencia: las claves enteras de YAML (123: foo) se convierten en cadenas en JSON, ya que JSON solo admite claves de tipo cadena (consulta la trampa n.º 5).

Para procesar archivos YAML multidocumento en streaming, usa yaml.NewDecoder en un bucle:

dec := yaml.NewDecoder(file)
for {
    var doc interface{}
    if err := dec.Decode(&doc); err != nil {
        if err == io.EOF { break }
        log.Fatal(err)
    }
    out, _ := json.Marshal(doc)
    fmt.Println(string(out))   // NDJSON: un documento por línea
}

Esto maneja archivos YAML multidocumento de tamaño arbitrario con memoria constante.

Trampas de la conversión de YAML — 8 casos verificados

YAML y JSON no tienen una correspondencia perfecta uno a uno. Estas son las cosas que más a menudo pillan a la gente.

Trampa 1: el problema de Noruega (NO → false)

YAML 1.1 interpreta ciertas cadenas sin comillas como booleanos:

country: NO

Se convierte en:

{ "country": false }

NO, no, Off, OFF, n, N, False, False, f, F se convierten todos en false. YES, Y, On, True, T, t se convierten todos en true. Este es el famoso "problema de Noruega": country: NO en una lista de códigos de país se parsea silenciosamente como un booleano.

Solución: pon comillas en los valores ambiguos de tu YAML:

country: "NO"

YAML 1.2 (en concreto el esquema Core) eliminó este comportamiento. Pero muchas herramientas siguen usando YAML 1.1 por defecto, incluidos el safe_load de PyYAML y yq hasta la v4. Pon siempre comillas en los códigos de país de dos letras, en cadenas de versión como 1.0 y en cualquier campo de cadena controlado por el usuario.

Trampa 2: los comentarios se pierden silenciosamente

YAML admite comentarios con #. JSON no. Cualquier comentario de tu archivo YAML se descarta durante la conversión:

# Conexión a la base de datos de producción (NO MODIFICAR)
host: db.prod.internal
port: 5432  # puerto estándar de PostgreSQL

Se convierte en:

{ "host": "db.prod.internal", "port": 5432 }

Ningún conversor puede preservar los comentarios de YAML en JSON porque JSON no tiene una sintaxis de comentarios. JSON5 y JSONC sí la tienen, pero no son estándar. Si los comentarios son importantes, guárdalos por separado o usa una herramienta como ruamel.yaml para extraerlos programáticamente antes de la conversión.

Trampa 3: YAML multidocumento (---) — por defecto solo sobrevive el primer documento

Los archivos YAML pueden contener varios documentos separados por ---:

---
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
---
apiVersion: v1
kind: Service
metadata:
  name: app-service

Comportamiento por defecto:

• yaml.safe_load (Python): devuelve silenciosamente solo el primer documento
• yaml.load (js-yaml): igual, devuelve solo el primero
• yq -o=json '.': emite varios documentos JSON uno tras otro (concatenados, NDJSON válido si es compacto)

Para obtener todos los documentos como un array JSON:

yq eval-all '[.]' -o=json multi.yaml

Python:

import yaml, json
docs = list(yaml.safe_load_all(open("multi.yaml")))
json.dump(docs, open("multi.json", "w"), indent=2)

Node.js:

const docs = yaml.loadAll(fs.readFileSync("multi.yaml", "utf8"));
fs.writeFileSync("multi.json", JSON.stringify(docs, null, 2));

Los archivos de Kubernetes con una "lista de manifiestos" casi siempre usan YAML multidocumento. Maneja este caso de forma explícita.

Trampa 4: yaml.load es inseguro — usa siempre safe_load

En PyYAML de Python, la función yaml.load por defecto permite la construcción arbitraria de objetos Python:

!!python/object/apply:os.system ["rm -rf /"]

Un archivo YAML diseñado con malas intenciones puede ejecutar código si se carga con yaml.load. Usa siempre yaml.safe_load (o yaml.safe_load_all para multidocumento) al manejar entradas no confiables.

js-yaml mitigó esto al deprecar yaml.safeLoad en favor de yaml.load, pero yaml.load en js-yaml es seguro por defecto. El deprecado unsafeLoad es el peligroso. La nomenclatura es confusamente distinta entre Python y Node; comprueba siempre cuál estás usando.

yq es seguro porque usa yaml.v3 de Go, que no tiene un equivalente a la etiqueta !!python/object de Python.

Trampa 5: las claves enteras se vuelven cadenas

YAML permite claves enteras:

123: first
456: second

Las claves de un objeto JSON deben ser cadenas, así que los conversores las convierten:

{ "123": "first", "456": "second" }

Esto suele estar bien, pero si tu código posterior espera buscar por clave entera (obj[123]), fallará porque la clave ahora es una cadena (obj["123"]). Convierte las claves de vuelta a enteros en el código de tu aplicación si es necesario.

Trampa 6: las anclas y los alias se expanden en línea

YAML te permite definir un valor una vez con &anchor y referenciarlo en otro lugar con *alias:

defaults: &defaults
  timeout: 30
  retries: 3

production:
  <<: *defaults
  host: prod.internal

staging:
  <<: *defaults
  host: stage.internal

Al convertir a JSON, el ancla se expande en línea: tanto production como staging acaban con una copia completa de cada valor por defecto:

{
  "defaults": { "timeout": 30, "retries": 3 },
  "production": { "timeout": 30, "retries": 3, "host": "prod.internal" },
  "staging": { "timeout": 30, "retries": 3, "host": "stage.internal" }
}

Los datos son correctos, pero la intención original de "estos comparten valores por defecto" ya no es visible. Si conviertes de vuelta a YAML, pierdes las anclas por completo. Esto es inevitable: JSON no tiene un equivalente a las anclas.

Trampa 7: 1.0 se vuelve un float (las cadenas de versión se rompen)

YAML trata los valores que parecen numéricos como números:

version: 1.0
release: 2026

Se convierte en:

{ "version": 1.0, "release": 2026 }

Si querías la cadena "1.0" (una etiqueta de versión), la conversión la fuerza silenciosamente a un float 1.0, que luego se imprime como 1 o 1.0 según el codificador de JSON. Las comparaciones de versión mayor (if version == "1.0") fallarán.

Solución: pon comillas en las cadenas de versión en YAML:

version: "1.0"
release: "2026"

Esto se aplica a cualquier cosa que deba seguir siendo una cadena pero que parezca numérica: números de teléfono, códigos postales ("01234" pierde el cero a la izquierda), hashes de commit que parecen números hexadecimales ("e10" → 1e+10).

Trampa 8: sorpresas de inferencia de tipos según el esquema

YAML tiene tres esquemas estándar que determinan cómo se infieren los tipos:

• Esquema FailSafe: solo cadenas, secuencias y mapas. Sin parseo de números ni booleanos. El más seguro.
• Esquema JSON: coincide con los tipos de JSON (cadenas, números, booleanos, null, arrays, objetos). Sin el problema de Noruega, sin booleanos yes/no.
• Esquema Core (por defecto en YAML 1.2): como JSON pero añade null, Null, NULL, ~ y vacío como null. También admite true/false/True/False/TRUE/FALSE como booleanos.

La mayoría de las herramientas usan Core por defecto. Algunas herramientas heredadas usan por defecto el esquema completo de YAML 1.1 (que incluye el problema de Noruega y yes/no).

Para forzar el esquema JSON en Python:

yaml.safe_load(text, Loader=yaml.SafeLoader)  # por defecto
# o de forma explícita:
yaml.load(text, Loader=yaml.CSafeLoader)

js-yaml:

yaml.load(text, { schema: yaml.JSON_SCHEMA });

yq v4 usa el esquema Core de YAML 1.2 por defecto, lo que evita el problema de Noruega.

Comparación de herramientas en línea

Una comparación práctica de conversores de YAML a JSON en línea habituales en 2026:

Para YAML sensible (Secrets de Kubernetes, contenido de vault de Ansible, configuraciones de CI con tokens), la afirmación de "funciona en el navegador" importa. Verifícala desactivando la red en las DevTools antes de pegar: una herramienta que realmente funciona en el navegador sigue operando sin conexión. FormatArc sigue funcionando con la red desactivada.

En el caso del YAML multidocumento, todas las herramientas en línea listadas manejan solo el primer documento. Para salida multidocumento o NDJSON, recurre a yq o Python.

YAML a JSON Lines (NDJSON) para pipelines de streaming

Cuando la entrada es un archivo YAML multidocumento y la salida debe alimentar a un consumidor de streaming (productor de Kafka, cargador de base de datos línea por línea, agente de envío de logs), JSON Lines (NDJSON) es el formato de salida adecuado.

Con yq

# NDJSON: cada documento YAML se convierte en una línea JSON
yq -o=json -I=0 '.' multi.yaml

# Filtrar y luego NDJSON
yq -o=json -I=0 '.items[]' kubernetes-list.yaml

Con streaming en Python

import yaml
import json
import sys

for doc in yaml.safe_load_all(sys.stdin):
    sys.stdout.write(json.dumps(doc, ensure_ascii=False) + "\n")

Uso: python3 yaml2ndjson.py < multi.yaml > multi.ndjson.

Esto consume memoria constante sin importar el tamaño de la entrada, algo importante para archivos YAML tipo log con miles de documentos.

Enviar a Kafka, BigQuery o S3

# Enviar a BigQuery
yq -o=json -I=0 '.' events.yaml | bq load --source_format=NEWLINE_DELIMITED_JSON dataset.events -

# Enviar a S3
yq -o=json -I=0 '.' events.yaml | aws s3 cp - s3://bucket/events.ndjson

# Enviar a Kafka mediante kafkacat
yq -o=json -I=0 '.' events.yaml | kafkacat -P -b broker:9092 -t events

Automatización CI/CD

Tres plataformas de pipeline habituales con pasos de conversión de YAML a JSON.

GitHub Actions

name: Convert YAML config to JSON
on: [push, pull_request]

jobs:
  convert:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Install yq
        run: |
          sudo wget -qO /usr/local/bin/yq https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64
          sudo chmod +x /usr/local/bin/yq
      - name: Convert
        run: yq -o=json '.' config.yaml > config.json
      - name: Validate against JSON Schema
        run: |
          npx ajv-cli validate -s schema.json -d config.json

GitLab CI

convert-yaml:
  image: mikefarah/yq:latest
  stage: validate
  script:
    - yq -o=json '.' config.yaml > config.json
    - jq empty config.json   # comprobación final de sintaxis
  artifacts:
    paths:
      - config.json

Jenkins (pipeline declarativo)

pipeline {
  agent any
  stages {
    stage('Convert YAML to JSON') {
      steps {
        sh 'yq -o=json . config.yaml > config.json'
        sh 'jq empty config.json'
      }
    }
  }
}

En cualquier caso, la conversión añade menos de un segundo al tiempo de ejecución del pipeline.

Flujo de trabajo práctico en Kubernetes

Un escenario típico del mundo real. Tienes un deployment en ejecución, quieres inspeccionarlo o modificarlo y necesitas convertir entre YAML y JSON.

# Obtener el deployment actual como JSON (kubectl admite ambos)
kubectl get deployment web-app -o json > deployment.json

# O obtenerlo como YAML y luego convertir (verifica tu herramienta yq local)
kubectl get deployment web-app -o yaml | yq -o=json '.' > deployment.json

# Modificar con jq (p. ej., escalar las réplicas)
jq '.spec.replicas = 5' deployment.json > updated.json

# Convertir de vuelta a YAML para hacer commit en Git
yq -P '.' updated.json > deployment.yaml

# Aplicar
kubectl apply -f deployment.yaml

O en un único pipeline:

kubectl get deployment web-app -o json \
  | jq '.spec.replicas = 5' \
  | yq -P '.' \
  > deployment.yaml

Este patrón funciona en todos los recursos de kubectl, los values de los charts de Helm y las definiciones de recursos personalizados.

Preguntas frecuentes

¿Por qué mi valor YAML country: NO se convirtió en false?

Este es el famoso "problema de Noruega". YAML 1.1 interpreta NO, Off, n, False y cadenas sin comillas similares como el booleano false. Soluciónalo poniendo comillas: country: "NO". La especificación de YAML 1.2 eliminó este comportamiento, pero muchas herramientas siguen usando 1.1 por defecto. yq v4 usa el esquema Core de YAML 1.2 y no tiene este fallo.

¿Puedo preservar los comentarios de YAML en la salida JSON?

No. JSON no tiene una sintaxis de comentarios. Las soluciones alternativas incluyen ruamel.yaml para extraer los comentarios como una estructura de metadatos separada, o formatos no estándar como JSON5 / JSONC. Si los comentarios son importantes, mantén el YAML como fuente de verdad. Consulta Cómo añadir comentarios a JSON para conocer las soluciones dentro del propio JSON.

YAML multidocumento — ¿qué ocurre durante la conversión?

Por defecto, la mayoría de las herramientas convierten solo el primer documento. Para obtener todos los documentos: usa yaml.safe_load_all en Python, yaml.loadAll en Node.js o yq eval-all '[.]' para envolverlos en un array JSON. Para streaming (un documento JSON por línea), usa yq -o=json -I=0 para salida NDJSON.

¿YAML a JSON Lines (NDJSON)?

Usa yq -o=json -I=0 '.' multi.yaml para una salida compacta de un documento por línea. Python: procesa en streaming con yaml.safe_load_all y escribe cada uno como una línea. NDJSON es el formato adecuado para consumidores de streaming (BigQuery, S3, Kafka, agentes de envío de logs).

¿YAML a JSON5 (con comentarios)?

JSON5 es un superconjunto de JSON que admite comentarios. Para convertir YAML a JSON5: convierte primero el YAML a JSON estándar y luego añade los comentarios manualmente, o usa una herramienta personalizada. La implementación de referencia de json5.org puede parsear y emitir JSON5, pero ninguna biblioteca importante de YAML produce JSON5 directamente.

Anclas y claves de fusión — ¿se preservan en JSON?

No. JSON no tiene el concepto de ancla / alias, así que las anclas se expanden en línea durante la conversión. Los datos expandidos son correctos, pero la intención original de "estos comparten valores por defecto" deja de ser visible en el JSON. Convertir de vuelta a YAML pierde las anclas por completo.

¿Cómo convierto un archivo YAML a JSON sin tener yq ni Python instalados?

Usa la herramienta de navegador FormatArc YAML a JSON: funciona por completo en el navegador, sin necesidad de instalar nada. Como alternativa, todos los sistemas operativos modernos incluyen Python 3 (que puede usar pyyaml tras un pip install pyyaml). En muchas distribuciones de Linux, python3 -c 'import sys, yaml, json; ...' funciona sin más.

En el sentido inverso

Para convertir JSON a YAML, consulta Cómo convertir JSON a YAML. La herramienta JSON a YAML de FormatArc maneja el sentido inverso con la misma facilidad.

Guías relacionadas

• Qué es YAML — el modelo de datos de YAML, su historia y sus casos de uso habituales
• Qué es JSON — el modelo de datos y los tipos de JSON
• Guía de sintaxis de YAML — escribir YAML válido desde cero
• YAML vs JSON — comparación estructural y cuándo usar cada uno
• Conversión de JSON a YAML — el sentido inverso
• Consejos para formatear JSON — producir un JSON revisable tras la conversión

Resumen

Cinco métodos cubren todos los casos de uso de YAML a JSON:

• Sin instalar nada, datos sensibles: FormatArc YAML a JSON — en el navegador, errores con número de línea.
• CLI / pipelines de DevOps: yq -o=json '.' — el estándar de facto.
• Aplicaciones Python: yaml.safe_load (nunca yaml.load) + json.dump.
• Aplicaciones Node.js: js-yaml (yaml.load con esquema JSON por seguridad).
• Servicios en Go: gopkg.in/yaml.v3 + encoding/json, con un bucle Decoder para archivos multidocumento.

Las 8 trampas (el problema de Noruega, la pérdida de comentarios, el manejo de multidocumento, la inseguridad de yaml.load, las claves enteras que se vuelven cadenas, la expansión de anclas, 1.0 que se vuelve float, la inferencia de tipos según el esquema) pillan a casi todo el mundo al menos una vez. Pon comillas en las cadenas ambiguas, usa safe_load y maneja el multidocumento de forma explícita: lo demás viene solo.