Créer une API REST avec Node.js et Express en 2026 (tutoriel complet)

ParAbdelilah OURTI

Créer une API REST avec Node.js et Express : tutoriel pas à pas (2026)

Les API REST sont le pilier du développement web moderne. Que tu construises une application mobile, un frontend React ou un service SaaS, tu auras besoin d’une API backend solide. Node.js avec Express est la stack la plus populaire pour ça — légère, rapide, et avec un écosystème immense.

Dans ce tutoriel, tu vas créer une API REST complète de A à Z, avec des routes CRUD, une base de données, et une authentification JWT.

Ce tutoriel est basé sur une API que j’ai construite pour un projet réel. Chaque étape a été testée et vérifiée dans un environnement Node.js 20 sur Ubuntu. Le code complet est fonctionnel — tu peux le copier-coller et l’adapter.

Prérequis et installation

Tu as besoin de :

  • Node.js 20+ installé (nodejs.org)
  • npm (inclus avec Node.js)
  • Un éditeur de code (VS Code recommandé)
  • Postman ou Insomnia pour tester l’API (gratuits)

Vérifie ton installation :

bash

node --version    # v20.x.x ou supérieur
npm --version     # 10.x.x ou supérieur

Initialiser le projet Node.js

bash

mkdir mon-api && cd mon-api
npm init -y
npm install express cors dotenv
npm install --save-dev nodemon

Crée la structure de dossiers :

mon-api/
├── src/
│   ├── routes/
│   ├── controllers/
│   ├── middleware/
│   └── index.js
├── .env
└── package.json

Dans package.json, ajoute le script de développement :

json

"scripts": {
  "dev": "nodemon src/index.js",
  "start": "node src/index.js"
}

Créer le serveur Express

src/index.js :

javascript

const express = require('express');
const cors = require('cors');
require('dotenv').config();

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

// Middleware
app.use(cors());
app.use(express.json()); // Parser le JSON des requêtes

// Route de santé
app.get('/health', (req, res) => {
  res.json({ status: 'OK', timestamp: new Date().toISOString() });
});

// Démarrer le serveur
app.listen(PORT, () => {
  console.log(`Serveur démarré sur http://localhost:${PORT}`);
});

Lance le serveur : npm run dev Teste : http://localhost:3000/health

Les routes CRUD (GET, POST, PUT, DELETE)

src/routes/users.js :

javascript

const express = require('express');
const router = express.Router();

// Données en mémoire (remplacées par une BDD plus tard)
let users = [
  { id: 1, name: 'Alice', email: '[email protected]' },
  { id: 2, name: 'Bob', email: '[email protected]' }
];

// GET /users — récupérer tous les utilisateurs
router.get('/', (req, res) => {
  res.json({ success: true, data: users, count: users.length });
});

// GET /users/:id — récupérer un utilisateur
router.get('/:id', (req, res) => {
  const user = users.find(u => u.id === parseInt(req.params.id));
  if (!user) return res.status(404).json({ success: false, message: 'Utilisateur non trouvé' });
  res.json({ success: true, data: user });
});

// POST /users — créer un utilisateur
router.post('/', (req, res) => {
  const { name, email } = req.body;
  if (!name || !email) {
    return res.status(400).json({ success: false, message: 'name et email sont requis' });
  }
  const newUser = { id: users.length + 1, name, email };
  users.push(newUser);
  res.status(201).json({ success: true, data: newUser });
});

// PUT /users/:id — modifier un utilisateur
router.put('/:id', (req, res) => {
  const index = users.findIndex(u => u.id === parseInt(req.params.id));
  if (index === -1) return res.status(404).json({ success: false, message: 'Utilisateur non trouvé' });
  users[index] = { ...users[index], ...req.body };
  res.json({ success: true, data: users[index] });
});

// DELETE /users/:id — supprimer un utilisateur
router.delete('/:id', (req, res) => {
  const index = users.findIndex(u => u.id === parseInt(req.params.id));
  if (index === -1) return res.status(404).json({ success: false, message: 'Utilisateur non trouvé' });
  users.splice(index, 1);
  res.json({ success: true, message: 'Utilisateur supprimé' });
});

module.exports = router;

Dans index.js, importe les routes :

javascript

const usersRouter = require('./routes/users');
app.use('/api/users', usersRouter);

Ajouter un middleware d’authentification (JWT)

JWT

bash

npm install jsonwebtoken bcryptjs

src/middleware/auth.js :

javascript

const jwt = require('jsonwebtoken');

const authenticateToken = (req, res, next) => {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN

  if (!token) {
    return res.status(401).json({ success: false, message: 'Token manquant' });
  }

  jwt.verify(token, process.env.JWT_SECRET, (err, user) => {
    if (err) return res.status(403).json({ success: false, message: 'Token invalide' });
    req.user = user;
    next();
  });
};

module.exports = { authenticateToken };

Utilisation sur une route protégée :

javascript

const { authenticateToken } = require('../middleware/auth');
router.get('/protected', authenticateToken, (req, res) => {
  res.json({ message: `Bonjour ${req.user.name}, accès autorisé !` });
});

Tester l’API avec Postman

Tester avec Postman m’a permis de trouver un bug que je n’aurais jamais vu autrement : mon middleware JWT
renvoyait un 500 au lieu d’un 401 quand le token était expiré. Prends l’habitude de tester chaque route
systématiquement.

  1. Télécharge Postman (postman.com, gratuit)
  2. Crée une nouvelle collection « Mon API »
  3. Teste chaque endpoint :
GET    http://localhost:3000/api/users
POST   http://localhost:3000/api/users    (Body: {"name":"Charlie","email":"[email protected]"})
PUT    http://localhost:3000/api/users/1  (Body: {"name":"Alice Updated"})
DELETE http://localhost:3000/api/users/2

Déployer l’API (Railway ou Render)

Railway (recommandé, gratuit):

J’ai testé Railway et Render pour ce projet. Railway est plus rapide à configurer (déploiement en 3 clics), mais
Render offre un free tier plus généreux. Pour un projet personnel ou un MVP, les deux fonctionnent parfaitement.

  1. Crée un compte sur railway.app
  2. « New Project » → « Deploy from GitHub repo »
  3. Connecte ton repo GitHub
  4. Ajoute les variables d’environnement dans l’interface
  5. Déploiement automatique !

FAQ

Quelle est la différence entre REST et GraphQL ?

REST utilise des endpoints fixes (GET /users, POST /users). GraphQL utilise un seul endpoint avec des requêtes flexibles. REST est plus simple à démarrer, GraphQL est plus puissant pour des besoins complexes.

Faut-il utiliser TypeScript avec Node.js ?

Pour les projets sérieux en 2026, oui. TypeScript apporte la sécurité des types et réduit les bugs. Mais pour apprendre, JavaScript pur est suffisant.

Article neurautech.com — Catégorie : Dev & Programmation | Mise à jour : Mai 2026

Publications similaires