JSON Editor online
Code

Export

My documents

Click a document to open it. They are stored only in this browser - nothing is uploaded. Clearing the browser's site data removes them, so download the ones you want to keep.

AI Assistant

Any AI can work with you - ChatGPT, Claude, Gemini, Copilot.

  1. Click Copy prompt.
  2. Paste it into your AI and say what it should change.
The AI should

The document travels in the link after the “#”, which no server sees. What you paste into your AI is handled by its provider.

Save to your server

The editor can send each saved version to your own server (a webhook), so your work is kept where you want it. Nothing is sent until you enter an address here.

What your server receives

A POST request with JSON (your server must allow CORS from https://json.giit.ch); content is the document as a string:

{ "editor": "json", "event": "save", "id": "…", "name": "Settings",
  "content": "{\n  \"debug\": false\n}\n",
  "updated": "2026-01-15T09:30:00.000Z" }
Embed the editor in your website 
<iframe src="https://json.giit.ch/?embed=1" style="width:100%;height:80vh;border:0"></iframe>
<script>
const frame = document.querySelector('iframe');
addEventListener('message', e => {
  if (e.origin !== 'https://json.giit.ch' || e.source !== frame.contentWindow) return;
  if (e.data.type === 'jsoneditor:ready')
    frame.contentWindow.postMessage({ type: 'jsoneditor:load', name: 'Settings',
      content: JSON.stringify(settings, null, 2) }, 'https://json.giit.ch');
  if (e.data.type === 'jsoneditor:save') saveOnYourServer(e.data.content);
});
</script>

Also possible: ?src=<URL of a .json file> opens a file, &webhook=<URL> saves this document there. The editor can also open in a window of its own (?embed=window), and your page can hand it its own AI prompt and a session key so the AI sends its result to your server (jsoneditor:ai, jsoneditor:key-request) - see "Use the editor on your own website" below the editor. Details are in llms.txt.

Help

How it works

  1. Write JSON on the left - or start with New and one of the templates. The tree in the middle shows the data as you type: objects and arrays fold, every value shows its type, {3} and [5] count the entries.
  2. Click a key or a value in the tree to change it right there. Enter or a click elsewhere writes the change into the code at exactly that place (one step for Undo), Escape cancels. The buttons above the tree add, duplicate, move and remove entries and change the type of a value.
  3. A click in the tree puts the code's cursor on that value; the cursor in the code marks its value in the tree. The path of the selected value ($.items[3].name) is below the tree.
  4. Problems (a missing comma, a duplicate key, what does not fit the schema) are listed above the code with line and column - click one to go there.
  5. Value on the right shows the selected key and value; Insert adds entries and pieces of code; Convert formats the document or converts it to YAML, CSV or XML; Schema checks it against a JSON Schema from your documents.
  6. My documents (the folder button at the top left) lists every document kept in this browser. Export saves it as JSON, minified JSON, YAML, CSV or text.

Keyboard shortcuts

↑ ↓ ← →
In the tree: go up and down, fold and unfold
Enter
In the tree: change the value (F2: the key)
Delete
In the tree: remove the entry
Alt + ↑ / ↓
In the tree: move the entry up / down
Ctrl + F
Search keys and values in the tree
Ctrl + Shift + F
Format the document
Tab / Shift + Tab
Indent / outdent in the code
Ctrl + Z / Y
Undo / redo
Ctrl + S / E
Save (download, or to your server) / export
Ctrl + O
My documents

Quotes and brackets close by themselves around a selection; Enter after { or [ indents the next line.

Edite JSON online, como código e como árvore

O Editor JSON mostra o seu código JSON e os dados em árvore lado a lado. Recolha objetos e arrays, veja o tipo e o número de entradas de cada valor e altere chaves e valores direto na árvore - a alteração vai para o código exatamente naquele lugar, e o resto do arquivo mantém a formatação. Os erros aparecem com linha e coluna, e os dados podem ser validados com um JSON Schema e convertidos para YAML, CSV ou XML.

Tudo roda no seu navegador. Os documentos não são enviados, não há cadastro nem publicidade.

O que o editor sabe fazer

Código e árvore

JSON com realce à esquerda, a árvore recolhível no meio. Um clique na árvore pula para o código, o cursor do código marca o valor dele na árvore, e o caminho ($.items[3].name) aparece sempre.

Edite na árvore

Altere chaves e valores, adicione, duplique, mova e remova entradas, mude um tipo - cada coisa como uma pequena edição do código, um passo para Desfazer.

Erros fáceis de achar

Uma vírgula ou umas aspas faltando, chaves duplicadas e valores que não batem com o seu JSON Schema, cada um com linha e coluna. JSON com comentários e JSON5 também são lidos.

Busca

Busque chaves e valores; cada resultado é marcado na árvore, e Enter vai para o próximo.

Converter

Formate, minifique e ordene chaves, ou converta para YAML, CSV (um array de objetos vira uma tabela) e XML. Arquivos YAML, CSV e XML abrem como JSON.

Muitos documentos

Guarde quantos documentos quiser no seu navegador, cada um com o próprio histórico de desfazer, e baixe todos em um ZIP.

Como funciona

  1. Comece - escolha um modelo em "Novo", abra um arquivo .json ou cole JSON.
  2. Edite - no código ou na árvore; os dois sempre mostram os mesmos dados.
  3. Valide e exporte - corrija os problemas listados, escolha um schema e baixe JSON, YAML, CSV ou texto.

Use o editor no seu próprio site

Qualquer página https (e localhost) pode incorporar o editor com um <iframe> e ?embed=1 - sem cadastro, sem chave. Incorporado, o editor oculta este texto e mostra um botão Salvar. Há dois jeitos de levar o documento para dentro e para fora.

1. Abrir um arquivo de um link, salvar no seu servidor

src= abre um arquivo (seu servidor precisa permitir CORS), webhook= faz "Salvar" (Ctrl+S) enviar o documento para esse endereço. Acrescente &token=… para um cabeçalho Authorization: Bearer … e &auto para salvar após cada alteração.

<iframe src="https://json.giit.ch/?embed=1&src=https://your-site.com/config/app.json&webhook=https://your-site.com/save.php"
        allow="clipboard-write" style="width:100%;height:800px;border:0"></iframe>

O webhook recebe um POST com JSON { editor: "json", event: "save", id, name, content, updated }; content é o documento como string. Um pequeno script PHP que o guarda:

<?php
header('Access-Control-Allow-Origin: https://json.giit.ch');
header('Access-Control-Allow-Headers: Content-Type, Authorization');
header('Access-Control-Allow-Methods: POST, OPTIONS');
if ($_SERVER['REQUEST_METHOD'] === 'OPTIONS') exit;
if (($_SERVER['HTTP_AUTHORIZATION'] ?? '') !== 'Bearer SECRET') { http_response_code(403); exit; }
$d = json_decode(file_get_contents('php://input'), true);
$name = preg_replace('/[^\w\- ]/u', '_', $d['name']);
file_put_contents(__DIR__ . "/config/$name.json", $d['content']);
echo '{"ok":true}';

2. A sua página guarda o documento (postMessage)

O editor diz jsoneditor:ready, a sua página responde com jsoneditor:load, o editor informa jsoneditor:loaded, jsoneditor:change em edições reais e jsoneditor:save quando o usuário salva. A sua página pode enviar jsoneditor:get (o estado atual) ou jsoneditor:save (apertar Salvar). Salvar passa então pelo seu próprio login e sessão.

<iframe id="ed" src="https://json.giit.ch/?embed=1" allow="clipboard-write" style="width:100%;height:800px;border:0"></iframe>
<script>
const ed = document.getElementById('ed');
const ORIGIN = 'https://json.giit.ch';

addEventListener('message', async e => {
  if (e.source !== ed.contentWindow || e.origin !== ORIGIN) return;
  const m = e.data;
  if (m.type === 'jsoneditor:ready') {              // o editor está pronto: entregue o documento a ele
    ed.contentWindow.postMessage({
      type: 'jsoneditor:load',
      name: 'Settings',
      content: await (await fetch('/config/app.json')).text()
    }, ORIGIN);
  }
  if (m.type === 'jsoneditor:change') document.title = '● not saved';   // uma edição real
  if (m.type === 'jsoneditor:save') {               // o usuário clicou em "Salvar"
    await fetch('/api/save', { method: 'POST', headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ name: m.name, content: m.content }) });
    document.title = 'Saved';
  }
});

// Um botão de salvar na sua própria página: a resposta chega como jsoneditor:save
function saveNow() { ed.contentWindow.postMessage({ type: 'jsoneditor:get' }, ORIGIN); }
</script>

Assistente de IA dentro da sua página: ele também funciona no frame. Com allow="clipboard-write" no iframe, "Copiar prompt" usa a área de transferência diretamente (senão o editor recorre ao antigo comando de copiar, ou mostra o prompt para copiar à mão). Um link enviado pela IA não alcança um editor dentro de outro site, então o editor pede à IA e ao usuário que colem a resposta inteira da IA no editor - ou abram o editor em uma janela própria.

3. Em uma janela própria

window.open("https://json.giit.ch/?embed=window", "jsoneditor-17") abre o editor completo em uma janela própria e troca as mesmas mensagens com window.opener. Os links de uma IA chegam até ele ali. jsoneditor:load também pode levar context: { host, title, rules } - o prompt da IA então diz a que lugar o documento pertence e segue as suas regras - e hook: { url, token }, um webhook só para este documento que nunca é guardado. Fechar a janela com alterações não salvas envia jsoneditor:closing.

4. IA pelo seu próprio servidor

Entregue ao editor o seu próprio prompt, um endereço no seu site e uma chave para esta sessão do editor. A janela de IA mostra então "Conectado a" o seu site, o que você diz à IA, e a escolha alterar o documento atual ou criar um novo; Copiar prompt junta tudo. A IA envia o resultado com a chave para o seu servidor, e a sua página o abre no editor - um novo documento abre separado e fica no navegador do usuário. Uma chave por sessão do editor: ela vale enquanto o editor estiver aberto, e só enquanto não tiver nenhuma o editor a pede com jsoneditor:key-request. O editor nunca envia a chave por conta própria e nunca a guarda; o endereço precisa ser https no seu próprio host ou em um subdomínio dele.

const key = async () => (await fetch('/api/ai-key.php?doc=17')).json();   // uma chave por sessão do editor
const k = await key();
ed.contentWindow.postMessage({ type: 'jsoneditor:load', name: 'Settings', content, ai: {
  label: 'My Site', prompt: 'Keep every key. Only change values.',
  endpoint: 'https://your-site.com/api/ai-result.php', key: k.key } }, ORIGIN);
// guarde o id de jsoneditor:loaded e ignore change/save/closing com outro id
// só enquanto o editor não tiver chave:
if (m.type === 'jsoneditor:key-request') { const k = await key(); ed.contentWindow.postMessage({ type: 'jsoneditor:ai', key: k.key }, ORIGIN); }
// enquanto o editor estiver aberto, avise o seu servidor a cada minuto; fechar o editor ou a página invalida a chave
setInterval(() => fetch('/api/ai-key.php?alive=' + k.key.slice(0, 8)), 60000);
// o seu servidor tem um resultado (polling, SSE …): target é "current" ou "new"
ed.contentWindow.postMessage({ type: 'jsoneditor:load', name: 'Settings', content: draft, from: 'ai', target }, ORIGIN);

Crie chaves com pelo menos 128 bits aleatórios, guarde só o hash delas, vincule cada uma ao usuário logado, ao documento e a esta sessão do editor, crie uma por sessão, mantenha-a válida só enquanto a sua página informar que a sessão está aberta, e invalide-a quando o editor ou a página fechar.

O protocolo completo está em llms.txt - entregue-o a uma IA e ela monta a conexão para o seu sistema. O Editor YAML funciona do mesmo jeito com o prefixo yamleditor: - yaml.giit.ch.

Perguntas frequentes

Meus dados são enviados para algum lugar?

Não. O editor roda inteiramente no seu navegador. Seus documentos nunca são enviados a um servidor, a não ser que você mesmo configure um webhook para o seu próprio servidor.

Posso editar os dados na árvore?

Sim. Clique em uma chave ou valor na árvore, digite e pressione Enter. A alteração é gravada no código exatamente naquele lugar - o resto mantém a formatação - e Desfazer volta atrás. Os botões acima da árvore adicionam, duplicam, movem e removem entradas e mudam o tipo de um valor.

Ele lê JSON com comentários ou JSON5?

Sim. Comentários, vírgulas sobrando no final, aspas simples e chaves sem aspas são lidos e mostrados na árvore, com um aviso de que não são JSON puro. "Formatar" escreve JSON puro.

Como valido meu JSON com um schema?

Abra ou cole o JSON Schema como um segundo documento e escolha-o na aba Schema. Cada lugar que não bate aparece com linha e coluna. O editor nunca baixa um schema da internet - um endereço $schema no documento é só exibido.

Ele converte JSON para YAML, CSV ou XML?

Sim, na aba Converter ou em Exportar. O CSV precisa de um array de objetos - cada objeto é uma linha. Arquivos YAML, CSV e XML que você abre são convertidos para JSON.

Onde meus documentos ficam salvos?

Só no seu navegador. Clique no botão de pasta no canto superior esquerdo (Meus documentos) para abrir, renomear, duplicar, baixar ou excluir os documentos. Limpar os dados do site no navegador os apaga, então baixe os que você quer manter - ou deixe o editor enviá-los ao seu próprio servidor ("Salvar no servidor").

Uma IA pode escrever no Editor JSON?

Sim, qualquer IA - ChatGPT, Claude, Gemini, Copilot ou a IA da sua ferramenta de programação. Clique em "Assistente de IA", depois em "Copiar prompt", cole na sua IA e diga o que ela deve alterar. A IA responde com um link; clique nele e os dados aparecem no seu editor. "Desfazer" desfaz qualquer alteração.

O Editor JSON custa alguma coisa?

Não. O editor é gratuito, sem anúncios e sem cadastro.