📘 Como Criar uma API REST com Node.js e Express

Publicado em 15/09/2025 — Tempo de leitura: 15 min

Como Criar uma API REST com Node.js e Express

O que você vai aprender

Neste tutorial completo, você aprenderá a criar uma API REST profissional do zero usando Node.js e Express. Vamos cobrir desde a configuração inicial até a implementação de rotas, validação de dados e boas práticas de desenvolvimento.

O que é uma API REST?

REST (Representational State Transfer) é um estilo arquitetural para desenvolvimento de serviços web. Uma API REST permite que diferentes aplicações se comuniquem através de requisições HTTP, usando métodos padronizados como GET, POST, PUT e DELETE.

APIs REST são fundamentais no desenvolvimento moderno porque:

Pré-requisitos

Antes de começar, certifique-se de ter instalado em seu computador:

Node.js

Versão 18.x ou superior

NPM ou Yarn

Gerenciador de pacotes

Editor de código

VS Code recomendado

Dica: Você pode verificar se o Node.js está instalado executando node --version no terminal. Se não tiver, baixe em nodejs.org

Passo a Passo Passo a Passo: Criando sua API

  • Configuração Inicial do Projeto

    Primeiro, vamos criar a estrutura do nosso projeto. Abra o terminal e execute:

    Terminal 
    # Criar pasta do projeto
mkdir minha-api-rest
cd minha-api-rest

# Inicializar o projeto Node.js
npm init -y

# Instalar dependências necessárias
npm install express cors dotenv

# Instalar dependências de desenvolvimento
npm install --save-dev nodemon

    O que cada pacote faz:

    • express: Framework web minimalista para Node.js
    • cors: Permite requisições de diferentes origens
    • dotenv: Gerencia variáveis de ambiente
    • nodemon: Reinicia o servidor automaticamente durante desenvolvimento

  • Estrutura de Pastas

    Organize seu projeto com a seguinte estrutura:

    Estrutura do Projeto 
    minha-api-rest/
│
├── src/
│   ├── controllers/
│   │   └── userController.js
│   ├── routes/
│   │   └── userRoutes.js
│   ├── models/
│   │   └── userModel.js
│   └── app.js
│
├── .env
├── .gitignore
├── package.json
└── server.js

  • Criando o Servidor Principal

    Crie o arquivo server.js na raiz do projeto:

    JavaScript - server.js 
    const express = require('express');
const cors = require('cors');
require('dotenv').config();

const app = express();
const PORT = process.env.PORT || 3000;

// Middlewares
app.use(cors());
app.use(express.json());

// Rota de teste
app.get('/', (req, res) => {
    res.json({ 
        message: 'API está funcionando!',
        version: '1.0.0'
    });
});

// Iniciar servidor
app.listen(PORT, () => {
    console.log(`Servidor rodando na porta ${PORT}`);
});

  • Implementando as Rotas

    Crie o arquivo src/routes/userRoutes.js:

    JavaScript - userRoutes.js 
    const express = require('express');
const router = express.Router();

// Simulando um banco de dados em memória
let users = [
    { id: 1, name: 'João Silva', email: 'joao@email.com' },
    { id: 2, name: 'Maria Santos', email: 'maria@email.com' }
];

// GET - Listar todos os usuários
router.get('/users', (req, res) => {
    res.json(users);
});

// GET - Buscar usuário por ID
router.get('/users/:id', (req, res) => {
    const user = users.find(u => u.id === parseInt(req.params.id));
    
    if (!user) {
        return res.status(404).json({ error: 'Usuário não encontrado' });
    }
    
    res.json(user);
});

// POST - Criar novo usuário
router.post('/users', (req, res) => {
    const { name, email } = req.body;
    
    if (!name || !email) {
        return res.status(400).json({ error: 'Nome e email são obrigatórios' });
    }
    
    const newUser = {
        id: users.length + 1,
        name,
        email
    };
    
    users.push(newUser);
    res.status(201).json(newUser);
});

// PUT - Atualizar usuário
router.put('/users/:id', (req, res) => {
    const user = users.find(u => u.id === parseInt(req.params.id));
    
    if (!user) {
        return res.status(404).json({ error: 'Usuário não encontrado' });
    }
    
    const { name, email } = req.body;
    user.name = name || user.name;
    user.email = email || user.email;
    
    res.json(user);
});

// DELETE - Remover usuário
router.delete('/users/:id', (req, res) => {
    const index = users.findIndex(u => u.id === parseInt(req.params.id));
    
    if (index === -1) {
        return res.status(404).json({ error: 'Usuário não encontrado' });
    }
    
    users.splice(index, 1);
    res.status(204).send();
});

module.exports = router;

  • Conectando as Rotas ao Servidor

    Atualize o server.js para incluir as rotas:

    JavaScript - server.js (atualizado) 
    const express = require('express');
const cors = require('cors');
const userRoutes = require('./src/routes/userRoutes');
require('dotenv').config();

const app = express();
const PORT = process.env.PORT || 3000;

app.use(cors());
app.use(express.json());

// Usar as rotas
app.use('/api', userRoutes);

app.get('/', (req, res) => {
    res.json({ 
        message: 'API REST com Node.js',
        endpoints: {
            users: '/api/users'
        }
    });
});

app.listen(PORT, () => {
    console.log(`🚀 Servidor rodando em http://localhost:${PORT}`);
});

  • Configurando Scripts no package.json

    Adicione os seguintes scripts no seu package.json:

    JSON - package.json 
    "scripts": {
    "start": "node server.js",
    "dev": "nodemon server.js"
}

  • Testando a API

    Inicie o servidor com:

    Terminal 
    npm run dev

    Agora você pode testar os endpoints usando ferramentas como Postman, Insomnia ou até mesmo o navegador:

    • GET http://localhost:3000/api/users - Lista usuários
    • GET http://localhost:3000/api/users/1 - Busca usuário específico
    • POST http://localhost:3000/api/users - Cria novo usuário
    • PUT http://localhost:3000/api/users/1 - Atualiza usuário
    • DELETE http://localhost:3000/api/users/1 - Remove usuário

    • Boas Práticas e Segurança

    Faça Sempre

    • Valide todos os dados de entrada
    • Use variáveis de ambiente para dados sensíveis
    • Implemente tratamento de erros adequado
    • Adicione logs para debugging
    • Use HTTPS em produção
    • Implemente rate limiting
    • Documente seus endpoints
    • Use versionamento de API

    Evite

    • Expor informações sensíveis nos erros
    • Commits com credenciais no código
    • Aceitar dados sem validação
    • Usar porta padrão em produção
    • Ignorar atualizações de segurança
    • Deixar endpoints sem autenticação
    • Retornar stack traces em produção

    Próximos Passos

    Agora que você tem uma API básica funcionando, considere implementar:

    Banco de Dados

    Conecte com MongoDB, PostgreSQL ou MySQL

    Autenticação

    Adicione JWT ou OAuth2

    Validação

    Use bibliotecas como Joi ou Yup

    Documentação

    Implemente Swagger/OpenAPI

    Testes

    Adicione Jest ou Mocha

    Deploy

    Publique em Heroku, Vercel ou AWS

    Integrando com Banco de Dados

    Para tornar sua API mais robusta, vamos conectá-la com MongoDB usando Mongoose:

    Terminal 
    # Instalar Mongoose
npm install mongoose

    Crie o arquivo src/config/database.js:

    JavaScript - database.js 
    const mongoose = require('mongoose');

const connectDB = async () => {
    try {
        await mongoose.connect(process.env.MONGODB_URI, {
            useNewUrlParser: true,
            useUnifiedTopology: true
        });
        console.log('✅ MongoDB conectado com sucesso!');
    } catch (error) {
        console.error('❌ Erro ao conectar MongoDB:', error.message);
        process.exit(1);
    }
};

module.exports = connectDB;
    Importante: Adicione sua URL de conexão MongoDB no arquivo .env:
    MONGODB_URI=mongodb://localhost:27017/minha-api

    Exemplo Completo com Middleware

    Vamos adicionar um middleware de logging para rastrear todas as requisições:

    JavaScript - logger.js 
    const logger = (req, res, next) => {
    const timestamp = new Date().toISOString();
    console.log(`[${timestamp}] ${req.method} ${req.url}`);
    next();
};

module.exports = logger;

    Use o middleware no server.js:

    JavaScript 
    const logger = require('./src/middlewares/logger');

// Adicione antes das rotas
app.use(logger);

    Tratamento de Erros

    Implemente um middleware global para capturar erros:

    JavaScript - errorHandler.js 
    const errorHandler = (err, req, res, next) => {
    console.error(err.stack);
    
    res.status(err.statusCode || 500).json({
        success: false,
        error: err.message || 'Erro interno do servidor',
        ...(process.env.NODE_ENV === 'development' && { stack: err.stack })
    });
};

module.exports = errorHandler;

    Checklist de Produção

    Antes de colocar sua API em produção:

    Recursos Adicionais

    Para aprofundar seus conhecimentos, consulte estes recursos oficiais:

    Performance: Use compressão gzip com o pacote compression para reduzir o tamanho das respostas em até 70%.

    Segurança: Instale o helmet para proteger sua aplicação de vulnerabilidades conhecidas configurando headers HTTP adequados.

    Debugging: Use o VS Code Debugger ou o módulo debug do npm para facilitar a identificação de problemas durante o desenvolvimento.

    Conclusão

    Parabéns! Você criou sua primeira API REST com Node.js e Express. Este é apenas o começo de sua jornada no desenvolvimento backend. Continue praticando, explorando novos recursos e implementando melhorias.

    Lembre-se: uma boa API é aquela que é fácil de usar, bem documentada, segura e mantém a consistência em todos os endpoints. Com o conhecimento adquirido neste tutorial, você está pronto para construir APIs mais complexas e robustas.