Gerador de JSON Schema
Gerar automaticamente definições JSON Schema em conformidade com padrões a partir de dados JSON
// O JSON Schema será gerado automaticamenteO 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
- Cole dados JSON na caixa de entrada à esquerda ou clique em Sample para carregar dados de exemplo
- Configure as opções: defina o ID do Schema, escolha se todos os campos são obrigatórios, adicione valores padrão, etc.
- A definição do JSON Schema correspondente é gerada automaticamente à direita
- Clique em Copy para copiar o Schema gerado para a área de transferência
- 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
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.