ToolActToolAct

Gerador de JSON Schema

Gerar automaticamente definições JSON Schema em conformidade com padrões a partir de dados JSON

Entrada JSON
Linhas: 1 | Caracteres: 0
Saída JSON Schema
// O JSON Schema será gerado automaticamente
Propriedades: 0 | Linhas: 1

Opções de configuração

Schema ID
Definir um identificador único para o Schema, tipicamente em formato URI, usado para referenciar e identificar Schema em grandes sistemas
Todos os campos obrigatórios
Quando habilitado, todas as propriedades são adicionadas ao array required, significando que esses campos devem existir nos dados
Adicionar valores padrão
Gerar automaticamente propriedade default baseada nos valores reais no JSON exemplo, útil para arquivos de configuração
Adicionar descrições de campo
Adicionar automaticamente campo description para cada propriedade, descrevendo tipo de dados e origem, útil para documentação
Modo estrito
Habilitar additionalProperties: false para proibir propriedades extras não definidas, garantindo consistência estrita da estrutura de dados

O que é JSON Schema?

JSON Schema é uma especificação para descrever e validar estruturas de dados JSON. Define regras para estrutura, tipos de dados, restrições e é amplamente usado para validação de API, validação de formulários, verificação de arquivos de configuração.

Com JSON Schema, você pode:

  • Validação de dados: Verificar se os dados JSON correspondem ao formato e restrições esperados
  • Geração de documentação: Gerar automaticamente documentação de API e definições de tipos
  • Inteligência de código: Obter autocompletar inteligente e verificação de tipos em IDEs
  • Testes automatizados: Validar automaticamente formato de dados de resposta em testes

Esta ferramenta suporta a especificação JSON Schema Draft-07, inferindo inteligentemente objetos aninhados, tipos de array, valores enum e outras estruturas complexas.

Como Usar

Como usar

  1. Cole dados JSON na caixa de entrada à esquerda ou clique em Sample para carregar dados de exemplo
  2. Configure as opções: defina o ID do Schema, escolha se todos os campos são obrigatórios, adicione valores padrão, etc.
  3. A definição do JSON Schema correspondente é gerada automaticamente à direita
  4. Clique em Copy para copiar o Schema gerado para a área de transferência
  5. Use o Schema para validação de API, validação de formulário ou verificação de arquivos de configuração

Dicas sobre Schema

  • Os schemas gerados refletem o JSON de exemplo fornecido; inclua campos opcionais representativos, valores nulos, arrays e casos extremos antes de copiar o resultado.
  • Revise manualmente os campos obrigatórios e formatos numéricos/string; a inferência baseada em exemplo nem sempre conhece suas regras de negócio.

Casos de uso

Criar schemas a partir de exemplos reais de APICole uma resposta JSON representativa e gere um schema draft-07 que captura propriedades do objeto, tipos primitivos, arrays aninhados, valores padrão e campos obrigatórios. Isso oferece às equipes de backend e frontend um ponto de partida concreto antes de refinar manualmente os casos extremos. Um exemplo real é melhor do que adivinhar, pois campos obrigatórios versus opcionais e pertencimento a enums são inferidos a partir do que realmente aparece nos dados.
Documentar arquivos de configuraçãoPara exemplos de configuração interna, ative valores padrão e descrições para produzir um schema útil em editores e documentação. O modo estrito pode adicionar additionalProperties: false, o que torna mais fácil detectar chaves acidentais quando o schema é integrado à validação. Combine o schema com uma verificação de CI que falha quando um arquivo de configuração deixa de corresponder ao seu contrato.
Explorar a forma dos dados antes do trabalho de validaçãoO gerador relata a contagem de propriedades e infere arrays a partir dos itens do exemplo, ajudando a visualizar rapidamente a amplitude aproximada de um payload. É especialmente prático para criação inicial de schema quando existe um exemplo ao vivo, mas ainda não foi escrito um contrato formal. Uma vez mapeada a forma, passe o schema para um gerador de tipos para uma ligação tipada mais forte.
Refinar tipos inferidos com dicas nullable e requiredUse as opções strict e nullable para que o schema draft-07 gerado marque campos opcionais corretamente, em vez de assumir que toda chave está sempre presente. Revise manualmente o array required resultante, pois uma única amostra de valor ausente pode ocultar um campo que é obrigatório no servidor. Alterne o tratamento nullable separadamente do required para que um campo que permite null, mas ainda é esperado, possa ser modelado com precisão.
Distinguir draft-07 do 2020-12 e inferência de enumsEste gerador emite JSON Schema draft-07 por padrão, que ainda é o mais amplamente suportado pelo Ajv, jsonschema e bibliotecas de formulários; projetos mais recentes podem querer atualizar manualmente para 2020-12 para usar if/then/else, prefixItems ou a palavra-chave const. A inferência de enums é baseada em heurística: quando um campo string tem menos de ~10 valores distintos nas amostras, ele é automaticamente promovido a enum, então verifique novamente um campo como status que deve permanecer livre. Trate o schema draft-07 gerado como um rascunho inicial e depois converta para 2020-12 com um transformador se a biblioteca consumidora suportar.

Princípio técnico

JSON Schema é um vocabulário declarativo para anotar e validar documentos JSON, definido em múltiplos rascunhos IETF (Draft 4 / 6 / 7 / 2019-09 / 2020-12). O mais recente é o Draft 2020-12, que define sete tipos primitivos (string, number, integer, boolean, array, object, null), um vocabulário de formato aberto (email, uri, date-time, uuid, ipv4, hostname, ...) e dezenas de palavras-chave de restrição: pattern (regex), minimum/maximum/exclusiveMinimum/exclusiveMaximum (intervalo numérico), minLength/maxLength (comprimento da string), minItems/maxItems/uniqueItems (restrições de array), required (array de campos obrigatórios no nível do objeto), additionalProperties (se campos extras são permitidos), enum e const (valores permitidos) e $ref (reuso de subesquema). A página gera saída Draft 2020-12 por padrão, com o Draft-07 mais antigo (ainda o mais comum em schemas de produção) selecionável no menu suspenso. A inferência do gerador é uma única passagem sobre o JSON fornecido pelo usuário, construindo um objeto schema recursivamente. O mapeamento central da inferência é: integer (Number.isInteger e sem parte fracionária) -> {type: 'integer'}, float -> {type: 'number'}, string -> {type: 'string'}, boolean -> {type: 'boolean'}, array -> {type: 'array', items: <recursão no primeiro elemento>} ou {type: 'array', prefixItems: [...]} para tuplas no Draft 2020-12, object -> {type: 'object', properties: <recursão em cada chave>}, null -> {type: 'null'}. Para arrays com tipos de elementos mistos, o gerador emite um subschema oneOf cobrindo cada tipo observado. Para múltiplos objetos de amostra, o gerador os compara para montar a lista de required: uma chave é obrigatória se aparece em todas as amostras, opcional se alguma amostra a omite. Padrões e restrições são inferidos quando as amostras se agrupam: se todos os números em um campo caem em [1, 100], o gerador emite {type: 'integer', minimum: 1, maximum: 100}; se um campo string é sempre um UUID, o gerador o marca com format: 'uuid' e emite um regex pattern: '^[0-9a-f]{8}-...'. A heurística de enum dispara quando um campo string assume ≤10 valores distintos nas amostras (ex.: role: 'admin' | 'editor' | 'viewer' todos observados), caso em que o gerador emite um array enum. Objetos profundamente aninhados e estruturas recursivas são extraídos para uma seção $defs (Draft 2020-12; o $definitions mais antigo é a palavra-chave do Draft-07) e referenciados via $ref. Estruturas recursivas — ex.: um nó de árvore com um campo 'children' do tipo nó de árvore — recebem um stub $ref apontando para a entrada $defs do pai, que o resolvedor resolve no momento da validação. O gerador escolhe automaticamente a troca certa entre ref e inline: schemas rasos ficam inline, profundos são divididos em definições para manter a saída legível. Schemas gerados são determinísticos para uma entrada dada: as mesmas amostras JSON sempre produzem o mesmo schema, e o gerador é implementado em JavaScript puro sem chamadas remotas.

  • Regras de inferência de tipo: números inteiros -> integer, ponto flutuante -> number, strings -> string, booleanos -> boolean, arrays -> array + items, objects -> object + properties. JSON null -> type: null (Draft 6+) ou string type: 'null'.
  • Detecção de campos obrigatórios: comparando todos os objetos de amostra, campos presentes em todos os objetos são tratados como obrigatórios e adicionados ao array required; campos ausentes são opcionais. Entrada com uma única amostra deixa required: [] pois a heurística precisa de pelo menos duas amostras.
  • Heurística de inferência de enum: quando um campo assume um conjunto pequeno e finito de valores string distintos nas amostras (cardinalidade <= 10), ele é automaticamente reconhecido como uma restrição enum. Cardinalidades maiores permanecem como tipo string simples.
  • Formato auto-detectado: com base em assinaturas de string, campos são marcados com dicas de formato como email, uri, date-time, uuid para documentação e validação. A palavra-chave format é informativa no Draft 2020-12 — resolvedores podem escolher aplicar ou ignorar.
  • Extração de $ref aninhado: objetos profundamente aninhados são extraídos para $defs internos (palavra-chave do Draft 2020-12; o $definitions mais antigo é do Draft 7) e referenciados via $ref, evitando que o Schema fique muito verboso. Estruturas recursivas recebem um stub $ref apontando para a entrada $defs do pai.
  • Expansão de restrições: além dos tipos básicos, você também pode adicionar minimum/maximum (intervalo numérico), minLength/maxLength (comprimento da string), pattern (regex) e restrições semelhantes. O gerador emite essas restrições quando as amostras de entrada se agrupam em valores específicos.
  • Seleção de Draft: 2020-12 (o mais recente) é o padrão e usa $defs; 2019-09 também usa $defs; Draft-07 usa $definitions e é o que a maioria das ferramentas existentes ainda emite. O Draft 6 introduziu semântica estrita de required, onde campos obrigatórios são listados no array required do pai em vez de como propriedade irmã.
  • Palavras-chave de composição (Draft 2019-09+): allOf (deve corresponder a todos os subschemas), anyOf (pelo menos um), oneOf (exatamente um), not (não deve corresponder). O gerador escolhe oneOf quando os valores de amostra se encaixam em dois subschemas disjuntos (ex.: integer vs string).

Exemplos

Objeto simples -> Schema

{"name": "Alice", "age": 25}
->
{
  "type": "object",
  "properties": {
    "name": { "type": "string" },
    "age": { "type": "integer" }
  },
  "required": ["name", "age"]
}

Schema com array

{"tags": ["js", "ts"]}
->
{
  "type": "object",
  "properties": {
    "tags": {
      "type": "array",
      "items": { "type": "string" }
    }
  }
}

Schema com enum

{"role": "admin"}
->
{
  "type": "object",
  "properties": {
    "role": { "type": "string", "enum": ["admin", "user", "guest"] }
  }
}

Perguntas frequentes

O que é JSON Schema?

JSON Schema (atualmente no draft 2020-12) é um vocabulário para validar documentos JSON. Ele descreve o formato esperado de um documento — quais campos existem, seus tipos, intervalos e padrões — semelhante ao XML Schema ou aos tipos do TypeScript. Ferramentas como Ajv, Hyperjump e a maioria dos frameworks de API o consomem para validação em tempo de execução.

Qual draft de JSON Schema o gerador produz?

Drafts modernos (normalmente 2020-12 ou draft-07). A saída começa com $schema declarando a versão, $id quando aplicável, type e as palavras-chave apropriadas para objetos, arrays, strings, números, booleanos e null. Mude a opção de draft se seu validador exigir uma versão antiga específica.

Como ele infere tipos a partir de uma amostra JSON?

Ele percorre a amostra registrando o tipo de cada propriedade. Para arrays, infere o schema dos itens a partir de um ou mais elementos (fazendo a união se os elementos diferem). Para propriedades com tipos mistos, usa oneOf ou anyOf. O resultado é um schema inicial permissivo; aperte as restrições (required, minLength, pattern) manualmente.

Todas as propriedades são marcadas como obrigatórias?

É configurável. O padrão é marcar como obrigatória toda propriedade observada. Ative 'todas opcionais' se sua amostra é apenas um exemplo e outras instâncias podem legitimamente omitir campos. Você pode editar o array required após a geração.

Como objetos e arrays aninhados são tratados?

Objetos aninhados se tornam blocos 'properties' aninhados; arrays se tornam definições 'items'. Aninhamento profundo funciona normalmente. Se a mesma estrutura aparece repetidamente, você pode refatorar com $defs / $ref depois — o gerador não faz desduplicação automática.

O que ele não consegue inferir a partir das amostras?

Restrições de format (date-time, email, uuid), pertinência a enum, padrões de regex, minimum/maximum, minItems/maxItems e dependências precisam ser adicionadas manualmente, porque uma única amostra não revela isso. Use o schema gerado como esqueleto e depois aperte as regras.

Meu JSON é enviado para algum servidor?

Não. A inferência roda localmente. O JSON colado não sai do seu navegador.