Par Ahmed Karim NJIAWOUO GBETNKOM•6 min de lecture

Le contexte : deux philosophies, un seul objectif
Quand Facebook a open-sourcé GraphQL en 2015, la communauté tech a cru qu'on allait assister à la mort de REST. Dix ans plus tard, REST représente toujours 83% des APIs en production. Pendant ce temps, GraphQL a explosé de 340% chez les Fortune 500.
Ce n'est pas un combat à mort. C'est deux outils qui excellent dans des contextes différents. La vraie question n'est pas "lequel est meilleur ?" mais "lequel pour mon projet ?"
Cet article vous donnera les clés pour trancher, avec des chiffres réels, des cas concrets, et zéro dogmatisme.
REST : le vétéran qui refuse de mourir
REST (Representational State Transfer) n'est pas un protocole, c'est un style d'architecture défini par Roy Fielding en 2000. Les principes ? Stateless, client-serveur, cache-friendly, et surtout : une ressource = une URL unique.
Exemple classique d'API REST
GET /api/users # Liste tous les utilisateurs
POST /api/users # Crée un utilisateur
GET /api/users/237 # Récupère l'utilisateur 237
PUT /api/users/237 # Met à jour l'utilisateur 237
DELETE /api/users/237 # Supprime l'utilisateur 237
GET /api/users/237/posts # Posts de l'utilisateur 237
GET /api/posts/456/comments # Commentaires du post 456
Ce qui fait la force de REST :
- Simplicité : GET pour lire, POST pour créer, PUT pour modifier, DELETE pour supprimer. Un enfant de 10 ans peut comprendre.
- Cache HTTP natif : ETags, cache-control, Last-Modified... tout l'écosystème web est optimisé pour REST.
- Maturité : 20 ans de tooling, de doc, de patterns éprouvés. Tous les langages, tous les frameworks supportent REST.
- Scalabilité horizontale : Stateless = facile à distribuer sur plusieurs serveurs. Load balancing trivial.
Les performances réelles : 120ms de temps de réponse moyen pour des opérations CRUD simples. Throughput de 15 000 à 25 000 requêtes/seconde sur du hardware standard. Taux de cache hit à 78% en moyenne.
Le problème ? REST souffre de deux maux incurables : l'over-fetching et l'under-fetching.
Over-fetching : vous avez trop de données
Vous voulez juste afficher le nom d'un utilisateur. GET /api/users/237 vous renvoie son nom, email,
adresse, date de naissance, numéro de téléphone, liste d'amis, et 42 autres champs dont vous n'avez rien à
faire.
Résultat : Payload de 5kb alors que vous aviez besoin de 50 bytes. Sur mobile avec une 4G pourrie, ça fait mal.
Under-fetching : vous n'avez pas assez de données
Vous voulez afficher un utilisateur avec ses 3 derniers posts et les commentaires de chaque post. Avec REST, c'est minimum 5 appels API :
1. GET /api/users/237
2. GET /api/users/237/posts
3. GET /api/posts/1/comments
4. GET /api/posts/2/comments
5. GET /api/posts/3/comments
5 round-trips réseau. 5 x 120ms = 600ms minimum. Sur une connexion lente, c'est 2-3 secondes d'attente.
GraphQL : le challenger qui change les règles
Facebook a créé GraphQL en 2012 pour résoudre exactement ces problèmes. L'idée est simple mais révolutionnaire : le client demande exactement ce qu'il veut, et rien d'autre.
Même scénario en GraphQL
query {
user(id: "237") {
name
posts(limit: 3) {
title
comments {
author
text
}
}
}
}
Une seule requête. Un seul endpoint (/graphql). Toutes les données nécessaires, rien
de plus.
Ce qui fait la force de GraphQL :
- Zéro over/under-fetching : Vous demandez exactement ce dont vous avez besoin. Réduction de 30% de la bande passante sur des requêtes complexes.
- Endpoint unique : Fini les 50 routes REST. Tout passe par
/graphql. Routing simplifié, versioning plus propre. - Strongly typed : Le schéma GraphQL définit tous les types. Autocomplétion dans l'IDE, validation automatique, documentation auto-générée.
- Introspection : Les clients peuvent interroger le schéma lui-même. Les APIs GraphQL sont auto-documentées.
- Subscriptions temps réel : WebSocket natif pour des updates live. 80% de réduction du polling vs REST.
Les performances réelles : 180ms de temps de réponse pour des requêtes complexes (vs 600ms+ en REST multi-calls). 15 000 requêtes complexes/seconde sur hardware standard. Sur requêtes simples, REST reste plus rapide (120ms vs 180ms).
Les statistiques qui tuent : 89% des équipes qui adoptent GraphQL choisiraient à nouveau GraphQL pour des projets similaires (Apollo GraphQL Developer Survey 2024). Ce taux de rétention ne ment pas.
Le problème ? GraphQL est plus complexe à mettre en place et à optimiser.
La complexité côté serveur
Un endpoint GraphQL, c'est facile. Optimiser les resolvers, gérer le N+1 problem, implémenter du DataLoader pour batching, limiter la profondeur des queries pour éviter les DOS... c'est une autre histoire. REST est plug-and-play. GraphQL demande de l'expertise.
Le caching, un cauchemar
REST utilise HTTP cache out of the box. GraphQL ? Chaque query est unique, donc le cache HTTP standard ne fonctionne pas. Il faut du field-level caching, des persisted queries, ou des solutions custom. Complexité +300%.
Le match comparatif : REST vs GraphQL en chiffres
Vitesse de développement
REST : API basique en 1-2 jours. CRUD complet en 1 semaine. Mais chaque nouvelle feature = nouveau endpoint à créer et documenter.
GraphQL : Setup initial plus long (2-3 jours). Mais après, ajout de features ultra rapide : il suffit d'étendre le schéma. Les front-end peuvent itérer sans toucher au back.
Performance réseau
REST : Excellent sur requêtes simples (120ms). Catastrophique sur agrégations multi-ressources (600ms+ avec 5-10 calls).
GraphQL : Bon sur requêtes complexes (180ms single call). Overhead léger sur requêtes simples comparé à REST.
Bande passante
REST : Over-fetching systématique. Payload 3-10x plus gros que nécessaire selon les cas.
GraphQL : Réduction de 30% de la bande passante sur requêtes complexes. Critique sur mobile/bas débit.
Caching
REST : HTTP cache natif. ETags, cache-control, CDN-friendly. Taux de hit à 78%.
GraphQL : Cache complexe. Persisted queries ou Apollo Client pour mitigate. Setup non-trivial.
Documentation
REST : Swagger/OpenAPI. Besoin de maintenir la doc manuellement. Souvent outdated.
GraphQL : Auto-documenté via introspection. GraphQL Playground/GraphiQL out of the box. Toujours à jour.
Courbe d'apprentissage
REST : 2-3 heures pour être productif. Patterns bien connus.
GraphQL : 2-3 jours pour comprendre les concepts (queries, mutations, subscriptions, resolvers). 2-3 semaines pour maîtriser les optimisations.
Quand choisir REST : les cas d'usage parfaits
REST n'est pas mort, il excelle dans des scénarios précis :
- 1. APIs publiques : Exposition externe = simplicité et compatibilité maximales. GitHub, Twitter, Stripe... toutes les grandes APIs publiques sont REST.
- 2. CRUD simples : Gestion basique de ressources. Blog, CMS, e-commerce classique. Pas besoin de sortir l'artillerie lourde.
- 3. Microservices : Communication service-to-service. Stateless, scalable, patterns bien établis.
- 4. Cache-heavy applications : Si votre app repose massivement sur le cache HTTP/CDN. REST est imbattable.
- 5. Équipes juniors : Pas besoin d'expertise GraphQL. REST fonctionne immédiatement.
Cas réel : API Stripe
Stripe gère des milliards de transactions. Leur API REST est un modèle de simplicité et de fiabilité. Pourquoi pas GraphQL ? Parce que leurs endpoints sont ultra-optimisés pour des opérations spécifiques (créer un payment, créer un customer, etc.). GraphQL ajouterait de la complexité sans gain réel. REST + cache HTTP agressif = performances optimales.
Quand choisir GraphQL : les cas d'usage parfaits
GraphQL brille quand la complexité monte :
- 1. Données fortement interconnectées : Réseaux sociaux, dashboards complexes, apps avec graphes de données riches. Une query GraphQL > 10 calls REST.
- 2. Clients multiples avec besoins différents : App mobile (besoin minimal), app web (besoin max), app admin (besoin custom). GraphQL = un seul backend, chaque client query ce qu'il veut.
- 3. Itérations front-end rapides : Le front change constamment les besoins data. Avec GraphQL, zero impact backend. Avec REST, nouveau endpoint à chaque fois.
- 4. Real-time critical : Subscriptions GraphQL = WebSocket natif. Chat, notifications live, dashboards temps réel.
- 5. Mobile-first : Bande passante limitée. GraphQL réduit le payload de 30-60% vs REST sur requêtes complexes.
Cas réel : GitHub API v4
GitHub a migré vers GraphQL (API v4) en gardant REST (API v3). Pourquoi ? Avec REST, afficher une PR avec ses commits, reviews, et comments = 15-20 appels API. Avec GraphQL, une seule query. Réduction de 90% du nombre de requêtes. Sur une app mobile, ça change tout.
L'approche hybride : REST + GraphQL, le meilleur des deux mondes
Voici le secret que personne ne vous dit : vous n'êtes pas obligé de choisir. Beaucoup d'entreprises utilisent les deux.
Le pattern classique :
- REST pour les APIs publiques : Simplicité, compatibilité maximale, cache HTTP.
- GraphQL pour les clients internes : Apps mobiles/web qui ont besoin de flexibilité et de réduction de latence.
Exemple architecture hybride :
API Gateway (Kong/Ambassador)
|
├── /api/v1/* → REST endpoints (public)
| - GET /api/v1/users
| - POST /api/v1/payments
| - Cache HTTP agressif
|
└── /graphql → GraphQL endpoint (internal)
- Apps mobiles/web
- Dashboards admin
- Apollo Client avec cache
Beaucoup d'entreprises exposent même GraphQL comme couche d'agrégation au-dessus de microservices REST existants. GraphQL devient un BFF (Backend For Frontend) qui unifie plusieurs APIs REST en un seul schéma.
Les pièges à éviter (leçons apprises à la dure)
Piège #1 : GraphQL sans DataLoader = N+1 queries
Vous queriz 100 users avec leurs posts. Sans DataLoader, GraphQL fait 1 query pour les users + 100 queries pour les posts. 101 queries SQL au lieu de 2. Votre DB pleure. Solution : DataLoader pour batching/caching des resolvers.
Piège #2 : REST sans pagination = crash garanti
GET /api/users retourne 50 000 users en
JSON. 25Mo de payload. Serveur et client meurent. Toujours paginer. Toujours. ?page=1&limit=20 ou cursor-based pagination.
Piège #3 : GraphQL sans query depth limit = DOS facile
Un attaquant envoie une query avec 50 niveaux de profondeur. Votre serveur calcule pendant 30 secondes avant de timeout. Toujours limiter la profondeur (depth limit à 7-10 max) et la complexité des queries.
Piège #4 : REST sans versioning = breaking changes en prod
Vous modifiez un endpoint. Les clients cassent. Toujours versionner : /api/v1/, /api/v2/. Ou header-based versioning. GraphQL
gère ça avec field deprecation (plus élégant).
Checklist de décision : REST ou GraphQL ?
Posez-vous ces questions dans l'ordre :
- 1. Mon API est-elle publique ? → OUI = REST (sauf si vous avez des ressources dédiées pour supporter GraphQL publiquement)
- 2. Mes données sont-elles fortement interconnectées ? → OUI = GraphQL penche fort
- 3. J'ai plusieurs clients avec des besoins data différents ? → OUI = GraphQL
- 4. Le cache HTTP est critique pour moi ? → OUI = REST
- 5. Mon équipe backend est junior ? → OUI = REST
- 6. Je veux itérer vite côté front sans toucher au back ? → OUI = GraphQL
- 7. Je construis une app mobile-first ? → OUI = GraphQL (économie de bande passante)
Si vous hésitez encore : Commencez par REST. Migrez vers GraphQL quand la complexité justifie l'investissement. Pas l'inverse. Over-engineering dès le départ = dette technique garantie.
Conclusion : arrêtez de chercher le "meilleur", cherchez le bon
REST n'est pas mort. GraphQL n'est pas la solution miracle. Ce sont des outils, pas des religions.
REST excelle pour les APIs publiques simples, le cache HTTP agressif, et les équipes qui veulent de la stabilité. GraphQL excelle pour les données interconnectées, les clients multiples, et les équipes qui veulent de la vélocité front-end.
Les meilleurs systèmes en production utilisent les deux. GitHub, Shopify, Netflix, Airbnb : tous ont des APIs REST ET GraphQL. Chacune pour ce qu'elle fait de mieux.
Le vrai skill en 2026, ce n'est pas de maîtriser GraphQL ou REST. C'est de savoir quand utiliser quoi, et pourquoi. C'est ce qui sépare un dev qui suit les trends d'un architecte qui fait des choix éclairés.
Alors la prochaine fois qu'on vous dit "GraphQL c'est le futur" ou "REST c'est dépassé", souriez poliment et posez la seule question qui compte : "Pour quel use case ?"
TL;DR - Résumé
- REST = simple, mature, cache HTTP natif. Parfait pour APIs publiques et CRUD basique.
- GraphQL = flexible, efficace, complexe. Parfait pour données interconnectées et clients multiples.
- Over-fetching/under-fetching REST vs complexité GraphQL : choisissez votre poison.
- N+1 queries = cauchemar GraphQL. DataLoader = solution obligatoire.
- Approche hybride = souvent la meilleure stratégie (REST public + GraphQL interne).
- Commencez simple (REST), complexifiez quand justifié (GraphQL).
- Le meilleur choix ? Celui qui résout VOTRE problème, pas celui qui fait le buzz sur Twitter.

