Une REST API expose des ressources via HTTP en suivant les contraintes formalisées par Roy Fielding (thèse 2000), rendant les échanges prévisibles, cacheables et scalables. Suivez les chapitres pour comprendre le cycle requête‑réponse, l’anatomie d’une requête et les bonnes pratiques à appliquer.
Quel problème les REST API résolvent elles
Les REST API standardisent la communication entre systèmes hétérogènes pour rendre les échanges prévisibles, interopérables et scalables.
J’observe ce besoin partout : interfaces utilisateur multiples (navigateur, application mobile, objets connectés) nécessitent d’accéder aux mêmes données et services backend. Les architectures monolithiques laissaient trop de couples propriétaire-produit, ce qui posait des problèmes lorsque l’on intégrait des fournisseurs tiers ou que l’on déployait des microservices indépendants.
Un standard est nécessaire pour formaliser le contrat d’échange (contrats d’API), garantir la compatibilité et faciliter la montée en charge. Les contrats rendent les échanges prévisibles, la compatibilité évite les régressions et la standardisation permet d’utiliser du tooling (caching HTTP, monitoring, gateways) pour scaler.
Exemples concrets : une API météo publique diffuse des données JSON consommées par des apps variées, l’authentification via OAuth (protocole d’autorisation qui permet à un service d’agir pour le compte d’un utilisateur sans partager son mot de passe) avec Google repose sur des endpoints REST, les paiements via Stripe exposent des endpoints REST pour créer des paiements, et les microservices internes communiquent en REST pour permettre des déploiements indépendants.
Historique et références : Le modèle REST a été formalisé par Roy Fielding dans sa thèse en 2000 et s’appuie sur les sémantiques HTTP décrites notamment par la RFC 7231 (définit les méthodes HTTP et leur signification).
Comparaison rapide avec d’autres approches : RPC (Remote Procedure Call) appelle des fonctions distantes comme si elles étaient locales, ce qui peut être simple mais moins standardisé. SOAP (Simple Object Access Protocol) est formel, orienté message et possède un riche écosystème WS-*, mais il est plus verbeux et complexe. REST reste souvent préféré pour sa simplicité, sa large adoption et l’écosystème d’outils modernes.
| REST | Points forts : Simplicité, HTTP natif, large tooling | Limites : Moins de standards formels pour les contrats |
| RPC | Points forts : Appels procéduraux directs, performant | Limites : Moins interopérable, dépendant d’implémentation |
| SOAP | Points forts : Standards riches, sécurité et transactions | Limites : Verbeux, complexité et adoption décroissante |
- Interopérabilité : Permet à des clients hétérogènes de consommer les mêmes services.
- Scalabilité : S’appuie sur HTTP et le caching pour monter en charge efficacement.
- Cache : Exploite les mécanismes HTTP (ETag, Cache-Control) pour réduire la charge.
- Déploiements indépendants : Facilite l’évolution et la mise à jour des services sans tout casser.
Qu’est ce qu’une REST API
Une REST API est un contrat d’échange qui expose des ressources via HTTP en appliquant des contraintes architecturales définies comme REST.
Pour moi, API signifie contrat : un ensemble de règles formelles qui décrit comment un client et un serveur communiquent (endpoints, schémas de données, erreurs).
Pour moi, REST (Representational State Transfer) est un ensemble de contraintes architecturales : identification des ressources via des URI, opérations stateless, représentation des ressources, hypermédia optionnelle.
Pour moi, HTTP est le protocole sous-jacent : il transporte les requêtes (méthodes), les en-têtes et les corps, et fournit les codes de statut standard.
Les éléments fonctionnels à connaître.
Les endpoints sont des URI qui représentent des ressources (par exemple /users/123).
Les ressources sont des entités métiers — utilisateurs, paiements, prévisions météo — et leurs représentations sont des formats de transfert (JSON, XML).
Les méthodes HTTP courantes : GET pour lire, POST pour créer, PUT/PATCH pour modifier, DELETE pour supprimer.
Exemples d’URL typiques et d’usage :
GET /weather?city=Paris
POST /payments
GET /users/123
PATCH /orders/456/status
Le rôle de Content-Type et Accept.
Content-Type indique le format du corps envoyé par le client (ex : application/json).
Accept indique les formats que le client peut recevoir.
Le format JSON s’est imposé par simplicité et parce qu’il est natif en JavaScript, ce qui facilite le parsing côté client et serveur.
Les études (SmartBear, State of API 2019–2020) montrent que REST reste majoritaire, utilisé par l’ordre de 80% des projets d’API.
| Composant | Rôle | Bonnes pratiques |
| URL | Identifie la ressource | Nommer au pluriel (/users), utiliser nouns, versioning (/v1/), éviter les verbes |
| Méthode | Indique l’action | Respecter GET/POST/PUT/PATCH/DELETE, idempotence |
| En-têtes | Transportent métadonnées (Content-Type, Accept, Auth) | Utiliser Content-Type, Accept, Authorization, limiter tailles |
| Corps | Contient la représentation de la ressource | JSON clair, schéma (OpenAPI/JSON Schema), éviter surcharge |
- Nommer l’endpoint en utilisant des noms de ressources clairs et au pluriel.
- Choisir la méthode HTTP correspondant à l’intention (GET/POST/PUT/PATCH/DELETE).
- Documenter et utiliser les codes HTTP standards (200, 201, 204, 400, 401, 404, 500).
- Renvoyer une réponse JSON cohérente avec un schéma et prévoir pagination pour les collections.
- Versionner l’API (URI ou en-tête) dès la première release si breaking changes probables.
Quelles sont les six contraintes REST
Les six contraintes de Fielding (client‑server, stateless, cacheability, uniform interface, layered system, code on demand) définissent le style REST et expliquent le comportement attendu d’une API.
Client‑Server
Voici la définition, l’impact, des exemples et comment vérifier.
- Définition concise: Séparation claire entre client (interface utilisateur) et serveur (stockage et logique métier).
- Impact opérationnel: Facilite l’évolution indépendante, améliore la maintenabilité et permet le scaling horizontal des serveurs.
- Exemples et pièges: Exemple pratique: APIs publiques qui servent plusieurs clients (web, mobile). Piège: Mélanger UI et logique serveur via rendu serveur lourd qui rend difficile la réutilisation.
- Comment vérifier: Vérifier l’absence de dépendances UI dans l’API et la possibilité de remplacer le client sans changer le serveur.
Stateless
Voici la définition, l’impact, des exemples et comment vérifier.
- Définition concise: Chaque requête contient toutes les informations nécessaires; le serveur ne conserve pas d’état de session.
- Impact opérationnel: Améliore la tolérance aux pannes et la scalabilité; facilite le load balancing.
- Exemples et pièges: Exemple pratique: Authentification via token JWT (données encodées côté client). Piège: Sessions serveur (cookies de session) violant la contrainte et complexifiant le scaling.
- Comment vérifier: Vérifier que les serveurs sont interchangeables et que la suppression d’un nœud n’affecte pas les sessions.
Cacheability
Voici la définition, l’impact, des exemples et comment vérifier.
- Définition concise: Les réponses doivent être explicitement marquées comme cachables ou non selon RFC 7234.
- Impact opérationnel: Réduit la latence et la charge serveur; améliore les performances globales.
- Exemples et pièges: Exemple pratique: Utiliser Cache‑Control et ETag. Piège: Règles de cache incorrectes entraînant données obsolètes.
- Comment vérifier: Inspecter les en‑têtes HTTP (Cache‑Control, ETag, Last‑Modified).
Uniform Interface
Voici la définition, l’impact, des exemples et comment vérifier.
- Définition concise: Interface standardisée (ressources identifiées par URI, verbes HTTP sémantiques, représentations).
- Impact opérationnel: Simplifie l’usage et l’interopérabilité, réduit la courbe d’apprentissage.
- Exemples et pièges: Exemple pratique: GET pour lire, POST pour créer, PUT pour remplacer, PATCH pour modifier. Piège: Utiliser POST pour tout casse la sémantique.
- Comment vérifier: Contrôler l’usage cohérent des méthodes HTTP et des codes de statut (RFC 7231).
Layered System
Voici la définition, l’impact, des exemples et comment vérifier.
- Définition concise: Architecture en couches où un client ne voit pas au‑delà de la couche directe.
- Impact opérationnel: Permet d’interposer proxys, load balancers et caches pour résilience et sécurité.
- Exemples et pièges: Exemple pratique: CDN devant l’API. Piège: Écoulement d’informations internes entre couches crée des dépendances.
- Comment vérifier: Inspecter l’architecture réseau et s’assurer que les composants sont découplés.
Code On Demand (facultatif)
Voici la définition, l’impact, des exemples et comment vérifier.
- Définition concise: Serveur peut fournir du code exécutable (ex: scripts) au client.
- Impact opérationnel: Augmente la flexibilité client mais réduit la visibilité et la sécurité; rarement utilisé en pratique.
- Exemples et pièges: Exemple pratique: Fournir du JavaScript pour enrichir une UI. Piège: Complexité de sécurité et difficulté de mise en cache ou de validation.
- Comment vérifier: Rechercher des réponses qui livrent du code exécutable et un mécanisme d’exécution côté client.
Les contraintes les plus couramment respectées sont: Stateless, Uniform Interface et Client‑Server. La contrainte la moins appliquée en production est Code On Demand.
Références: Roy Fielding (2000) dissertation sur REST; RFC 7231 (semantics des méthodes HTTP) et RFC 7234 (caching).
| Contrainte | Bénéfice principal | Indicateur pratique |
| Client‑Server | Modularité / évolutivité | Facile |
| Stateless | Scalabilité / tolérance | Facile |
| Cacheability | Performance | Moyen |
| Uniform Interface | Interopérabilité | Facile |
| Layered System | Résilience / sécurité | Moyen |
| Code On Demand | Flexibilité client | Difficile |
Comment fonctionne une requête REST étape par étape
Une requête REST suit un cycle simple : client → requête HTTP (URL, méthode, en‑têtes, corps) → serveur → réponse HTTP (statut, en‑têtes, corps).
La résolution du host et de l’endpoint commence par une requête DNS (Domain Name System) pour traduire le nom en adresse IP, puis par l’établissement d’une connexion TCP/TLS si nécessaire.
La sélection de la méthode HTTP détermine l’intention : GET pour lire, POST pour créer, PUT/PATCH pour modifier, DELETE pour supprimer.
La construction des en‑têtes inclut Authorization (jeton d’accès), Content-Type (format du corps envoyé), Accept (formats acceptés en réponse) et Cache-Control (règles de mise en cache).
Le format du corps est le plus souvent JSON (JavaScript Object Notation), un format léger, lisible et largement supporté.
La gestion des codes de réponse informe du résultat : 200 OK (requête réussie), 201 Created (ressource créée), 204 No Content (success sans corps), 400 Bad Request (mauvaise requête), 401 Unauthorized (authentification requise), 404 Not Found (ressource inexistante), 409 Conflict (conflit d’état), 500 Internal Server Error (erreur serveur).
curl -i -H "Accept: application/json" https://api.exemple.com/users/123
La commande curl lance la requête.
L’option -i inclut les en‑têtes de réponse.
L’en‑tête Accept demande du JSON.
L’URL cible l’endpoint users/123.
curl -X POST -H "Authorization: Bearer TOKEN" -H "Content-Type: application/json" -d '{"name":"Alice","email":"a@ex.com"}' https://api.exemple.com/users
L’option -X POST force la méthode POST.
L’en‑tête Authorization porte le jeton Bearer.
Content-Type précise que le corps est en JSON.
-l’option -d envoie l’objet JSON pour créer la ressource.
curl -X PATCH -H "Authorization: Bearer TOKEN" -H "Content-Type: application/json-patch+json" -d '[{"op":"replace","path":"/email","value":"new@ex.com"}]' https://api.exemple.com/users/123
La méthode PATCH effectue une mise à jour partielle.
Le corps suit le format JSON Patch (opérations de modification).
L’endpoint cible l’identifiant de la ressource à modifier.
HTTP/1.1 200 OK
Cache-Control: public, max-age=3600
Link: <https://api.exemple.com/users?page=2>; rel="next", <https://api.exemple.com/users?page=10>; rel="last"
Content-Type: application/json
La ligne d’état indique le succès.
Cache-Control montre que la réponse est cacheable pour 3600 secondes.
Link fournit les URLs de pagination avec rel= »next » et rel= »last ».
Content-Type confirme le format du corps.
| Méthode | Usage recommandé | Idempotence | Code de succès attendu |
| GET | Lire une ressource | Oui | 200 |
| POST | Créer une ressource | Non | 201 |
| PUT | Remplacer une ressource | Oui | 200/204 |
| PATCH | Modifier partiellement | Non (généralement) | 200/204 |
| DELETE | Supprimer une ressource | Oui | 204 |
Prêt à concevoir ou auditer une REST API efficace pour votre projet ?
En résumé, une REST API standardise l’échange de données via HTTP en s’appuyant sur des règles (URL, méthodes, en‑têtes, corps) et des contraintes architecturales définies par Roy Fielding. Comprendre le cycle requête‑réponse, les six contraintes et l’anatomie d’une requête vous permet de concevoir des API plus fiables, scalables et interopérables. En appliquant ces principes vous réduisez les erreurs, améliorez la performance et facilitez l’évolution de vos systèmes : bénéfice direct pour vos équipes techniques et vos utilisateurs.
FAQ
-
Qu’est‑ce qu’une REST API ?
Une REST API est un service web qui expose des ressources via HTTP selon des contraintes architecturales (définies par Roy Fielding). Elle utilise des URL pour identifier les ressources, des méthodes HTTP pour les opérations et des en‑têtes/corps pour les métadonnées et données. -
REST est‑il identique à HTTP ?
Non. HTTP est le protocole de transport. REST est un style architectural qui s’appuie souvent sur HTTP. REST décrit des contraintes (stateless, uniform interface…) que l’on applique en pratique via HTTP. -
Quand utiliser PUT ou PATCH pour les mises à jour ?
PUT remplace entièrement une ressource (idempotent). PATCH applique une modification partielle (non forcément idempotent). Choisissez PUT pour remplacement complet, PATCH pour modifications ciblées et moins verbeuses. -
Les REST API doivent‑elles être stateless ?
Idéalement oui : chaque requête doit contenir toutes les informations nécessaires. Le statelessness facilite la scalabilité et la résilience. Si un état est nécessaire, stockez‑le côté client ou dans un store partagé (ex : token, cache distribué). -
Quelles bonnes pratiques de sécurité appliquer ?
Utilisez HTTPS, authentification et autorisation (OAuth2, JWT selon le cas), validation côté serveur, limitation de débit (rate limiting) et en-têtes sécuritaires. Ne stockez pas d’informations sensibles dans les URLs et gérez correctement les erreurs pour éviter les fuites d’information.
A propos de l’auteur
Je suis Franck Scandolera, expert & formateur en tracking avancé server‑side, Analytics Engineering, automatisation No/Low Code (n8n), intégration de l’IA en entreprise et SEO/GEO. J’ai accompagné des clients comme Logis Hôtel, Yelloh Village, BazarChic, la Fédération Française de Football et Texdecor. Responsable de l’agence webAnalyste et de l’organisme de formation « Formations Analytics ». Disponible pour aider vos équipes à concevoir ou auditer vos APIs et pipelines : contactez‑moi.
⭐ Analytics engineer, Data Analyst et Automatisation IA indépendant ⭐
- Ref clients : Logis Hôtel, Yelloh Village, BazarChic, Fédération Football Français, Texdecor…
Mon terrain de jeu :
- Data Analyst & Analytics engineering : tracking avancé (GTM server, e-commerce, CAPI, RGPD), entrepôt de données (BigQuery, Snowflake, PostgreSQL, ClickHouse), modèles (Airflow, dbt, Dataform), dashboards décisionnels (Looker, Power BI, Metabase, SQL, Python).
- Automatisation IA des taches Data, Marketing, RH, compta etc : conception de workflows intelligents robustes (n8n, App Script, scraping) connectés aux API de vos outils et LLM (OpenAI, Mistral, Claude…).
- Engineering IA pour créer des applications et agent IA sur mesure : intégration de LLM (OpenAI, Mistral…), RAG, assistants métier, génération de documents complexes, APIs, backends Node.js/Python.






