Consommer une API : fetch en JavaScript, PHP, Python et C#

const API = 'https://api.gsb.example/v1';

async function chargerFiche(id, jeton) {
  const reponse = await fetch(`${API}/fiches/${id}`, {
    headers: {
      Accept: 'application/json',
      Authorization: `Bearer ${jeton}`,
    },
  });
  if (!reponse.ok) {
    throw new Error(`Erreur ${reponse.status}`);
  }
  return reponse.json();   // une autre promesse : le corps lu et converti
}

const fiche = await chargerFiche(12, jeton);
console.log(fiche.mois, fiche.etat);   // 2026-10 CR

const reponse = await fetch(`${API}/fiches/12/frais-hors-forfait`, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    Authorization: `Bearer ${jeton}`,
  },
  body: JSON.stringify({ date: '2026-10-14', libelle: 'Repas client à Lyon', montant: 23.5 }),
});
if (reponse.status === 201) {
  console.log('Créé à', reponse.headers.get('Location'));
}

const params = new URLSearchParams({ etat: 'CL', mois: '2026-10', q: 'note de frais' });
const url = `${API}/fiches?${params}`;
// https://api.gsb.example/v1/fiches?etat=CL&mois=2026-10&q=note+de+frais

try {
  const reponse = await fetch(`${API}/fiches`, { signal: AbortSignal.timeout(5000) });
  // …
} catch (e) {
  if (e.name === 'TimeoutError') console.error("L'API n'a pas répondu en 5 secondes");
  else throw e;
}

class ErreurApi extends Error {
  constructor(probleme) {
    super(probleme.detail ?? probleme.title);
    this.status = probleme.status;
    this.type = probleme.type;
    this.probleme = probleme;   // le corps RFC 9457 complet, avec ses extensions
  }
}

async function appelerApi(chemin, { methode = 'GET', corps, signal } = {}) {
  const reponse = await fetch(`${API}${chemin}`, {
    method: methode,
    headers: {
      Accept: 'application/json',
      Authorization: `Bearer ${lireJeton()}`,
      ...(corps !== undefined && { 'Content-Type': 'application/json' }),
    },
    body: corps !== undefined ? JSON.stringify(corps) : undefined,
    signal: signal ?? AbortSignal.timeout(5000),
  });

  if (reponse.status === 204) return null;
  const type = reponse.headers.get('Content-Type') ?? '';
  const donnees = type.includes('json') ? await reponse.json() : await reponse.text();
  if (!reponse.ok) {
    throw new ErreurApi(typeof donnees === 'object' ? donnees : { status: reponse.status, title: donnees });
  }
  return donnees;
}

try {
  const fiche = await appelerApi('/fiches', { methode: 'POST', corps: { mois: moisChoisi } });
  afficherFiche(fiche);
} catch (e) {
  if (!(e instanceof ErreurApi)) afficherMessage('Connexion impossible. Vérifie ton réseau.');
  else if (e.status === 401) redirigerVersConnexion();
  else if (e.status === 409) afficherMessage('Tu as déjà une fiche pour ce mois.');
  else if (e.status === 422) afficherErreursChamps(e.probleme.erreurs);
  else afficherMessage(`Erreur inattendue (${e.status}). Réessaie plus tard.`);
}

<?php
function appelerApi(string $methode, string $url, ?array $corps = null, string $jeton = ''): array
{
    $ch = curl_init($url);
    $entetes = ['Accept: application/json'];
    if ($jeton !== '') {
        $entetes[] = 'Authorization: Bearer ' . $jeton;
    }
    if ($corps !== null) {
        $entetes[] = 'Content-Type: application/json';
        curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($corps, JSON_THROW_ON_ERROR));
    }
    curl_setopt_array($ch, [
        CURLOPT_CUSTOMREQUEST  => $methode,
        CURLOPT_HTTPHEADER     => $entetes,
        CURLOPT_RETURNTRANSFER => true,   // renvoyer le corps au lieu de l'afficher
        CURLOPT_CONNECTTIMEOUT => 3,      // secondes pour établir la connexion
        CURLOPT_TIMEOUT        => 10,     // secondes au total
    ]);

    $texte = curl_exec($ch);
    if ($texte === false) {
        throw new RuntimeException('Erreur réseau : ' . curl_error($ch));
    }
    $statut = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
    $donnees = $texte === '' ? null : json_decode($texte, true, 512, JSON_THROW_ON_ERROR);

    return ['statut' => $statut, 'donnees' => $donnees];
}

$reponse = appelerApi('GET', 'https://geo.api.gouv.fr/communes?' . http_build_query([
    'codePostal' => '69001',
    'fields'     => 'nom,population',
]));
if ($reponse['statut'] === 200) {
    foreach ($reponse['donnees'] as $commune) {
        echo htmlspecialchars($commune['nom']), "\n";
    }
}

import requests

API = "https://api.gsb.example/v1"
session = requests.Session()   # réutilise la connexion et les en-têtes communs
session.headers.update({"Authorization": f"Bearer {jeton}", "Accept": "application/json"})

# Lire une liste filtrée : params encode la chaîne de requête
reponse = session.get(f"{API}/fiches", params={"etat": "CR", "limite": 20}, timeout=5)
reponse.raise_for_status()   # lève HTTPError pour un code 4xx ou 5xx
for fiche in reponse.json()["donnees"]:
    print(fiche["id"], fiche["mois"], fiche["etat"])

# Créer une fiche et traiter les erreurs
try:
    reponse = session.post(f"{API}/fiches", json={"mois": "2026-13"}, timeout=5)
    reponse.raise_for_status()
    print("Créée :", reponse.headers["Location"])
except requests.HTTPError as e:
    probleme = e.response.json()
    print(e.response.status_code, probleme["title"])
    for erreur in probleme.get("erreurs", []):
        print(" -", erreur["champ"], ":", erreur["message"])
except requests.RequestException as e:
    print("Problème réseau :", e)

12 2026-10 CR
13 2026-11 CR
422 Données invalides
 - mois : Format attendu : AAAA-MM

using System.Net;
using System.Net.Http.Headers;
using System.Net.Http.Json;

using var http = new HttpClient
{
    BaseAddress = new Uri("https://api.gsb.example/v1/"),
    Timeout = TimeSpan.FromSeconds(5),
};
http.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", jeton);

// Lire une fiche : le JSON devient un objet Fiche
Fiche? fiche = await http.GetFromJsonAsync<Fiche>("fiches/12");
Console.WriteLine($"{fiche!.Mois} {fiche.Etat}");   // 2026-10 CR

// Créer une fiche et lire le code de statut
HttpResponseMessage reponse = await http.PostAsJsonAsync("fiches", new { mois = "2026-11" });
if (reponse.StatusCode == HttpStatusCode.Created)
{
    Fiche? creee = await reponse.Content.ReadFromJsonAsync<Fiche>();
    Console.WriteLine($"Créée : {reponse.Headers.Location} (id {creee!.Id})");
}
else
{
    Probleme? p = await reponse.Content.ReadFromJsonAsync<Probleme>();
    Console.WriteLine($"{(int)reponse.StatusCode} {p?.Title} : {p?.Detail}");
}

record Fiche(int Id, int VisiteurId, string Mois, string Etat, decimal? MontantValide);
record Probleme(string Type, string Title, int Status, string? Detail);

const attendre = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const CODES_PASSAGERS = [429, 502, 503, 504];
const METHODES_IDEMPOTENTES = ['GET', 'HEAD', 'PUT', 'DELETE'];

async function fetchAvecReessais(url, options = {}, essaisMax = 4) {
  // Un POST (ou un PATCH) sans clé d'idempotence n'est jamais rejoué : un seul essai
  const methode = (options.method ?? 'GET').toUpperCase();
  const rejouable = METHODES_IDEMPOTENTES.includes(methode) || new Headers(options.headers).has('Idempotency-Key');
  if (!rejouable) essaisMax = 1;

  for (let essai = 1; ; essai++) {
    let reponse;
    try {
      reponse = await fetch(url, { ...options, signal: AbortSignal.timeout(5000) });
    } catch (erreur) {
      // Délai dépassé (TimeoutError) ou réseau coupé (TypeError) : passager lui aussi
      if (essai === essaisMax) throw erreur;
      await attendre(2 ** (essai - 1) * 1000 + Math.random() * 300);
      continue;
    }
    if (!CODES_PASSAGERS.includes(reponse.status) || essai === essaisMax) return reponse;

    // Retry-After en secondes si le serveur le donne, sinon 1 s, 2 s, 4 s… plus un peu de hasard
    const retryAfter = Number(reponse.headers.get('Retry-After'));
    const delai = retryAfter > 0 ? retryAfter * 1000 : 2 ** (essai - 1) * 1000 + Math.random() * 300;
    await attendre(delai);
  }
}

Front (navigateur)  →  API d'AppliFrais (détient la clé)  →  Service de géocodage
       aucun secret          contrôle le jeton de Lucas          reçoit la clé d'API