Como Criar uma API REST Falsa em Minutos (com JSONPlaceholder)

Você está construindo um frontend, mas o backend ainda não está pronto. Você precisa de uma API REST que retorne JSON realista agora, com GET, POST, PUT e DELETE, para continuar implementando sem bloquear o desenvolvimento.

Experimente o Apidog hoje

É exatamente aqui que json-server ajuda: você aponta para um arquivo JSON e ganha uma API REST funcional em segundos, sem escrever backend. Para cenários ainda mais rápidos, o JSONPlaceholder oferece uma API falsa hospedada que você pode consumir sem instalar nada. Neste guia, você verá como usar os dois, onde eles deixam de ser suficientes e quando migrar para um mock baseado em esquema no Apidog.

Para uma visão mais ampla sobre simulação de endpoints, veja o que é uma API mock. Aqui, o foco é prático: criar uma API falsa rapidamente e saber quando trocar de abordagem.

O que é json-server?

json-server é uma ferramenta npm de código aberto que transforma um arquivo JSON em uma API REST. Você cria um db.json, executa um comando e recebe rotas CRUD prontas.

O ponto importante: operações de escrita realmente alteram o arquivo JSON. Ou seja, POST, PUT, PATCH e DELETE persistem durante o uso local.

Use json-server quando você precisa de:

• um backend temporário para desenvolver frontend;
• dados personalizados;
• rotas REST simples;
• persistência local básica;
• protótipos, demos ou testes manuais.

O projeto está disponível no GitHub.

Como instalar e executar json-server

Instale o pacote:

npm install json-server

Crie um arquivo db.json na raiz do projeto:

{
  "posts": [
    { "id": "1", "title": "First post", "views": 100 },
    { "id": "2", "title": "Second post", "views": 250 }
  ],
  "comments": [
    { "id": "1", "text": "Nice work", "postId": "1" }
  ],
  "profile": {
    "name": "apidog"
  }
}

Inicie o servidor:

npx json-server db.json

Por padrão, a API fica disponível em:

http://localhost:3000

Nota sobre versões: no json-server v1, o comando atual é npx json-server db.json. Em versões antigas da linha 0.x, você ainda pode encontrar exemplos usando json-server --watch db.json.

Rotas REST geradas automaticamente

Com o db.json acima, arrays de nível superior viram coleções REST.

Para posts, você recebe:

GET    /posts
GET    /posts/:id
POST   /posts
PUT    /posts/:id
PATCH  /posts/:id
DELETE /posts/:id

Para profile, que é um objeto, você recebe:

GET   /profile
PUT   /profile
PATCH /profile

Na prática, você pode testar com curl:

curl http://localhost:3000/posts

Criar um post:

curl -X POST http://localhost:3000/posts \
  -H "Content-Type: application/json" \
  -d '{"id":"3","title":"Third post","views":10}'

Atualizar parcialmente:

curl -X PATCH http://localhost:3000/posts/3 \
  -H "Content-Type: application/json" \
  -d '{"views":42}'

Remover:

curl -X DELETE http://localhost:3000/posts/3

Consultas, filtros, ordenação e paginação

O json-server também suporta queries úteis para simular comportamentos comuns de API.

Exemplos:

GET /posts?views:gt=100
GET /posts?views:lte=50
GET /posts?_sort=-views
GET /posts?_page=1&_per_page=25
GET /posts?_embed=comments

Na versão v1, filtros condicionais usam :.

Operadores disponíveis incluem:

• lt
• lte
• gt
• gte
• eq
• ne
• in
• contains
• startsWith
• endsWith

Exemplo com curl:

curl "http://localhost:3000/posts?views:gt=100"

Ordenar por visualizações em ordem decrescente:

curl "http://localhost:3000/posts?_sort=-views"

Paginar resultados:

curl "http://localhost:3000/posts?_page=1&_per_page=25"

JSONPlaceholder: API falsa sem instalação

Se você não quer instalar nada, use o JSONPlaceholder. Ele é uma API REST falsa e gratuita, hospedada em jsonplaceholder.typicode.com.

Exemplo:

curl https://jsonplaceholder.typicode.com/posts/1

Resposta:

{
  "userId": 1,
  "id": 1,
  "title": "sunt aut facere repellat provident",
  "body": "quia et suscipit..."
}

Ele já vem com recursos prontos:

• /posts com 100 itens
• /comments com 500 itens
• /albums com 100 itens
• /photos com 5000 itens
• /todos com 200 itens
• /users com 10 itens

Também aceita POST, PUT, PATCH e DELETE, mas com uma diferença importante: as escritas são simuladas. A API retorna uma resposta como se tivesse salvo, mas nada é persistido.

Exemplo:

curl -X POST https://jsonplaceholder.typicode.com/posts \
  -H "Content-Type: application/json" \
  -d '{"title":"Novo post","body":"Conteúdo","userId":1}'

A resposta parece real, mas ao consultar novamente, o item não estará salvo. Isso é útil para testar chamadas HTTP e estados de UI simples, mas não substitui um backend com estado.

json-server vs JSONPlaceholder

Critério	json-server	JSONPlaceholder
Configuração	Instalar pacote npm e criar db.json	Nenhuma
Onde executa	Localmente	Hospedado publicamente
Dados personalizados	Sim	Não
Escritas persistem	Sim, no db.json	Não
Melhor uso	Prototipar com seus próprios formatos	Demos rápidas e aprendizado
Requer Node.js	Sim	Não

Use JSONPlaceholder quando você só precisa testar consumo de API rapidamente. Use json-server quando você precisa controlar o formato dos dados e persistir alterações localmente.

Exemplo prático: consumir json-server no frontend

Depois de iniciar o servidor, você pode consumir a API com fetch:

async function loadPosts() {
  const response = await fetch("http://localhost:3000/posts");

  if (!response.ok) {
    throw new Error("Erro ao buscar posts");
  }

  return response.json();
}

loadPosts().then(console.log);

Criar um item:

async function createPost() {
  const response = await fetch("http://localhost:3000/posts", {
    method: "POST",
    headers: {
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      id: crypto.randomUUID(),
      title: "Novo post",
      views: 0
    })
  });

  return response.json();
}

Atualizar:

async function updatePost(id) {
  const response = await fetch(`http://localhost:3000/posts/${id}`, {
    method: "PATCH",
    headers: {
      "Content-Type": "application/json"
    },
    body: JSON.stringify({
      views: 999
    })
  });

  return response.json();
}

Excluir:

async function deletePost(id) {
  await fetch(`http://localhost:3000/posts/${id}`, {
    method: "DELETE"
  });
}

Onde essas ferramentas atingem o limite

json-server e JSONPlaceholder são excelentes para servir JSON rapidamente. O problema aparece quando o projeto deixa de ser um protótipo simples.

Principais limitações:

• Sem validação real de esquema. Se você enviar uma string onde deveria haver um número, o json-server pode aceitar. Uma API real provavelmente rejeitaria.
• Dados pouco dinâmicos. As respostas vêm do arquivo. Não há geração automática de valores realistas por tipo de campo.
• Uso local. O json-server roda no seu laptop. Sua equipe ou pipeline de CI não acessam localhost:3000 sem configuração extra.
• Contrato separado do mock. O arquivo falso pode divergir da especificação OpenAPI ou do contrato real.
• Escritas falsas no JSONPlaceholder. Fluxos com estado, como carrinho, checkout ou onboarding, não são testados de forma confiável.

Se você já passou do estágio de arquivo simples, veja também estes comparativos:

• ferramentas para mock de endpoints REST
• servidores de mock de API gratuitos e baratos
• ferramentas online de mock de API comparadas

Quando migrar para um servidor de mock baseado em esquema

Quando o mock precisa seguir o contrato da API, um arquivo JSON solto começa a atrapalhar. Nesse ponto, um servidor de mock baseado em esquema é mais adequado.

É aqui que o Apidog entra como alternativa ao json-server.

Com o Apidog, você pode:

• Mockar a partir do esquema. Defina endpoints ou importe uma especificação OpenAPI.
• Manter contrato e mock sincronizados. O mock vem da mesma definição da API.
• Gerar dados realistas. Campos como email, createdAt e price recebem valores compatíveis com nome e tipo.
• Usar regras por campo. Você pode configurar saídas específicas com regras no estilo Faker.
• Compartilhar uma URL em nuvem. A equipe e o CI podem consumir o mesmo mock hospedado.
• Evitar setup por projeto. Não há necessidade de manter um db.json local.

Para aprofundar a geração de dados realistas, veja:

• Faker.js no Apidog
• gerador de dados de teste

Como simular a mesma API no Apidog

Fluxo básico:

1. Baixe o Apidog e crie ou abra um projeto.
2. Adicione um endpoint, por exemplo GET /posts.
3. Defina o esquema de resposta ou importe uma especificação OpenAPI existente.
4. Use a URL de mock gerada pelo Apidog.
5. Ajuste regras por campo se precisar de valores específicos.
6. Compartilhe a URL com o time ou use em testes automatizados e CI.

Você mantém a velocidade de “API em minutos” do json-server, mas adiciona contrato, dados dinâmicos e uma URL acessível para toda a equipe.

FAQ

O json-server é gratuito?

Sim. json-server é open source e gratuito. JSONPlaceholder também é gratuito.

O json-server persiste dados?

Sim. POST, PUT, PATCH e DELETE escrevem de volta no db.json, então as mudanças persistem enquanto você usa o servidor local.

JSONPlaceholder não persiste dados. Ele apenas simula a resposta.

Posso usar json-server em produção?

Não. Ele foi criado para prototipagem e testes. Não oferece validação robusta, autenticação, autorização ou garantias de escalabilidade.

Qual é a diferença entre json-server e Apidog?

json-server transforma um arquivo JSON em uma API REST local. O Apidog simula endpoints a partir do esquema da API, gera dados realistas e fornece uma URL hospedada para equipe e CI.

Para contexto, veja o que é uma API mock e o resumo de ferramentas de mock REST.

Como obter dados falsos mais realistas?

Use um gerador de dados. Um gerador de dados de teste cria registros variados e realistas. No Apidog, o mock pode gerar valores automaticamente com base no esquema.

Resumo

Use json-server quando você precisa transformar rapidamente um arquivo JSON em uma API REST local. Use JSONPlaceholder quando precisa apenas de uma API falsa pública sem configuração.

Migre para um mock baseado em esquema quando precisar de:

• contrato sincronizado com a API;
• dados dinâmicos e realistas;
• URL compartilhável;
• uso em equipe ou CI;
• menos risco de divergência entre mock e API real.

Nesse ponto, o servidor de mock do Apidog assume melhor o papel. Baixe o Apidog, importe sua especificação e gere mocks alinhados ao contrato desde a primeira requisição.