Todos os artigos
Tecnologia11 de novembro de 2026

Como criar uma API REST com Node.js e Express do zero: guia prático

Aprenda a construir uma API REST profissional com Node.js e Express partindo do absoluto zero, sem atalhos mágicos ou conceitos desnecessários. O guia cobre desde a configuração inicial do ambiente até a implementação completa das quatro operações do CRUD e testes práticos de rotas.

Capa do artigo Como criar uma API REST com Node.js e Express do zero: guia prático

Se você já tentou aprender desenvolvimento backend, provavelmente esbarrou em tutoriais que pulam etapas básicas ou usam ferramentas complexas demais logo de cara. A boa notícia é que aprender como criar uma API REST com Node.js e Express do zero não exige anos de experiência nem dezenas de bibliotecas instaladas. Com apenas duas ferramentas e algumas dezenas de linhas de código em JavaScript, qualquer desenvolvedor web consegue colocar no ar um servidor confiável, capaz de conversar com aplicativos móveis, telas de navegador ou outros sistemas.

Uma API REST funciona como o garçom de um restaurante tradicional: o cliente faz o pedido no salão, o garçom leva o bilhete até a cozinha e retorna com o prato pronto. No nosso cenário, o cliente é o frontend ou um aplicativo no celular, e a cozinha é o servidor que consulta dados e processa regras de negócio. O protocolo HTTP é a língua falada nessa conversa, usando verbos como GET para pedir dados, POST para enviar informações novas, PUT para atualizar o que já existe e DELETE para remover registros.

Nas próximas seções, você vai acompanhar o processo de construção de uma aplicação prática, sem termos rebuscados, entendendo o porquê de cada comando executado no terminal.

O que você precisa antes de escrever a primeira linha de código

Antes de abrir o editor de código, precisamos garantir que o seu computador tenha as ferramentas corretas para rodar JavaScript fora do navegador. Durante anos, o JavaScript viveu preso dentro do Google Chrome ou do Firefox. O Node.js quebrou essa barreira, permitindo que a mesma linguagem fosse executada diretamente no sistema operacional do servidor, gerenciando arquivos, portas de rede e memória.

Você precisará de três coisas instaladas:

* Node.js: baixe a versão LTS (suporte de longo prazo) diretamente do site oficial. A versão LTS garante estabilidade e evita quebras inesperadas por recursos experimentais.

* Um editor de código: o Visual Studio Code (VS Code) é o mais popular e conta com ótimo suporte para extensões de JavaScript e atalhos rápidos.

* Um cliente de requisições HTTP: softwares como Insomnia ou Postman servem para disparar comandos POST, PUT e DELETE contra o seu servidor, já que o navegador comum, pela barra de endereços, só sabe fazer requisições do tipo GET.

Para checar se tudo deu certo na instalação, abra o terminal do seu computador (pode ser o Prompt de Comando no Windows ou o Terminal no macOS/Linux) e digite:

node -v

npm -v

Se ambos retornarem números de versão, você está com o caminho livre para avançar. O `npm` é o gerenciador de pacotes que vem junto com o Node, e ele será responsável por baixar o Express e qualquer outra ferramenta que o projeto venha a usar.

Como estruturar o projeto e instalar dependências do zero

Criar uma aplicação organizada desde o primeiro minuto economiza horas de frustração mais tarde. Não jogue arquivos soltos na sua pasta de downloads. Crie uma pasta específica para os seus estudos ou projetos de tecnologia.

Abra o terminal, navegue até o diretório onde deseja manter o código e rode a sequência abaixo:

mkdir minha-primeira-api

cd minha-primeira-api

npm init -y

O comando `npm init -y` gera automaticamente um arquivo chamado `package.json` na raiz da pasta. Esse arquivo serve como a certidão de nascimento do projeto: ele guarda o nome, versão, autor e a lista exata de pacotes externos que o sistema necessita para rodar.

Instalando o Express e configurando scripts

Agora instalamos a biblioteca principal da nossa aplicação. O Express é um framework minimalista que simplifica o tratamento de requisições HTTP, o roteamento de URLs e a aplicação de filtros no tráfego de dados. No mesmo terminal, execute:

npm install express

Você vai notar que uma pasta chamada `node_modules` e um arquivo chamado `package-lock.json` surgiram no diretório. Nunca altere nada manualmente dentro de `node_modules`; essa pasta guarda o código bruto das dependências e é gerida pelo próprio `npm`.

Para facilitar nossa rotina, abra o arquivo `package.json` e adicione um script de execução dentro da chave `"scripts"`:

"scripts": {

"start": "node src/server.js"

}

Dessa forma, sempre que quiser ligar o servidor, você só precisará digitar `npm start` no terminal, sem precisar lembrar o caminho exato do arquivo principal.

Como criar seu primeiro servidor funcional com Express

Com o ambiente configurado, é hora de erguer o servidor. Vamos criar uma pasta chamada `src` e, dentro dela, um arquivo de texto com o nome `server.js`. Essa separação mantém o código-fonte limpo e separado dos arquivos de configuração da raiz.

Abra o arquivo `src/server.js` no seu editor e escreva o bloco a seguir:

const express = require('express');

const app = express();

const PORT = 3000;

// Avisa o Express que vamos receber dados no formato JSON

app.use(express.json());

// Rota inicial de boas-vindas

app.get('/', (req, res) => {

return res.status(200).json({ mensagem: 'API funcionando com sucesso!' });

});

app.listen(PORT, () => {

console.log(`Servidor rodando no endereço http://localhost:${PORT}`);

});

A mágica toda acontece em poucas linhas. Importamos o módulo do Express, instanciamos a aplicação na constante `app` e definimos uma porta lógica de rede, a `3000`. O comando `app.use(express.json())` é fundamental: sem ele, o Express não entende quando alguém envia dados em formato JSON no corpo das requisições, deixando os campos vazios.

Volte ao terminal e inicie a aplicação com o comando:

npm start

Abra o seu navegador de internet comum e acesse o endereço `http://localhost:3000`. Se uma resposta com o texto `{"mensagem": "API funcionando com sucesso!"}` aparecer na tela, parabéns: seu primeiro servidor web feito em Node.js está oficialmente ativo.

Como construir uma API REST com Node.js e Express do zero com rotas CRUD

Uma API simples ganha utilidade real quando executa as operações básicas de persistência: Criar (Create), Ler (Read), Atualizar (Update) e Deletar (Delete). Juntas, elas formam a famosa sigla CRUD.

Para manter este guia acessível e focado na mecânica do Express, não vamos conectar um banco de dados pesado como PostgreSQL ou MongoDB neste primeiro momento. Vamos armazenar os dados em uma lista (array) na memória do próprio JavaScript. Quando o servidor for reiniciado a lista voltará ao estado original, mas isso é mais do que suficiente para entender a lógica das rotas.

Imagine uma API simples para gerenciar produtos de um comércio local. Cada produto terá um identificador único, nome e preço.

Implementando a leitura (GET) e a criação (POST)

Substitua o conteúdo de `src/server.js` pelo código abaixo, que adiciona a nossa lista em memória e as rotas de busca e inserção de produtos:

const express = require('express');

const app = express();

const PORT = 3000;

app.use(express.json());

// Banco de dados simulado em memória

let produtos = [

{ id: 1, nome: 'Café Torrado 500g', preco: 18.50 },

{ id: 2, nome: 'Pão de Queijo Congelado 1kg', preco: 24.00 }

];

// Rota para listar todos os produtos

app.get('/produtos', (req, res) => {

return res.status(200).json(produtos);

});

// Rota para buscar um único produto pelo ID

app.get('/produtos/:id', (req, res) => {

const { id } = req.params;

const produto = produtos.find(p => p.id === Number(id));

if (!produto) {

return res.status(404).json({ erro: 'Produto não encontrado.' });

}

return res.status(200).json(produto);

});

// Rota para cadastrar um novo produto

app.post('/produtos', (req, res) => {

const { nome, preco } = req.body;

if (!nome || preco === undefined) {

return res.status(400).json({ erro: 'Nome e preço são obrigatórios.' });

}

const novoProduto = {

id: produtos.length > 0 ? produtos[produtos.length - 1].id + 1 : 1,

nome,

preco: Number(preco)

};

produtos.push(novoProduto);

// Retorna status 201 Created com o item criado

return res.status(201).json(novoProduto);

});

Perceba como usamos `req.params` para ler variáveis que vêm na própria URL (como o ID em `/produtos/:id`) e `req.body` para capturar os dados enviados no corpo da requisição POST. Também validamos a entrada: se alguém tentar criar um produto sem nome, devolvemos o código de status HTTP 400 avisando sobre o erro, em vez de deixar o sistema aceitar lixo.

Atualizando (PUT) e removendo itens (DELETE)

Agora vamos completar o ciclo de vida dos nossos dados. Adicione as seguintes rotas logo abaixo do método POST em `src/server.js`:

// Rota para alterar dados de um produto existente

app.put('/produtos/:id', (req, res) => {

const { id } = req.params;

const { nome, preco } = req.body;

const indice = produtos.findIndex(p => p.id === Number(id));

if (indice === -1) {

return res.status(404).json({ erro: 'Produto não localizado para alteração.' });

}

produtos[indice] = {

...produtos[indice],

nome: nome !== undefined ? nome : produtos[indice].nome,

preco: preco !== undefined ? Number(preco) : produtos[indice].preco

};

return res.status(200).json(produtos[indice]);

});

// Rota para remover um produto da lista

app.delete('/produtos/:id', (req, res) => {

const { id } = req.params;

const existe = produtos.some(p => p.id === Number(id));

if (!existe) {

return res.status(404).json({ erro: 'Produto não localizado para exclusão.' });

}

produtos = produtos.filter(p => p.id !== Number(id));

// 204 significa No Content (operação bem-sucedida sem corpo de resposta)

return res.status(204).send();

});

app.listen(PORT, () => {

console.log(`Servidor rodando no endereço http://localhost:${PORT}`);

});

A manipulação segue padrões da arquitetura REST. Ao deletar um registro com sucesso, não precisamos devolver nenhum dado de volta; o código de status HTTP 204 (No Content) expressa com precisão que a remoção deu certo e não há nada extra a ser exibido.

Como testar seus endpoints com o Insomnia ou Postman

Navegadores não conseguem fazer chamadas POST, PUT ou DELETE apenas clicando na barra de navegação. Por isso, você precisa de uma ferramenta como o Insomnia, Postman ou até a extensão Thunder Client do VS Code.

Para testar o cadastro de um novo item no Insomnia:

  • Crie uma nova requisição do tipo POST.
  • Digite a URL: `http://localhost:3000/produtos`.
  • Escolha o corpo como JSON.
  • Escreva o payload:
  • {

    "nome": "Biscoito Caseiro 200g",

    "preco": 8.90

    }

  • Clique em Send.
  • Você deverá receber de volta o status verde 201 Created, com o objeto completo contendo o novo `id: 3`. Em seguida, mude o método da requisição para GET apontando para `http://localhost:3000/produtos` e envie novamente: a lista agora trará os três itens devidamente consolidados.

    Se algo der errado, verifique sempre dois pontos: se o servidor está rodando no terminal e se você não esqueceu as aspas duplas nas chaves do JSON. Quase todos os erros iniciais em chamadas de API acontecem por falhas na pontuação do formato JSON.

    Boas práticas fundamentais para manter seu código saudável

    Escrever código que roda na sua máquina é o primeiro passo, mas mantê-lo organizado para crescer é o que separa amadores de profissionais. À medida que sua aplicação recebe novas regras, colocar todas as rotas dentro de um único arquivo `server.js` vai transformar o projeto em um labirinto impossível de manter.

    Alguns cuidados práticos tornam sua API muito mais resistente:

    * Separe rotas e regras de negócio: utilize o recurso `express.Router()` para criar arquivos separados para cada recurso (por exemplo, `src/routes/produtos.routes.js`). O arquivo principal do servidor deve apenas inicializar a conexão e carregar os módulos.

    * Trate exceções e erros inesperados: nunca permita que um erro interno trave o processo do Node.js. Crie middlewares de erro no Express para capturar falhas imprevistas e responder ao cliente com o status 500 (Internal Server Error) de maneira elegante.

    * Use variáveis de ambiente: nunca escreva senhas, chaves de API secretas ou portas de rede fixas no código. Use a biblioteca `dotenv` e guarde esses valores em um arquivo `.env`, que deve ficar fora do seu controle de versão no Git.

    * Respeite os códigos de status HTTP: devolver status 200 quando houve um erro confunde totalmente quem consome a API no frontend. Use 200 para leituras com sucesso, 201 para criações, 400 para erros do usuário, 404 para dados não encontrados e 500 para falhas no servidor.

    Com essa base conceitual e prática, você aprendeu na prática como criar uma API REST com Node.js e Express do zero, montando uma estrutura enxuta, eficiente e pronta para receber conexões com bancos de dados reais quando você decidir dar o próximo passo.

    Perguntas frequentes sobre APIs com Node.js e Express

    Preciso de um banco de dados relacional para começar a estudar APIs?

    Não. Como vimos neste guia prático, você pode iniciar guardando dados em memória usando variáveis e arrays do JavaScript. Isso permite dominar a mecânica das requisições, parâmetros de rotas e códigos de status HTTP antes de gastar energia configurando bancos como PostgreSQL, MySQL ou MongoDB.

    Qual é a diferença real entre uma biblioteca e um framework como o Express?

    Uma biblioteca entrega funções pontuais para você chamar quando quiser (como manipular datas ou cálculos). Já um framework como o Express dita a arquitetura básica do projeto, fornecendo o esqueleto sobre o qual você encaixa seu código para gerenciar requisições, roteamento e respostas de rede.

    Como faço para publicar essa API gratuitamente na internet?

    Plataformas como Render, Fly.io e Railway possuem planos gratuitos ou de teste que aceitam projetos em Node.js com muita facilidade. Você só precisa subir o seu código para um repositório no GitHub, conectar a conta da plataforma escolhida e definir o comando de inicialização `npm start`.