Formatador Pretty Print JSON

1. 1

   Cole ou envie o seu JSON

   Solte um arquivo .json, .jsonc, .ndjson, .jsonl ou .txt na página, escolha um com Procurar, ou abra o painel de colagem. JSON minificado, JSON com recuo e JSON Lines funcionam, e a ferramenta diz qual encontrou.

2. 2

   Escolha como a saída deve ficar

   Escolha Formatar ou Minificar e depois um recuo de 2 espaços, 4 espaços ou tabulação. Opcionalmente ordene as chaves, decida o que fazer com as duplicadas e escolha fins de linha LF ou CRLF. Tudo isso é gratuito.

3. 3

   Leia o resultado

   A visão Texto mostra a saída formatada com destaque de sintaxe. A visão Árvore permite recolher ramos inteiros e copiar o caminho JSON de qualquer valor. A visão Dados informa o que o documento contém, incluindo o que outro formatador teria alterado.

4. 4

   Conserte se estiver quebrado

   JSON inválido recebe uma mensagem, uma linha e uma coluna, e a linha problemática com um cursor sob o caractere exato. Se o problema puder ser reparado, aparece um botão Reparar que depois detalha exatamente o que mudou.

5. 5

   Baixe ou copie

   Baixe o arquivo formatado ou copie-o para a área de transferência. Tudo acontece no seu dispositivo, então nada é enviado e a ferramenta continua funcionando offline depois que a página carrega.

Este formatador JSON gratuito transforma JSON minificado ou difícil de ler numa saída clara e recuada, e devolve JSON recuado à sua menor forma válida. Cole ou envie o seu documento, escolha 2 ou 4 espaços ou uma tabulação, e leia o resultado como texto destacado, como árvore recolhível ou como um conjunto de estatísticas sobre o que o documento realmente contém. Se o JSON for inválido você recebe linha, coluna e a linha problemática marcada; se for reparável você recebe um reparo que detalha exatamente o que mudou. Tudo acontece no seu dispositivo, sem fila e sem envio.

• Pretty print e minificação — Converta JSON minificado ou bagunçado numa forma legível e recuada — ou retire de novo cada byte desnecessário. As duas direções são gratuitas e rodam na mesma passagem.
• Opções de recuo — 2 espaços, 4 espaços ou uma tabulação, em cada nível de aninhamento. Tabulações combinam com equipes cujo estilo as usa; a escolha muda os espaços e nada mais.
• Ordenar chaves, de quatro formas — Desligado, de A a Z, de Z a A, ou ordem natural que compara sequências de dígitos como números, então item2 vem antes de item10. É recursivo pelos objetos aninhados e sempre deixa a ordem dos arrays em paz.
• Visão em árvore com caminhos JSON — Recolha ramos inteiros para ver de relance o formato de uma resposta grande, e copie o caminho de qualquer valor — rows[0].meta.created — direto para o seu editor, o console ou o jq.
• Erros com linha e coluna — Uma mensagem específica, a posição exata, e a linha problemática impressa com um cursor embaixo. Não um deslocamento de caracteres dentro de um documento que pode ter uma única linha.
• Reparo para JSON quebrado — Vírgulas finais, aspas simples, chaves sem aspas, comentários, literais de Python, aspas tipográficas e vírgulas faltando. É opcional, e lista cada mudança em vez de devolver um arquivo corrigido e torcer para você concordar.
• JSON Lines e NDJSON — Um arquivo com um registro por linha é detectado automaticamente e continua JSON Lines válido, ou pode ser envolvido num array único se pedido.
• Colar, enviar, baixar, copiar — Cole da área de transferência, solte um arquivo, ou procure um. Leve o resultado como download ou direto para a área de transferência. Com o Pro você formata até 20 documentos e leva tudo num único ZIP.

Um formatador só pode mudar os espaços. Parece óbvio, e quase todo formatador JSON online quebra essa regra — incluindo os mais conhecidos — porque todos fazem a mesma coisa internamente: leem o seu documento como valores JavaScript com JSON.parse e os reescrevem com JSON.stringify. Essa ida e volta perde informação de cinco maneiras específicas, nenhuma das quais produz erro nem parece errada na saída. Esta ferramenta não faz isso. Cada número, cada string e cada chave é copiado do seu texto original caractere a caractere, então a única coisa que muda é o espaço entre eles.

• Inteiros longos sobrevivem — Números em JavaScript são de ponto flutuante de 64 bits, então qualquer inteiro acima de 9.007.199.254.740.991 perde os dígitos finais. 12345678901234567890 volta de uma ida e volta como 12345678901234567000. Isso é um snowflake ID, um id de objeto do Stripe ou uma chave primária de 64 bits virando outro valor num arquivo que você está prestes a commitar.
• Decimais de alta precisão sobrevivem — Uma coordenada com dezoito casas decimais é arredondada para o que um double comporta; um valor como 1e-400 vira 0 silenciosamente. Aqui os dois são copiados exatamente como escritos, inclusive a grafia: 1.10 continua 1.10 e 1e2 continua 1e2, em vez de virarem 1.1 e 100.
• Chaves duplicadas sobrevivem — JSON permite que um objeto nomeie a mesma chave duas vezes. Lê-lo como objeto JavaScript mantém só a última, então um formatador que faz a ida e volta apaga um membro em silêncio. Aqui os dois ficam, a visão Dados os conta, e o controle Chaves duplicadas permite resolvê-las para a primeira ou a última de propósito, não por acidente.
• A ordem das chaves sobrevive — Objetos JavaScript movem chaves parecidas com inteiros para o início, em ordem numérica. Um objeto escrito {"2": ..., "1": ..., "nome": ...} volta com 1 e 2 no começo, com a ordenação desligada, numa ferramenta cujo único trabalho era mudar os espaços.
• Escapes sobrevivem — Uma string escrita com \u00e9 ou com uma barra escapada é reescrita pela ida e volta como o caractere literal. É inofensivo para a maioria dos dados e não é inofensivo quando o arquivo é uma fixture, uma carga assinada ou qualquer coisa comparada byte a byte.
• E ele diz quando importou — A visão Dados informa quantos números teriam perdido precisão, quantas chaves duplicadas foram encontradas e quantas chaves teriam sido reordenadas — para você saber se a ferramenta que usou semana passada estava mudando os seus dados sem avisar.

JSON minificado economiza banda e é quase ilegível. Formatá-lo com recuo e quebras de linha torna a estrutura óbvia, então você pode depurar uma configuração, inspecionar uma resposta de API ou preparar um trecho para a documentação sem contar colchetes. O contrário é igualmente útil: minificar um documento antes de enviá-lo tira todos os bytes que só existiam para olhos humanos. Ordenar as chaves dá uma ordem estável para que os diffs mostrem mudanças reais, e a visão em árvore responde à pergunta que uma resposta longa costuma levantar primeiro: qual é o formato disto.

• Legibilidade — JSON recuado revela aninhamento, arrays e campos faltando de relance. Uma resposta de 40 linhas vira algo que você lê em vez de analisar de cabeça.
• Diffs estáveis — Chaves ordenadas tiram o ruído de reordenação do controle de versão, então um pull request mostra os valores que mudaram e não a ordem em que foram escritos.
• Cargas menores — Minificar tira recuo e quebras de linha de um documento que não precisa mais deles. Numa carga de API típica isso é cerca de 45 por cento de economia.
• Entender o formato — A visão em árvore recolhe ramos para que uma resposta de mil linhas caiba numa tela como um esquema, e cada linha pode lhe dar o caminho até o valor procurado.
• Idas e voltas confiáveis — Como nada é reserializado através de valores JavaScript, formatar e depois minificar devolve um documento que significa exatamente o que o original significava.

Quando o JSON não é analisado, o que interessa é onde ele parou e o que encontrou ali. Esta ferramenta informa uma causa específica, a linha e a coluna, e imprime a linha problemática com um cursor sob o caractere exato. Isso importa sobretudo num documento minificado, onde um deslocamento de caracteres dentro de uma única linha de 200.000 caracteres não diz nada. Estas são as causas que realmente aparecem, mais ou menos por frequência.

• Vírgula final — Uma vírgula antes de uma chave ou colchete de fechamento. Legal em JavaScript e em JSON5, não em JSON. Relatada na vírgula, e não como uma reclamação confusa sobre o colchete seguinte.
• Aspas simples — 'chave': 'valor' é JavaScript, não JSON. Strings JSON usam aspas duplas, sempre. O reparo as converte, escapando as aspas duplas que houver dentro.
• Chaves sem aspas — {chave: 1} é um literal de objeto JavaScript. JSON exige que toda chave seja uma string entre aspas.
• Comentários — // e /* */ são comuns em configurações escritas à mão e não fazem parte de JSON. Arquivos que os usam costumam se chamar .jsonc; o reparo os remove.
• NaN, Infinity e literais de Python — Nem NaN, nem Infinity, nem True, False, None ou undefined existem em JSON. Chegam o tempo todo do print do Python e de consoles JavaScript. O reparo os mapeia para null, true e false.
• Quebras de linha cruas em strings — Uma quebra de linha literal dentro de uma string é ilegal — precisa ser escrita como \n. É o que acontece quando alguém cola uma mensagem de várias linhas num arquivo JSON à mão.
• Dois documentos num arquivo — Conteúdo depois do fim do primeiro valor. Muitas vezes isso não é erro nenhum, e sim JSON Lines, que esta ferramenta detecta e formata em vez de rejeitar.

O reparo é uma caixa de seleção, não um padrão, e isso é deliberado: reparar é tomar uma decisão sobre os dados de outra pessoa. Uma vírgula faltando pode ir em dois lugares; uma barra invertida solta pode ser apagada ou escapada. Então o reparo só roda quando você pede, e quando roda ele informa cada mudança e quantas vezes, na visão Dados, ao lado do resultado. Ele também nunca mexe no interior de uma string: o documento é relido com uma versão permissiva do mesmo leitor que o rejeitou, e JSON canônico é reescrito a partir dos tokens, então uma vírgula dentro de um valor entre aspas nunca é confundida com estrutura.

• O que conserta — Vírgulas finais, vírgulas faltando, dois-pontos faltando, strings com aspas simples e tipográficas, chaves sem aspas, comentários //, /* */ e #, NaN e Infinity, os True, False e None do Python, undefined, números hexadecimais e com sinal de mais inicial, caracteres de controle crus em strings, strings não terminadas e colchetes não fechados no fim do arquivo.
• O que preserva — Tudo o que o caminho estrito preserva. Um documento reparado mantém os inteiros longos, as chaves duplicadas e a ordem das chaves — o reparo conserta a sintaxe e deixa os valores em paz.
• Como trata uma barra solta — Uma barra invertida que o JSON não define é escapada em vez de apagada. C:\qux vira C:\\qux, que devolve exatamente o que estava escrito; apagar a barra mudaria em silêncio um caminho do Windows, que é o que a maioria das ferramentas de reparo faz.
• O que não faz — Não adivinha conteúdo. Se um membro tem chave e não tem valor, vira null e diz isso; se não há nada recuperável no arquivo, ele diz isso, em vez de devolver um documento vazio que depois falha na análise.

Muitíssimos arquivos com extensão .json não são um documento JSON. Logs de aplicação, exportações do BigQuery e do Athena, dumps do Kafka e arquivos de lote da OpenAI são todos JSON Lines: um valor JSON completo por linha, sem array envolvendo e sem vírgulas entre registros. Entregues a um formatador normal, produzem um erro sobre conteúdo inesperado depois do primeiro registro — tecnicamente correto e completamente inútil como afirmação sobre um arquivo válido num formato comum.

• Detectado, não configurado — O formato é deduzido lendo o documento, não olhando a extensão: muitos arquivos JSON Lines se chamam .json, e um documento recuado está cheio de quebras de linha e enganaria qualquer palpite baseado em contar linhas.
• Ainda um registro por linha — Por padrão cada registro é reescrito minificado na própria linha, porque um registro recuado em várias linhas deixa de ser JSON Lines. O controle de recuo se desliga enquanto isso vale e explica por quê, em vez de ficar ali fingindo fazer algo.
• Ou um array — Mude para Array único e os registros são envolvidos num único array JSON, formatado com o seu recuo — geralmente o que você quer antes de entregar os dados a algo que espera um documento só.
• Ordenação e reparo continuam valendo — Todos os outros ajustes funcionam por registro: ordenar chaves, tratar duplicadas, fins de linha e reparo se comportam igual, tenha o arquivo um registro ou um milhão.

• Saída — Formatar para JSON legível e recuado; Minificar para a menor forma válida. As duas são gratuitas.
• Recuo — 2 espaços, 4 espaços ou tabulação, em cada nível de aninhamento. Inativo enquanto Minificar está selecionado e enquanto os registros JSON Lines ficam um por linha.
• Ordenar chaves — Desligado, de A a Z, de Z a A, ou ordem natural. Recursivo pelos objetos aninhados; arrays sempre mantêm a ordem.
• Chaves duplicadas — Manter as duas, a primeira ou a última. Manter as duas é o padrão porque é a única opção que não apaga dados.
• JSON Lines — Um registro por linha, ou todos os registros num array único. Só faz sentido quando a entrada tem mais de um registro de nível superior.
• Fim de linha — LF para Unix e para tudo que vai ao controle de versão; CRLF para arquivos que serão abertos no Bloco de Notas do Windows.
• Quebra de linha final — Termina o arquivo com uma quebra de linha, que é o que ferramentas POSIX e a maioria dos linters esperam.
• Reparar JSON inválido — Desligado por padrão. Quando ligado, problemas comuns de sintaxe são corrigidos antes de formatar e cada mudança é listada.
• Nome do arquivo de saída (Pro) — Dê você mesmo o nome do arquivo baixado. O nome padrão vem da entrada, então isso é comodidade e não uma capacidade que falta.

Um documento de 25 MB é formatado em menos de meio segundo num notebook atual, fora da thread principal, então a página nunca congela.

• Validador JSON
• Minificador JSON
• Visualizador JSON
• Comparar JSON
• Ordenar chaves JSON
• Remover chaves JSON
• Mesclar JSON
• Escapar JSON
• JSON para XML
• JSON para YAML
• XML para JSON
• YAML para JSON
• CSV para JSON
• JSON para CSV
• Excel para JSON
• Todas as ferramentas JSON