←écrits
Architecture· Mai 2026, revu en octobre 2026· Lecture · 9 min

Les sept familles d'API

REST, SOAP, gRPC, GraphQL, Webhooks, WebSockets, WebRTC. Sept manières de faire communiquer deux machines, chacune taillée pour un problème précis. Ce mémo les range par usage.

D'abord, c'est quoi une API ?

API veut dire Application Programming Interface. C'est le contrat qui permet à un programme d'en utiliser un autre sans connaître ses détails internes. Ce contrat peut être une bibliothèque appelée en mémoire, un service local exposé sur une socket ou, ce qui nous intéresse ici, un système distant joint par le réseau.

La suite parle donc des API réseau, où deux machines échangent des données ou déclenchent des opérations à distance selon un protocole défini. Les sept familles ci-dessous se distinguent par ce protocole.

Trois axes pour s'orienter

Comparer ces protocoles sur leur popularité ou leur âge ne mène pas loin. Chacun répond à un problème de communication, et trois questions suffisent à les séparer.

Trois questions pour les ranger
Qui initie ?
Client demande
Serveur pousse
Les deux en duplex
Combien de temps ?
One-shot (requête / réponse)
Persistant (connexion ouverte)
Streaming (flux continu)
Quel format ?
Texte (JSON, XML)
Binaire (Protobuf)
Media (audio/vidéo)

Vus sous ces trois angles, ce ne sont plus sept protocoles concurrents. GraphQL et REST sont proches voisins, WebRTC est loin des deux, et c'est pour cela qu'on ne remplace pas l'un par l'autre.

REST, le standard de facto

REST n'est pas un protocole mais un style d'architecture, décrit par Roy Fielding dans sa thèse en 2000. Tout y est une ressource identifiée par une URL. Le style ne dépend pas de HTTP, mais les API dites RESTful manipulent ces ressources avec les verbes HTTP (GET, POST, PUT, PATCH, DELETE), et la plupart ignorent la contrainte d'hypermédia (HATEOAS) de Fielding. Chaque requête est stateless : le serveur ne garde aucun contexte de session entre deux appels. Les ressources vivent bien côté serveur, c'est la conversation qui est sans mémoire.

requête → réponse, sans état partagé

Transport
HTTP (1.1, 2 ou 3)
Format
JSON (souvent), texte
Pattern
Requête → réponse
Récupérer un utilisateur
GET /api/users/42 → 200 OK { "id": 42, "name": "Alice", "email": "alice@example.com" }
Forces
  • Universellement supporté, cacheable nativement
  • Conventions claires, courbe d'apprentissage douce
  • Outillage abondant (curl, Postman, navigateurs)
Limites
  • Over-fetching et under-fetching fréquents
  • Pas de push dans le modèle requête/réponse (il faut SSE ou WebSockets)
  • Versioning des contrats parfois douloureux
À utiliser pour API publiques web, CRUD applicatif, intégrations tierces, mobile classique. Quand on hésite, c'est le défaut raisonnable.

Mon avis. Pour une nouvelle app SaaS B2B, je commence presque toujours par REST. Le coût d'entrée est nul, l'outillage suit, et le jour où une portion du trafic exige réellement du streaming ou de l'agrégation côté client, on ajoute la techno qui répond (gRPC sur un sous-chemin interne, GraphQL sur un BFF) sans tout réécrire.

SOAP, le vétéran de l'entreprise

SOAP est un protocole strict basé sur XML. Le nom voulait dire Simple Object Access Protocol, mais depuis la version 1.2 (2003) ce n'est plus un acronyme. Son contrat formel, le WSDL, décrit chaque opération et chaque type de données. On se moque souvent de sa verbosité, pourtant il reste en place dans la banque, l'assurance, la défense et les systèmes qui ont besoin de transactions distribuées entre applications.

enveloppe XML lourde, contrat WSDL strict

Transport
HTTP, SMTP, TCP, JMS…
Format
XML strict + WSDL
Pattern
Requête → réponse
Enveloppe SOAP 1.2 minimale
POST /UserService Content-Type: application/soap+xml; charset=utf-8 <soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope"> <soap:Body> <GetUser> <UserId>42</UserId> </GetUser> </soap:Body> </soap:Envelope>
Forces
  • Contrats stricts via WSDL, génération de clients
  • Sécurité robuste (WS-Security, signatures XML)
  • Commit atomique distribué (WS-AtomicTransaction)
Limites
  • Verbosité XML énorme (overhead réseau et CPU)
  • Outillage moderne plus rare, courbe raide
  • Mal adapté au web mobile et aux navigateurs
À utiliser pour Systèmes legacy d'entreprise, intégrations bancaires, secteurs réglementés. C'est rarement le choix d'un nouveau projet.

gRPC, la performance pour le back-to-back

gRPC est le framework RPC ouvert par Google en 2015. Il combine trois choix techniques : Protocol Buffers comme format binaire compact, HTTP/2 comme transport (multiplexage, streams, compression d'en-têtes), et la génération de code à partir d'un fichier .proto dans la plupart des langages. On obtient des appels typés et rapides, avec du streaming dans les deux sens.

frames binaires multiplexés sur HTTP/2, streaming bidirectionnel

Transport
HTTP/2 (gRPC natif)
Format
Protocol Buffers (binaire)
Pattern
Unary + 3 modes streaming
Contrat .proto
syntax = "proto3"; service UserService { rpc GetUser(UserId) returns (User); rpc StreamUsers(Filter) returns (stream User); } message User { int32 id = 1; string name = 2; }
Forces
  • Payload souvent bien plus compact que JSON
  • Streaming bidirectionnel natif
  • Génération de clients typés multi-langages
Limites
  • Navigateur via gRPC-Web et un proxy, sans streaming client ni bidirectionnel
  • Debug binaire moins direct que JSON
  • Le gRPC natif exige HTTP/2 de bout en bout
À utiliser pour Microservices internes haute performance, communication inter-datacenters, environnements polyglottes avec contrats stricts. Utilisé chez Google, Square ou Netflix.

Mon avis. gRPC seulement si l'organisation sait opérer Protobuf : codegen intégré au CI, breaking changes versionnés avec rigueur, outillage de debug binaire en place. Sinon on gagne en performance et on perd en productivité.

GraphQL, le client décide ce qu'il veut

GraphQL (Facebook, publié en 2015) donne la main au client. Au lieu d'une liste figée d'endpoints, le serveur publie un schéma typé, et le client y décrit exactement les champs dont il a besoin, en une seule requête. Plus besoin d'enchaîner GET /user, GET /user/posts puis GET /user/posts/comments.

une requête déclarative, une réponse de forme identique

Transport
HTTP (souvent POST)
Format
Query language + JSON
Pattern
Requête déclarative
Requête GraphQL
query { user(id: 42) { name posts(last: 3) { title comments { author } } } }
Forces
  • Plus d'over-fetching, une seule requête réseau
  • Schéma typé, introspection, outillage riche
  • Évolution sans versioning de l'API
Limites
  • Caching HTTP nettement moins naturel qu'en REST, exige une stratégie dédiée (persisted queries, Apollo Cache, etc.)
  • Problème du N+1 côté résolveurs
  • Complexité backend, risque de requêtes coûteuses
À utiliser pour Frontends complexes avec besoins de données variables (apps mobile + web partageant un backend), agrégation de plusieurs services, BFF (Backend For Frontend).

Mon avis. Souvent trop lourd pour une seule appli web. La valeur de GraphQL apparaît quand plusieurs frontends différents tapent le même backend. Sinon, on paie la complexité serveur sans en récolter les bénéfices.

Webhooks, l'API inversée

Avec un webhook, c'est le service tiers qui appelle. On lui donne une URL, et quand un événement survient chez lui (paiement réussi, commit poussé, message reçu), il envoie une requête HTTP vers cette URL. Plus besoin de demander toutes les cinq secondes s'il y a du nouveau : on est prévenu au moment où ça se produit.

le serveur déclenche, votre endpoint reçoit

Transport
HTTP (POST entrant)
Format
JSON (souvent signé HMAC)
Pattern
Serveur → client (push)
Webhook Stripe entrant (extrait)
POST https://mon-app.com/webhooks/stripe Stripe-Signature: t=1715...,v1=a4f7b2... { "id": "evt_1Q...", "object": "event", "type": "payment_intent.succeeded", "data": { "object": { "amount": 4200, "customer": "cus_xyz" } } }
Forces
  • Quasi temps réel sans polling
  • Découplage propre entre producteur et consommateur
  • Économise une énorme charge serveur
Limites
  • Endpoint public requis (NAT, firewall, tunnel)
  • Signature obligatoire (HMAC) sinon falsifiable
  • Retries et idempotence à la charge du consommateur
À utiliser pour Événements de paiement (Stripe), déclenchement de CI (webhooks GitHub, GitLab), notifications de messageries, intégrations Zapier-like. Toute architecture event-driven inter-systèmes.

WebSockets, le tunnel bidirectionnel

WebSocket ouvre une connexion TCP persistante et bidirectionnelle entre client et serveur, après un handshake HTTP initial qui « upgrade » la connexion. Une fois établie, les deux côtés peuvent émettre des messages à tout moment, sans nouveau cycle requête-réponse. D'où le chat temps réel, les flux de marché, l'édition collaborative.

une connexion ouverte, du trafic libre dans les deux sens

Transport
TCP (upgrade HTTP/1.1)
Format
Libre (texte ou binaire)
Pattern
Full-duplex persistant
Handshake puis dialogue
// 1. Upgrade HTTP → WebSocket (RFC 6455) GET /chat HTTP/1.1 Host: example.com Upgrade: websocket Connection: Upgrade Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ== Sec-WebSocket-Version: 13 → 101 Switching Protocols Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo= // 2. Dialogue libre dans les deux sens client → {"msg": "Salut tout le monde"} server → {"users_online": 42} server → {"msg": "Bob a rejoint"} client → {"typing": true}
Forces
  • Latence très faible, pas de re-handshake
  • Le serveur peut pousser à tout moment
  • Support navigateur natif depuis longtemps
Limites
  • Connexions stateful : scaling horizontal complexe
  • Reconnexion à gérer côté client
  • Proxies et load balancers parfois récalcitrants
À utiliser pour Chat temps réel, notifications push, jeux multijoueurs, tableaux de bord live, édition collaborative (Figma), flux financiers.

WebRTC, le pair-à-pair temps réel

WebRTC permet à deux navigateurs (ou applications) d'établir une connexion directe de pair à pair dans le cas idéal. Le serveur intervient pour la phase de signaling (échanger les descriptions de session, les SDP) et pour la traversée NAT (STUN, puis TURN si STUN échoue). En conditions réelles, TURN relaie souvent le trafic quand le NAT bloque la connexion directe, et une visio à plus de deux participants passe en pratique par un SFU (Selective Forwarding Unit) côté serveur. Le pair-à-pair pur reste l'exception.

phase 1 · signaling SDP, phase 2 · flux direct entre pairs

Transport
UDP par défaut (SRTP, SCTP sur DTLS), TCP via TURN
Format
Media + binaire arbitraire
Pattern
Pair-à-pair temps réel
Établissement d'une session
const pc = new RTCPeerConnection({ iceServers }); pc.ontrack = (e) => (videoEl.srcObject = e.streams[0]); pc.onicecandidate = (e) => e.candidate && signaling.send(e.candidate); // 1. Média local, puis offre SDP via le serveur de signaling const stream = await navigator.mediaDevices.getUserMedia({ video: true }); stream.getTracks().forEach((t) => pc.addTrack(t, stream)); await pc.setLocalDescription(await pc.createOffer()); signaling.send(pc.localDescription); // → pair distant // 2. Le pair distant répond avec sa SDP await pc.setRemoteDescription(answer); // 3. Le média passe en direct, ou par TURN
Forces
  • La latence la plus basse du lot, pensée pour la voix et la vidéo
  • P2P quand il s'établit : économise la bande passante serveur
  • Chiffrement obligatoire (DTLS-SRTP), end-to-end en P2P pur
Limites
  • Complexité du signaling, STUN, TURN à opérer
  • P2P pur ne scale pas au-delà de quelques pairs (SFU)
  • Debug et observabilité difficiles
À utiliser pour Visioconférence (Google Meet, Jitsi), appels audio in-app, streaming live faible latence, transferts P2P de fichiers, jeux en cloud.

Mon avis. Le P2P gratuit n'existe pas en production. Entre TURN à provisionner, un SFU dimensionné pour les appels à plus de deux et une équipe pour observer la pile WebRTC, le coût d'exploitation approche celui d'un serveur de streaming classique. On le choisit quand la latence l'impose, rarement par défaut.

La matrice de décision

Tout revient à une question pratique : qu'est-ce que je veux faire ?

Si l'objectif est… Le bon choix Pourquoi
Exposer une API publique REST Universel, cacheable, attendu par les intégrateurs
Communiquer entre microservices internes gRPC Compact, typé, streaming, multi-langages
Servir un frontend mobile + web complexe GraphQL Évite l'over-fetching, une requête par écran
Réagir à des événements externes Webhooks Pas de polling, découplage propre
Chat, notifications, dashboards live WebSockets Bidirectionnel persistant, faible latence
Audio / vidéo / data en temps réel WebRTC Pair-à-pair, latence minimale, media-natif
S'intégrer à un système bancaire legacy SOAP Contrats stricts, sécurité éprouvée, déjà en place

Si tu dois décider demain

Trois questions, dans cet ordre

1 · Qui appelle qui ? Client → serveur, c'est REST/GraphQL/gRPC. Serveur → client, c'est Webhooks. Les deux à tout moment, c'est WebSockets ou WebRTC.
2 · Une réponse, ou un flux ? Une réponse, défaut REST. Un flux media, défaut WebRTC. Un flux de messages, défaut WebSockets.
3 · Qui consomme ? Un navigateur ouvert → REST/GraphQL/WebSockets. Du back-to-back interne polyglotte → gRPC. Un système bancaire → SOAP, parce qu'il est déjà là.

Le plus souvent, on s'arrête à la question 1. Le choix par défaut reste REST avec des webhooks, et le reste doit justifier son surcoût d'exploitation.

Mémo

REST pour le web ouvert, gRPC pour le back-to-back interne, GraphQL pour les frontends gourmands, Webhooks pour réagir, WebSockets pour dialoguer, WebRTC pour le temps réel media, SOAP pour le legacy d'entreprise.