Skip to content

Conversor JSON para YAML

Cole JSON e obtenha YAML instantaneamente. Conversão ao vivo no navegador. K8s/Compose, indentação 2/4 espaços, Norway-safe. 100% privado, sem upload.

Sem rastreamento Roda no navegador Grátis
Opções · 2 espaços · auto · block
Indentação
Estilo
0 caracteres
YAML Saída
0 linhas
Revisado para conformidade com RFC 8259, saída de especificação YAML 1.2 e correção no tratamento do problema Norway — Go Tools Engineering Team · May 4, 2026

O que é YAML e por que converter de JSON?

YAML (YAML Ain't Markup Language) é um formato de serialização de dados legível por humanos, projetado para arquivos de configuração, infraestrutura como código e em qualquer lugar onde um humano escreva dados que uma máquina vai ler. Sua sintaxe baseada em indentação não exige chaves ou colchetes, tornando-o muito mais legível que JSON para estruturas aninhadas complexas. Kubernetes, Helm, Ansible, Docker Compose, GitHub Actions, CircleCI e praticamente todas as ferramentas cloud-native usam YAML como formato de configuração primário. Converter JSON para YAML é, portanto, uma das tarefas mais comuns em DevOps e desenvolvimento backend — você recebe uma definição de recurso de uma API em JSON e precisa de um manifesto YAML para commitar no controle de versão.

Esta ferramenta tem quatro diferenciadores importantes em comparação com conversores online típicos:

**1. Problema Norway — Aspas Seguras Automáticas.** O maior risco em conversão de JSON para YAML é o problema Norway do YAML. No YAML 1.1 (que milhões de parsers em produção ainda usam, incluindo versões mais antigas do Kubernetes, PyYAML, Ansible e Psych do Ruby), as strings simples yes, no, on, off, y e n são analisadas como valores booleanos verdadeiro/falso. Isso afetou de forma famosa o código de país ISO da Noruega («NO» → falso) e causou interrupções reais em produção em configurações do Kubernetes. O YAML 1.2 corrigiu isso, mas seus parsers podem não estar na versão 1.2. O modo padrão de aspas Auto desta ferramenta usa a biblioteca eemeli/yaml com o esquema YAML 1.1, então ela automaticamente envolve qualquer string do problema Norway em aspas, garantindo round-trips seguros pelos parsers YAML 1.1 e 1.2. Saiba mais em nosso artigo complementar em O Problema Norway do YAML e Diferenças entre JSON e YAML.

**2. Preservação da Ordem das Chaves.** Diferentemente de alguns conversores que ordenam as chaves alfabeticamente, esta ferramenta preserva a ordem original de inserção das chaves do seu JSON — correspondendo ao comportamento de JSON.parse() em todos os motores JavaScript modernos. Isso importa para manifestos do Kubernetes (onde apiVersion e kind são esperados primeiro por convenção), especificações OpenAPI (onde info aparece antes de paths) e qualquer configuração onde a ordenação dos campos é significativa para legibilidade ou diffs.

**3. Aviso de Precisão de Números Grandes.** Números JSON maiores que 2^53 - 1 (9007199254740991) não podem ser representados exatamente no float de precisão dupla IEEE 754 do JavaScript. Quando JSON.parse() lê um inteiro grande como um campo resourceVersion do Kubernetes (que é um inteiro de 64 bits no servidor), ele o trunca silenciosamente. Esta é uma limitação fundamental do JavaScript no navegador que afeta todas as ferramentas JSON baseadas em navegador, incluindo esta. A solução segura é garantir que inteiros grandes sejam armazenados como strings no seu JSON antes de converter. Esta ferramenta documenta esse comportamento honestamente no erro comum de Perda de Precisão de Número abaixo.

**4. 100% Privacidade Baseada no Navegador.** Seus dados JSON — que frequentemente contêm chaves de API, credenciais de banco de dados, configurações internas de serviço e segredos de produção — nunca saem do seu navegador. Nenhum dado é enviado a nenhum servidor. Você pode verificar isso na guia de Rede do seu navegador. Esta é a única forma segura de lidar com dados de configuração sensíveis em uma ferramenta online. Veja nossa ferramenta complementar para a direção inversa em Conversor YAML para JSON, e nosso Formatador JSON se precisar validar e imprimir JSON antes de converter.

A natureza legível por humanos do YAML vem com uma troca: ele tem mais casos extremos de análise do que o JSON. Além do problema Norway, o YAML tem peculiaridades com números octais (0777 é analisado como 511 no YAML 1.1), sintaxe de string multilinha (| para literal, > para dobrado), referências de âncora e alias (&anchor e *alias) e suporte a múltiplos documentos (separador ---). O JSON não tem nenhuma dessas complexidades — é um formato estrito e mínimo com apenas seis tipos de dados. Para troca de dados entre máquinas, JSON é quase sempre a melhor escolha. Para arquivos de configuração editados por humanos onde legibilidade e comentários importam, o YAML vence. Este conversor oferece o melhor dos dois mundos: use JSON programaticamente, converta para YAML para sua infraestrutura.

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

Recursos Principais

Conversão ao Vivo

A saída YAML atualiza instantaneamente conforme você digita ou cola JSON — sem necessidade de botão Converter. Entradas grandes (>200KB) mudam automaticamente para o modo manual para manter o navegador responsivo.

Indentação de 2 ou 4 Espaços

Alterne entre indentação de 2 espaços (padrão para Kubernetes, Docker Compose e GitHub Actions) e 4 espaços (convenção do Ansible). Tabs são proibidos em YAML — esta ferramenta sempre usa espaços.

Aspas Seguras Automáticas (Norway-safe)

O modo Auto padrão usa o esquema YAML 1.1 para automaticamente entre aspas strings como «no», «yes», «on», «off», «y» e «n» que seriam lidas erroneamente como booleanos pelos parsers YAML 1.1, prevenindo configurações incorretas em produção.

Estilos Block e Flow

O estilo Block produz YAML indentado e legível por humanos, ideal para manifestos e arquivos de configuração. O estilo Flow produz YAML compacto e inline, semelhante ao JSON — útil para trechos de documentação ou ferramentas que preferem saída mínima.

100% Privacidade Baseada no Navegador

Toda a conversão é executada localmente no seu navegador usando JavaScript. Seus dados JSON — incluindo chaves de API, credenciais e configurações de produção — nunca são enviados a nenhum servidor, nunca são registrados e nunca são armazenados.

Suporte para K8s, Compose e Terraform

Otimizado para casos de uso DevOps do mundo real: manifestos do Kubernetes, stacks Docker Compose, valores de charts Helm, workflows do GitHub Actions, especificações OpenAPI e saídas de plano JSON do Terraform — com exemplos para cada um.

Exemplos

Kubernetes Deployment

{"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"}}}]}}}}

Converta um manifesto de Deployment do Kubernetes do formato de resposta JSON da API para YAML, para aplicar com 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":{}}}

Converta uma definição de serviço Docker Compose de JSON para o formato YAML exigido pelo docker compose up

Workflow do 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"}]}}}

Converta uma definição de workflow de CI do GitHub Actions de JSON para YAML, para commitar em .github/workflows/

Especificação 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"}}}}}}

Converta uma especificação OpenAPI 3.0 de JSON para YAML — o formato preferido pelo Swagger UI, Redoc e pela maioria das ferramentas 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"}}

Converta um package.json típico de Node.js para YAML — útil para migrar configurações de projeto para ferramentas que preferem YAML

Plano JSON do 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}}}]}

Converta a saída do plano JSON do Terraform para YAML para revisão humana, trilhas de auditoria GitOps e pipelines de CI/CD — um diferencial que a maioria dos conversores não oferece

Como Usar

  1. 1

    Cole seu JSON

    Insira ou cole seus dados JSON no campo de entrada acima. Você também pode clicar em «Carregar exemplo» para experimentar uma amostra como um Deployment do Kubernetes, um arquivo Docker Compose ou um plano do Terraform.

  2. 2

    Veja a saída YAML ao vivo

    O YAML aparece instantaneamente no painel de saída. Ajuste as Opções (indentação 2/4, aspas Auto/Duplas/Simples, estilo Block/Flow) para corresponder aos requisitos da sua ferramenta de destino.

  3. 3

    Copie ou Baixe

    Clique em Copiar para pegar o YAML para a área de transferência, ou em Baixar para salvá-lo como arquivo .yaml pronto para kubectl apply, docker compose up ou qualquer outra ferramenta.

Armadilhas Comuns de Conversão

Vírgulas Finais

JSON não permite vírgula após o último elemento em um objeto ou array. Isso é extremamente comum ao copiar de código JavaScript, que permite vírgulas finais. Remova a vírgula final antes de converter.

✗ Incorreto 
{"name": "Alice", "role": "admin",}
✓ Correto 
{"name": "Alice", "role": "admin"}

Aspas Simples

JSON exige aspas duplas para todos os valores de string e chaves de objeto. Aspas simples são válidas em JavaScript e Python, mas são um erro de sintaxe em JSON.

✗ Incorreto 
{'name': 'Alice', 'active': true}
✓ Correto 
{"name": "Alice", "active": true}

Chaves sem Aspas

Todas as chaves de objeto JSON devem estar entre aspas duplas. Chaves sem aspas são válidas em literais de objeto JavaScript, mas causarão um erro de análise em JSON estrito.

✗ Incorreto 
{name: "Alice", role: "admin"}
✓ Correto 
{"name": "Alice", "role": "admin"}

Comentários Não Permitidos

O JSON padrão não suporta comentários de nenhum tipo — nem //, /* */ ou #. Se precisar de comentários na configuração, use YAML (que suporta comentários #) ou JSONC (JSON com Comentários, usado pelo VS Code). Remova todos os comentários antes de usar os dados como JSON.

✗ Incorreto 
{"port": 8080 // HTTP port}
✓ Correto 
{"port": 8080}

Problema Norway do YAML (tratado automaticamente no modo Auto)

Nos parsers YAML 1.1 (usados pelo Kubernetes, Ansible, PyYAML, Ruby Psych), as strings simples yes, no, on, off, y e n são analisadas como booleanos verdadeiro/falso em vez de strings. O modo Auto desta ferramenta coloca automaticamente aspas nesses valores na saída YAML para garantir round-trips seguros por qualquer parser YAML 1.1 ou 1.2. Se você selecionar o modo de aspas Duplas ou Simples, todas as strings são explicitamente entre aspas, o que também evita o problema — mas o modo Auto produz a saída mais natural.

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

Perda de Precisão para Inteiros Grandes

O JavaScript só pode representar inteiros exatamente até 2^53 - 1 (9007199254740991). Inteiros JSON maiores que isso — como os campos resourceVersion do Kubernetes (que são int64 no servidor) — são silenciosamente arredondados quando analisados por JSON.parse(). Esse número truncado aparece na saída YAML. Esta é uma limitação fundamental do JavaScript no navegador que afeta todas as ferramentas JSON baseadas em navegador. A solução segura é armazenar inteiros grandes como strings no JSON antes de converter.

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

Casos de Uso Comuns

Manifestos do Kubernetes
Converta respostas JSON da API de kubectl get -o json ou da API do Kubernetes em manifestos YAML para workflows GitOps, overlays do Kustomize e deployments com kubectl apply -f.
Arquivos Docker Compose
Transforme a saída JSON de docker inspect ou configurações de serviço geradas programaticamente em arquivos docker-compose.yaml compatíveis com docker compose up e deployments Docker Stack.
Valores de Charts Helm
Converta exportações de configuração JSON em arquivos YAML de valores para deployments de charts Helm, permitindo configuração de infraestrutura com controle de versão e sintaxe YAML limpa.
Workflows do GitHub Actions
Construa definições de workflow do GitHub Actions programaticamente em JSON e converta para o formato .github/workflows/*.yaml exigido pelo runner do GitHub Actions.
Especificações OpenAPI
Converta especificações OpenAPI/Swagger do formato JSON retornado por muitos frameworks (FastAPI, SpringDoc) para o formato YAML preferido pelo Swagger UI, Redoc e ferramentas de gateway de API.
Migração de Configuração
Migre configurações de aplicação armazenadas em JSON (appsettings.json, config.json) para o formato YAML para ferramentas que exigem ou preferem YAML, adicionando a capacidade de usar comentários para documentação.

Detalhes Técnicos

Análise JSON Compatível com RFC 8259
A entrada JSON é analisada usando o JSON.parse() nativo do navegador, que é totalmente compatível com RFC 8259. Isso fornece mensagens de erro de sintaxe precisas, incluindo informações de posição (números de linha e coluna com melhor esforço), e lida com todos os tipos de dados JSON: strings, números, booleanos, null, arrays e objetos.
Saída YAML 1.2 via API de Documento eemeli/yaml com Esquema YAML 1.1
O YAML é gerado usando a biblioteca eemeli/yaml (v2.8+, segura contra CVEs) via sua API de Documento com version: '1.1'. Essa combinação produz saída compatível com YAML 1.2 enquanto aplica as regras de aspas do YAML 1.1 — o que significa que strings do problema Norway (yes/no/on/off/y/n) são automaticamente entre aspas na saída, tornando-a segura para parsers YAML 1.1 e 1.2. A quebra de linha é desativada (lineWidth: 0) para preservar strings longas intactas.
100% Baseado no Navegador — Sem Upload, Sem Servidor
Todo o processamento acontece inteiramente no motor JavaScript do seu navegador. Nenhum dado é transmitido pela rede em nenhum momento. Entradas maiores que 200KB mudam automaticamente do modo ao vivo para o modo manual (exigindo um clique explícito em Converter) para manter o navegador responsivo e evitar o bloqueio da thread principal durante a serialização pesada.

Melhores Práticas

Sempre Use o Modo Auto de Aspas para Configurações DevOps
Ao converter JSON para uso no Kubernetes, Helm, Ansible, Docker Compose ou GitHub Actions, sempre use o modo padrão Auto (Norway-safe) de aspas. Os parsers YAML 1.1 nessas ferramentas interpretarão silenciosamente yes, no, on, off, y e n simples como booleanos — o modo Auto previne isso de forma transparente.
Use Indentação de 2 Espaços para Ferramentas Cloud-Native
Kubernetes, Docker Compose, GitHub Actions e Helm usam indentação de 2 espaços por convenção. Usar indentação de 4 espaços nesses arquivos é YAML válido, mas criará inconsistência com exemplos da comunidade, configurações geradas automaticamente e os manifestos existentes da sua equipe.
Armazene Inteiros Grandes como Strings Antes de Converter
Os campos resourceVersion, uid e outros campos int64 do servidor de API do Kubernetes podem exceder o intervalo seguro de inteiros do JavaScript (2^53 - 1). Se precisar de precisão numérica exata, armazene esses valores como strings JSON antes de converter. Isso é especialmente importante para a saída de kubectl get -o json que inclui campos gerados pelo servidor.
Valide o JSON Primeiro
Se sua fonte JSON é escrita à mão ou vem de um sistema que ocasionalmente produz saída inválida (vírgulas finais, chaves sem aspas, comentários), valide-a com um formatador JSON antes de converter. Use nosso Formatador JSON para detectar e corrigir erros de sintaxe primeiro, depois converta o JSON limpo para YAML.
Prefira o Estilo Block para Arquivos no Controle de Versão
O YAML no estilo Block produz diffs limpos e legíveis por humanos no Git, porque cada campo aparece em sua própria linha. O estilo Flow (compacto, inline) torna os diffs mais difíceis de ler e revisar. Reserve o estilo Flow para incorporar trechos curtos de YAML em documentação ou para ferramentas que exigem saída compacta.

Perguntas Frequentes

Como converter JSON para YAML online?
Cole seu JSON no campo de entrada acima. A ferramenta converte para YAML instantaneamente no navegador — sem necessidade de clicar em botão. Você pode ajustar a indentação (2 ou 4 espaços), o estilo de aspas (Auto, Duplas ou Simples) e o estilo de saída (Block ou Flow) no painel de Opções. Assim que o YAML aparecer na área de saída, clique em Copiar para copiá-lo para a área de transferência ou em Baixar para salvar como arquivo .yaml. Tudo é executado localmente — seus dados nunca saem do dispositivo.
O que é o problema Norway do YAML e como esta ferramenta o trata?
O problema Norway do YAML refere-se a uma peculiaridade da especificação YAML 1.1, onde strings simples como «no», «yes», «on», «off», «y» e «n» são interpretadas como valores booleanos (falso/verdadeiro) em vez de strings. Isso causou um famoso problema real onde o código de país ISO da Noruega («NO») era lido como o booleano falso em playbooks do Ansible e configurações do Kubernetes. No YAML 1.2, isso foi corrigido — strings simples são sempre strings. No entanto, milhões de parsers em produção (versões mais antigas do Kubernetes, PyYAML, Ansible, Psych do Ruby) ainda usam YAML 1.1. O modo Auto de aspas desta ferramenta (o padrão) envolve automaticamente quaisquer strings do problema Norway em aspas, para que façam round-trip com segurança pelos parsers YAML 1.1 e 1.2. Quando strings do problema Norway são detectadas na entrada, um banner de aviso lista exatamente quais valores foram automaticamente entre aspas.
Por que o problema Norway importa para Kubernetes e DevOps?
Manifestos YAML do Kubernetes, valores de charts Helm, playbooks do Ansible e workflows do GitHub Actions são todos analisados por ferramentas que historicamente usavam YAML 1.1. Se você tiver uma chave de configuração com o valor «no» (por exemplo, um código de país, um flag enabled em forma de string ou um campo personalizado semelhante a booleano), um parser YAML 1.1 o converterá silenciosamente para o booleano falso. Isso pode causar configurações incorretas de serviço extremamente difíceis de depurar, porque o YAML parece correto quando visualizado como texto, mas se comporta diferentemente quando analisado. Sempre use o modo Auto de aspas ao converter JSON para uso no Kubernetes ou em qualquer toolchain DevOps para garantir round-trips seguros.
Devo usar indentação de 2 ou 4 espaços para YAML?
Use indentação de 2 espaços para manifestos do Kubernetes, valores Helm, arquivos Docker Compose e workflows do GitHub Actions — essas ferramentas são projetadas em torno de YAML com 2 espaços e é a convenção da comunidade. Use indentação de 4 espaços para playbooks do Ansible (que seguem a convenção de 4 espaços) e quando sua equipe ou organização tem um guia de estilo que o exige. O YAML proíbe completamente o uso de tabs — toda a indentação deve ser com espaços. Esta ferramenta usa 2 espaços por padrão, que é a escolha correta para a grande maioria dos casos de uso cloud-native.
Como usar esta ferramenta para criar um manifesto do Kubernetes?
Se você tiver uma definição de recurso do Kubernetes em JSON (de kubectl get deployment my-app -o json, uma resposta de API ou um bloco de recurso Terraform), cole-a no campo de entrada. Selecione 2 espaços de indentação (o padrão) e aspas Auto (o padrão, que trata o problema Norway). A saída YAML está imediatamente pronta para kubectl apply -f. Você também pode clicar em Baixar para salvar o arquivo com extensão .yaml e redirecioná-lo diretamente para kubectl apply -f -. O exemplo de K8s Deployment acima mostra um manifesto de deployment completo que você pode carregar e modificar.
Como converter um JSON do Docker Compose para YAML?
Cole seu JSON do Docker Compose no campo de entrada. Use indentação de 2 espaços (convenção do Docker Compose) e estilo Block. O YAML de saída é compatível com docker compose up, docker compose config e Docker Stack. Um cenário comum é exportar a configuração de uma stack em execução com docker inspect e depois convertê-la de volta para um arquivo compose.yaml. O exemplo de Docker Compose acima inclui definições de serviço com ports, variáveis de ambiente, volumes e depends_on.
Números JSON maiores que 2^53 podem perder precisão ao converter para YAML?
Sim. Esta é uma limitação fundamental do JavaScript: o float de precisão dupla IEEE 754 usado pelo tipo Number do JavaScript só pode representar inteiros exatamente até 2^53 - 1 (9007199254740991). Qualquer inteiro além disso — como os campos resourceVersion do Kubernetes (que são int64 no servidor) — será silenciosamente arredondado quando analisado por JSON.parse(). Por exemplo, o valor 9007199254740993 torna-se 9007199254740992 no JavaScript, e esse número truncado aparecerá na saída YAML. Isso afeta todas as ferramentas JSON baseadas em navegador, não apenas esta. A solução segura é armazenar inteiros grandes como strings no JSON ("resourceVersion": "9007199254740993") — eles aparecerão como strings YAML sem nenhuma perda de precisão.
O conversor preserva a ordem original das chaves do meu JSON?
Sim. A biblioteca eemeli/yaml usada por esta ferramenta preserva a ordem de inserção, que corresponde ao comportamento de JSON.parse() em todos os motores JavaScript modernos (V8, SpiderMonkey, JavaScriptCore). As chaves aparecem na saída YAML na mesma ordem em que apareceram na entrada JSON. Isso é importante para manifestos do Kubernetes e especificações OpenAPI, onde a ordem dos campos é frequentemente significativa para legibilidade e diffs.
Quando devo usar JSON versus YAML?
Use JSON quando: estiver construindo APIs e serviços web (JSON é o formato universal de intercâmbio), quando a velocidade de análise pela máquina importa, quando precisar de segurança estrita de tipos ou quando o consumidor for uma aplicação JavaScript/TypeScript. Use YAML quando: escrever arquivos de configuração destinados à edição humana (manifestos do Kubernetes, pipelines de CI/CD, playbooks do Ansible, valores Helm), quando quiser comentários na configuração ou quando a legibilidade for mais importante que a rigidez. Uma regra útil: se uma máquina o escreve ou o lê primeiro, use JSON; se um humano o escreve e uma máquina o lê, use YAML.
Como posso converter JSON para YAML na linha de comando?
A abordagem mais popular é combinar yq e jq. Instale o yq (versão de Mike Farah, não a versão Python): brew install yq no macOS ou wget https://github.com/mikefarah/yq/releases/latest/download/yq_linux_amd64 -O /usr/local/bin/yq para Linux. Então execute: cat input.json | yq -P para imprimir como YAML. Alternativamente: yq -o yaml input.json ou cat input.json | python3 -c "import sys, json, yaml; yaml.dump(json.load(sys.stdin), sys.stdout, default_flow_style=False)". Para Kubernetes especificamente: kubectl get deployment my-app -o yaml converte diretamente da API do cluster.
Como converter JSON para YAML em Python, Node.js ou Go?
Em Python: import json, yaml; yaml.dump(json.load(open('input.json')), open('output.yaml', 'w'), default_flow_style=False) usando PyYAML, ou ruamel.yaml para fidelidade de round-trip. Em 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 é a mesma biblioteca e abordagem usada por esta ferramenta. Em Go: import gopkg.in/yaml.v3; json.Unmarshal(jsonBytes, &data); yaml.Marshal(data) — note que o Go YAML v3 usa YAML 1.1 por padrão, portanto strings do problema Norway serão automaticamente entre aspas.
Meus dados JSON são enviados a algum servidor ao usar esta ferramenta?
Não. Toda a conversão acontece inteiramente no seu navegador usando JavaScript. Seus dados JSON nunca são transmitidos pela rede, nunca são armazenados em nenhum servidor e nunca são registrados ou analisados. Isso torna a ferramenta segura para uso com chaves de API, credenciais de banco de dados, arquivos de configuração internos, manifestos do Kubernetes em produção e quaisquer outros dados sensíveis. A ferramenta não usa cookies para seus dados de entrada e não tem análises de terceiros que capturem o que você cola. Você pode verificar isso abrindo a guia de Rede do seu navegador — você verá zero requisições disparadas ao colar JSON.
Existe um limite de tamanho de arquivo para entrada JSON?
Não há limite rígido de tamanho de arquivo, mas entradas grandes (acima de 200KB) mudam automaticamente do modo ao vivo para o modo manual. No modo manual, um botão Converter aparece e a conversão só é executada quando você clica nele — isso evita que a thread principal do navegador bloqueie por 200-500ms a cada tecla pressionada. Para arquivos JSON muito grandes (vários megabytes), considere usar ferramentas de linha de comando como yq ou jq para melhor desempenho. A ferramenta lida eficientemente com payloads reais típicos, como dumps completos de namespace do Kubernetes, grandes especificações OpenAPI e arquivos Docker Compose com múltiplos serviços.

Ferramentas relacionadas

Ver todas as ferramentas →

Decodificador e Codificador Base64

Codificação e Formatação

Decodifique e codifique Base64 online gratuitamente. Conversão em tempo real com suporte completo a UTF-8 e emoji. 100% privado — executa no seu navegador. Sem necessidade de cadastro.

Formatador e Validador JSON

Codificação e Formatação

Formate, valide e embeleze JSON instantaneamente no seu navegador. Ferramenta online gratuita com validação de sintaxe, detecção de erros, minificação e cópia com um clique. 100% privado — seus dados nunca saem do seu dispositivo.

Codificador e Decodificador de URL com Analisador Integrado

Codificação e Formatação

Cole uma URL para decodificar ou codificar em tempo real. Analisador de URL integrado decompõe cada componente em campos editáveis. Modo duplo: encodeURI e encodeURIComponent. Privado — nenhum dado enviado a servidor.

Conversor YAML para JSON

Codificação e Formatação

Cole YAML e obtenha JSON instantaneamente. Conversão ao vivo no navegador. Suporte a manifestos K8s, OpenAPI e valores Helm. 100% privado, sem upload.

Conversor de Base Numérica — Binário, Hex, Decimal e Octal

Ferramentas de Conversão

Converta números entre binário, hexadecimal, decimal, octal e qualquer base personalizada (2-36) instantaneamente. Gratuito, privado, sem cadastro — todo o processamento acontece no seu navegador.

Comprimir Imagens Online — JPEG, PNG e WebP

Ferramentas de Conversão

Reduza o tamanho de imagens em até 80% — comprima JPEG, PNG e WebP no navegador, sem upload. Lote de 20 imagens, ajuste de qualidade, compare antes e depois. Gratuito e privado.