DEV Community

Cover image for Como Criar um Mock de API no Apidog Sem Programar
Lucas
Lucas

Posted on • Originally published at apidog.com

Como Criar um Mock de API no Apidog Sem Programar

Sua equipe de frontend está bloqueada: GET /users e GET /orders ainda não existem no backend, mas a UI precisa renderizar listas, paginação, estados vazios e erros com dados plausíveis. Em vez de manter arquivos JSON manuais que se desatualizam do contrato, use o esquema da API como fonte única de verdade para gerar mocks.

Experimente o Apidog hoje

Se você já tem uma especificação, o Apidog pode gerar respostas mock diretamente do esquema do endpoint, sem escrever um servidor ou manter fixtures. Esse recurso, chamado Smart Mock, usa os tipos e nomes das propriedades para produzir valores plausíveis: name gera nomes, email gera e-mails e createdAt gera timestamps. Para contexto adicional, veja o que é e como funciona o mocking de API e a documentação do JSON Schema.

O que o Smart Mock faz

O mecanismo de mock do Apidog pode responder de cinco formas:

  1. Smart Mock: gera dados a partir do esquema da API.
  2. Exemplo de resposta: retorna um exemplo definido na especificação.
  3. Resposta personalizada: retorna um corpo configurado manualmente.
  4. Mocking condicional: escolhe respostas conforme parâmetros da requisição.
  5. Scripts de mock: gera valores relacionados aos dados enviados na requisição.

Recursos de mock do Apidog

O Smart Mock é a opção sem configuração. Basta que o endpoint tenha um esquema de resposta: o Apidog lê esse contrato e preenche os campos automaticamente.

Na prática, isso evita divergência entre mock e API real:

  • você altera o esquema;
  • o mock passa a refletir o novo esquema;
  • o frontend continua usando a mesma URL de mock.

Pré-requisito: defina a resposta do endpoint

O Smart Mock precisa de um esquema de resposta. Se você criou a API no Apidog, adicione-o na definição de resposta do endpoint. Se importou uma especificação OpenAPI, os schemas normalmente já vêm no arquivo.

Sem uma resposta definida, o mecanismo não tem como inferir os campos e tipos a retornar.

Para usar o Local Mock, instale o cliente desktop do Apidog. Ele não está disponível na versão web. Baixe o Apidog para acompanhar.

Tutorial: mock de GET /users e GET /orders

Vamos configurar dois endpoints de uma API simples de e-commerce e consumi-los com curl.

1. Defina GET /users

Crie o endpoint GET /users e configure uma resposta com este formato:

{
  "id": 1024,
  "name": "Amara Osei",
  "email": "amara.osei@example.com",
  "phone": "+1-415-555-0148",
  "createdAt": "2026-03-11T09:24:00Z",
  "isActive": true
}
Enter fullscreen mode Exit fullscreen mode

Mais importante do que os valores do exemplo é definir corretamente os tipos de cada propriedade:

  • id: número inteiro;
  • name, email, phone: string;
  • createdAt: string em formato de data/hora;
  • isActive: booleano.

2. Defina GET /orders

Agora crie GET /orders com uma resposta em lista:

[
  {
    "orderId": "ORD-58210",
    "userId": 1024,
    "total": 84.5,
    "currency": "USD",
    "status": "shipped",
    "createdAt": "2026-05-02T14:03:00Z"
  }
]
Enter fullscreen mode Exit fullscreen mode

Defina os tipos no schema para que o Smart Mock possa gerar valores coerentes para IDs, totais, status e datas.

3. Copie a URL de mock

Cada endpoint recebe uma URL de mock automaticamente.

Você pode encontrá-la em:

  • Modo DESIGN: aba API, dentro do endpoint;
  • Modo DEBUG: aba Mock.

Use Clique para copiar para obter a URL. Esse botão copia somente a URL: se o endpoint exigir outro método HTTP ou um corpo de requisição, informe-os ao fazer a chamada.

No Local Mock, a URL usa 127.0.0.1:4523. No modo de caminho, ela segue este formato:

http://127.0.0.1:4523/m1/{projectID}-{versionNo}-{serverNo}/users
Enter fullscreen mode Exit fullscreen mode

Também existe o modo baseado no ID do endpoint:

http://127.0.0.1:4523/m2/{projectID}-{versionNo}-{serverNo}/{endpointId}
Enter fullscreen mode Exit fullscreen mode

4. Consuma o mock

Com o cliente Apidog aberto, chame GET /users:

curl http://127.0.0.1:4523/m1/1234567-0-0/users
Enter fullscreen mode Exit fullscreen mode

A resposta será semelhante a esta:

{
  "id": 3187,
  "name": "Diego Marchetti",
  "email": "diego.marchetti@example.net",
  "phone": "+1-628-555-0113",
  "createdAt": "2026-01-27T18:41:22Z",
  "isActive": true
}
Enter fullscreen mode Exit fullscreen mode

O valor de name parece um nome e email parece um e-mail porque o Smart Mock considera o nome da propriedade, não apenas o tipo. Ao repetir a chamada, valores dinâmicos podem ser regenerados.

Faça o mesmo para pedidos:

curl http://127.0.0.1:4523/m1/1234567-0-0/orders
Enter fullscreen mode Exit fullscreen mode

Você receberá uma lista de pedidos com valores apropriados para total, status e createdAt, pronta para conectar à tela de pedidos do frontend.

Como o Smart Mock escolhe os valores

Para cada propriedade, o Smart Mock usa esta ordem de prioridade:

  1. Campo de Mock
  2. Correspondência por Nome de Propriedade
  3. Restrições do JSON Schema

Prioridade de geração do Smart Mock

1. Campo de Mock

Se você definir um valor ou expressão no Campo de Mock da propriedade, essa configuração vence as demais.

Use:

  • Valor Fixo para retornar sempre o mesmo valor;
  • Instrução Faker para gerar valores dinâmicos.

Por exemplo, para garantir que status use apenas valores do domínio da aplicação, configure uma expressão que escolha entre:

shipped
pending
delivered
Enter fullscreen mode Exit fullscreen mode

2. Correspondência por Nome de Propriedade

Sem um Campo de Mock explícito, o Apidog tenta reconhecer o nome da propriedade usando regras internas.

Por isso, campos como estes normalmente recebem dados adequados:

{
  "email": "user@example.com",
  "createdAt": "2026-01-27T18:41:22Z",
  "phone": "+1-628-555-0113"
}
Enter fullscreen mode Exit fullscreen mode

As regras podem ser ajustadas em Configurações de Mock.

3. JSON Schema

Se não houver Campo de Mock nem regra baseada no nome, o Smart Mock usa o tipo e as restrições do schema.

Aproveite isso para tornar o mock mais previsível:

{
  "type": "object",
  "properties": {
    "status": {
      "type": "string",
      "enum": ["pending", "shipped", "delivered"]
    },
    "total": {
      "type": "number",
      "minimum": 1,
      "maximum": 10000
    },
    "items": {
      "type": "array",
      "minItems": 3
    }
  }
}
Enter fullscreen mode Exit fullscreen mode

Com esse schema:

  • status será sempre um dos três valores definidos;
  • total ficará dentro do intervalo configurado;
  • items terá pelo menos três elementos.

O Apidog também suporta localidades de mock, o que ajuda quando a aplicação precisa de dados em formatos regionais específicos, como nomes e endereços japoneses.

Quando o Smart Mock não gera o valor esperado

O Smart Mock faz inferências. Campos como sku podem resultar em strings genéricas, e total pode não seguir o formato de negócio esperado sem restrições adicionais.

Ajuste em três níveis, nesta ordem.

Aperte o schema

Comece definindo melhor as restrições:

{
  "sku": {
    "type": "string",
    "pattern": "^[A-Z]{3}-[0-9]{6}$"
  },
  "total": {
    "type": "number",
    "minimum": 0.01,
    "maximum": 9999.99
  },
  "status": {
    "type": "string",
    "enum": ["pending", "shipped", "delivered"]
  }
}
Enter fullscreen mode Exit fullscreen mode

Isso é preferível a uma regra manual quando o comportamento pode ser descrito no contrato.

Configure um Campo de Mock

Use um Campo de Mock quando o schema não for suficiente.

Exemplos:

  • defina currency como valor fixo USD;
  • use uma instrução Faker para gerar códigos ou dados variados;
  • controle campos específicos sem alterar os demais.

A camada Faker do Apidog segue conceitos semelhantes aos da biblioteca Mock.js. Para exemplos de sintaxe, veja o guia de como usar o Faker no Apidog.

Adicione uma regra por nome de propriedade

Se sku aparece em vários endpoints e deve seguir sempre o mesmo padrão, crie uma regra global:

  1. Abra Configurações.
  2. Vá para Configurações Gerais.
  3. Abra Configurações de Recursos.
  4. Acesse Configurações de Mock.
  5. Clique em Novo.
  6. Defina a condição para o nome sku.
  7. Associe uma expressão de mock.

A partir desse ponto, todo campo sku do projeto seguirá a regra definida.

Prioridade entre Expectativas, exemplos e Smart Mock

Quando um endpoint pode devolver mais de uma resposta, o Apidog usa o método de mock padrão configurado em Configurações do Projeto > Configurações de Mock.

As opções são:

  • Smart Mock Primeiro: Expectativa de Mock → Smart Mock
  • Exemplo de resposta primeiro: Expectativa de Mock → Exemplo de Resposta → Smart Mock

Leia a sequência da esquerda para a direita.

No modo padrão, o Apidog procura primeiro uma Expectativa de Mock que corresponda à requisição. Se não encontrar, gera a resposta com Smart Mock.

No modo Exemplo de resposta primeiro, um exemplo de resposta definido no endpoint é usado antes do Smart Mock.

As Expectativas de Mock sempre têm prioridade máxima quando suas condições correspondem. Por exemplo, você pode retornar 404 para um usuário específico:

userId = 9999
Enter fullscreen mode Exit fullscreen mode

Mesmo que exista um exemplo de resposta ou Smart Mock configurado, essa expectativa será aplicada primeiro. Para configurar esse fluxo, veja o guia de mocking de respostas de API condicionais no Apidog.

Resumo:

Expectativa de Mock > Exemplo ou Smart Mock > fallback
Enter fullscreen mode Exit fullscreen mode

Local Mock, Cloud Mock e Runner Mock

Smart Mock e Custom Mock definem como a resposta é gerada. Local, Cloud e Runner definem onde ela é executada.

Local Mock

O Local Mock roda no seu computador pelo cliente Apidog.

  • Escuta em 127.0.0.1:4523;
  • inicia enquanto o cliente Apidog está aberto;
  • não está disponível no Apidog Web;
  • é indicado para desenvolvimento local e trabalho individual.

Cloud Mock

O Cloud Mock é hospedado nos servidores do Apidog.

  • Pode ser acessado continuamente;
  • fica desativado por padrão;
  • deve ser ativado no gerenciamento de ambiente;
  • usa URLs em https://mock.apidog.com;
  • é destinado a testes, não a tráfego de produção.

Use-o quando outros desenvolvedores, um ambiente de preview ou testes remotos precisarem acessar o mock.

Runner Mock

O Runner Mock é auto-hospedado na infraestrutura da sua equipe. Ele é útil quando o mock precisa permanecer em uma rede interna ou sob controle do seu ambiente.

Escolha conforme o cenário:

Cenário Opção recomendada
Desenvolvimento local Local Mock
Compartilhar com colegas ou preview Cloud Mock
Ambiente interno auto-hospedado Runner Mock

Compare alternativas no artigo sobre ferramentas de mocking de API online e consulte o guia do Apidog Cloud Mock para detalhes de configuração.

Detalhes de roteamento importantes

Algumas regras evitam erros comuns ao chamar URLs de mock.

O caminho deve começar com /

Use:

/orders
Enter fullscreen mode Exit fullscreen mode

Uma URL completa que não começa com / não usará o ambiente de mock. Um caminho sem barra inicial funciona apenas no modo baseado em ID.

APIs com mesmo método e caminho

Se duas APIs têm o mesmo método HTTP e o mesmo caminho, o modo de caminho não consegue distingui-las sozinho.

Adicione o parâmetro abaixo para selecionar o endpoint correto:

?apidogApiId={endpointId}
Enter fullscreen mode Exit fullscreen mode

Cada requisição pode gerar dados novos

Valores dinâmicos são regenerados quando você faz uma nova requisição. Se a resposta parecer idêntica em chamadas diferentes, confirme se o cliente, navegador ou proxy não está exibindo conteúdo em cache.

Use o Apidog CLI para manter o contrato atualizado

O Apidog CLI não inicia nem hospeda um servidor de mock pelo terminal. Local Mock, Cloud Mock e Runner Mock continuam sendo responsáveis por servir as respostas.

O papel do CLI é manter o contrato por trás do mock atualizado à medida que a API evolui.

Como o Smart Mock depende do schema, um schema correto produz mocks mais úteis. O CLI e agentes de codificação de IA, como Cursor, Claude Code, Trae e Codex, podem ajudar a criar e atualizar endpoints e schemas no projeto.

Depois que o mock desbloqueia o frontend, execute os cenários do projeto no CI para validar o backend real contra o mesmo contrato:

apidog run -t <scenario_id> -e <env_id> -r html,cli
Enter fullscreen mode Exit fullscreen mode

Instale o CLI:

npm install -g apidog-cli
Enter fullscreen mode Exit fullscreen mode

Autentique usando um token:

apidog login --with-token <seu-token>
Enter fullscreen mode Exit fullscreen mode

O requisito é Node.js v16 ou superior. Para integrar no pipeline, consulte o guia de como executar o Apidog em um pipeline CI/CD.

FAQ

Preciso escrever código para usar o Smart Mock?

Não. Basta definir o esquema de resposta do endpoint. Use Campo de Mock, Faker ou scripts apenas quando precisar substituir ou controlar um campo específico. Veja também a visão geral da API de mock.

Por que minha URL de mock não retorna nada?

Verifique estes pontos:

  1. O endpoint possui uma definição de resposta?
  2. O caminho começa com /?
  3. O cliente Apidog está aberto, caso você use Local Mock?
  4. Você está chamando a URL e o método HTTP corretos?

A causa mais comum é não haver schema de resposta no endpoint.

Como retorno um valor específico em vez de um valor aleatório?

Defina o Campo de Mock da propriedade:

  • use um Valor Fixo para repetir sempre o mesmo dado;
  • use uma instrução Faker para gerar valores variados sob controle.

O Campo de Mock tem prioridade sobre correspondência por nome e geração baseada no schema.

Minha equipe pode acessar o mock do meu laptop?

Apenas pela rede local e enquanto o cliente Apidog estiver aberto. O Local Mock usa 127.0.0.1:4523.

Para disponibilizar um mock continuamente, ative o Cloud Mock em https://mock.apidog.com.

O que vence: exemplo de resposta ou Smart Mock?

Depende da configuração:

  • em Smart Mock Primeiro, o Smart Mock gera a resposta;
  • em Exemplo de resposta primeiro, o exemplo é usado antes do Smart Mock.

Uma Expectativa de Mock correspondente substitui ambos os comportamentos.

Conclusão

O Smart Mock transforma um schema de API em um endpoint funcional sem manter JSONs manuais ou escrever um servidor de mock.

O fluxo prático é:

  1. defina o schema de resposta;
  2. copie a URL de mock na aba API ou Mock;
  3. chame o endpoint pelo frontend ou com curl;
  4. refine o schema, o Campo de Mock ou as regras de nome quando necessário;
  5. use Expectativas de Mock para cenários condicionais;
  6. valide o backend real no CI contra o mesmo contrato.

Top comments (0)