Une requête XHR est une requête HTTP envoyée depuis le navigateur par l’objet JavaScript XMLHttpRequest. Elle permet d’échanger des données avec un serveur sans recharger la page. Selon MDN, l’API sert à envoyer des requêtes HTTP entre une page web et un serveur, et malgré son nom elle ne se limite pas au format XML.
Dans cet article, vous allez écrire une requête XHR pas à pas, traiter la réponse et les erreurs, comprendre les blocages CORS, puis voir comment le Real User Monitoring (RUM) mesure ces requêtes chez de vrais utilisateurs. La partie Dynatrace vaut pour Dynatrace SaaS comme pour Dynatrace Managed : la notion d’action XHR est la même dans le RUM classique des deux plateformes.
En bref
- XHR est l’API historique d’AJAX : on crée l’objet, on pose des écouteurs, on appelle
open, puissend. - Fetch est aujourd’hui recommandé quand c’est possible, mais XHR reste très présent dans les bases de code existantes et dans de nombreuses bibliothèques.
- Les erreurs viennent surtout de trois sources : le statut HTTP, le réseau et CORS. Chacune se diagnostique différemment.
- Le Real User Monitoring mesure la durée et les échecs de ces requêtes côté navigateur, sur de vrais parcours, ce que les tests en laboratoire ne montrent pas.
Ce qu’est une requête XHR, concrètement
Quand vous cliquez sur « Charger plus » et que de nouveaux éléments apparaissent sans changement d’URL, il y a de fortes chances qu’une requête XHR (ou son équivalent Fetch) ait été envoyée en arrière-plan. Le principe, que MDN décrit dans son guide sur la récupération de données du serveur, sépare deux tâches : JavaScript demande les données au serveur, puis manipule le DOM pour mettre à jour l’interface, au lieu de déclencher une navigation complète.
L’acronyme AJAX (Asynchronous JavaScript and XML) date d’une époque où XML était le format d’échange courant. Aujourd’hui, le serveur renvoie le plus souvent du JSON, parfois du HTML ou du texte, comme le rappelle la même page MDN. Un cours de l’université de Caen Normandie insiste sur deux points : la réponse n’est pas forcément du XML, et l’écouteur doit être ajouté avant de lancer la requête avec send.
Le mot « asynchrone » est central. Le navigateur n’attend pas la réponse pour continuer à afficher la page et à réagir aux clics. Vous décrivez ce qui doit se passer à l’arrivée de la réponse, et le code continue.
Écrire une requête XHR pas à pas
Selon MDN, une requête suit trois étapes : créer l’objet, ouvrir l’URL avec open, puis envoyer avec send. L’argument async de open vaut true par défaut ou lorsqu’il est omis : la requête est alors asynchrone. Voici un exemple minimal qui récupère du JSON.

const xhr = new XMLHttpRequest();
xhr.addEventListener("load", () => {
if (xhr.status >= 200 && xhr.status < 300) {
const data = JSON.parse(xhr.responseText);
console.log(data);
} else {
console.error("Statut HTTP inattendu :", xhr.status);
}
});
xhr.addEventListener("error", () => console.error("Échec réseau"));
xhr.addEventListener("abort", () => console.warn("Requête annulée"));
xhr.open("GET", "https://api.exemple.fr/produits");
xhr.setRequestHeader("Accept", "application/json");
xhr.send();
Les quatre étapes à retenir
- Instancier l’objet avec
new XMLHttpRequest(). - Brancher les écouteurs d’événements. MDN précise qu’ils doivent être ajoutés avant l’appel à
open, sinon les événementsprogressne sont pas captés. - Ouvrir la requête avec
open(méthode, url). Les en-têtes se définissent aprèsopenet avantsend. - Envoyer avec
send(). D’après la page XMLHttpRequest.send(), cette méthode envoie la requête au serveur et accepte un paramètre facultatif pour le corps, utilisé surtout pour des requêtes comme PUT. Pour GET ou HEAD, ce corps est ignoré.
Envoyer des données avec POST
Pour un POST en JSON, ouvrez la requête avec la méthode POST, déclarez le type de contenu, puis passez le corps à send. L’exemple ci-dessous ajoute aussi un délai d’attente, détaillé plus loin :

const xhr = new XMLHttpRequest();
xhr.timeout = 8000;
xhr.addEventListener("timeout", () => console.warn("Délai dépassé"));
xhr.addEventListener("load", () => console.log(xhr.status));
xhr.open("POST", "/api/commandes");
xhr.setRequestHeader("Content-Type", "application/json");
xhr.send(JSON.stringify({ produit: 42, quantite: 2 }));
Choisir le type de réponse
La propriété responseType indique le format attendu : text (valeur par défaut), arraybuffer, blob, document ou json. Pour une API JSON, définir xhr.responseType = "json" avant l’envoi évite le JSON.parse manuel : le résultat se lit alors dans xhr.response, qui vaut null si le serveur renvoie autre chose que du JSON valide. Pour télécharger un fichier, blob est le choix habituel.
Suivre le déroulement : événements, statut et erreurs
Une requête XHR passe par plusieurs états, et la propriété readyState en donne la valeur. L’exemple historique de MDN teste readyState === XMLHttpRequest.DONE (la valeur 4) et status === 200 avant de lire la réponse. Les événements modernes sont plus lisibles que l’ancien onreadystatechange.

| Événement | Quand il se déclenche | Usage typique |
|---|---|---|
progress |
Pendant le transfert | Barre de progression d’un téléchargement |
load |
Transfert terminé | Lire la réponse et le statut |
error |
Échec de la requête (réseau, CORS) | Message d’erreur, nouvelle tentative |
abort |
Requête annulée | Nettoyer l’interface |
timeout |
Délai xhr.timeout dépassé |
Informer l’utilisateur |
loadend |
Fin, quel que soit le résultat | Masquer un indicateur de chargement |
Ce tableau reprend les définitions de la documentation MDN. Un point piège : load se déclenche aussi pour une réponse 404 ou 500, car le transfert a bien abouti. Testez donc toujours xhr.status dans le gestionnaire load, comme dans l’exemple plus haut. L’événement error, lui, signale que la requête n’a pas pu aboutir du tout.
Gérer le délai d’attente
Par défaut, xhr.timeout vaut 0, c’est-à-dire aucun délai : une requête peut rester en attente longtemps. Définissez xhr.timeout en millisecondes et écoutez l’événement timeout pour informer l’utilisateur, plutôt que de laisser un indicateur tourner indéfiniment. Cette valeur est aussi un bon point de départ pour décider ce qui est « trop lent » dans votre supervision.
Pourquoi une requête XHR échoue : HTTP, réseau et CORS
Trois familles de problèmes reviennent sans cesse. Les distinguer fait gagner beaucoup de temps.
Erreurs HTTP (4xx et 5xx)
Le serveur a répondu, mais avec un statut d’échec. La requête est « réussie » côté transfert, l’événement load se déclenche, et c’est à votre code de lire xhr.status. Un 401 ou 403 pointe vers l’authentification, un 404 vers une URL erronée, un 500 vers un problème côté serveur.
Erreurs réseau
Pas de réponse exploitable : connexion coupée, DNS introuvable, certificat invalide. Seul l’événement error se déclenche, sans statut utile. Dans le navigateur, le détail reste volontairement vague, et l’onglet Réseau des outils de développement est votre meilleur allié.
Erreurs CORS
Le navigateur applique la politique de même origine. Une requête vers un autre domaine n’aboutit que si le serveur l’autorise. MDN indique que XMLHttpRequest fonctionne tant que le serveur est configuré pour accepter l’origine de votre application web, via l’en-tête de réponse Access-Control-Allow-Origin. Côté code, le symptôme ressemble à une erreur réseau, mais la console du navigateur indique une raison CORS précise.
Deux cas fréquents :
- Les cookies ne partent pas. Par défaut, les justificatifs (cookies, en-têtes d’authentification) ne sont pas envoyés dans une requête inter-origines. Le client doit définir
xhr.withCredentialsàtrue, et le serveur doit répondre avec l’en-tête Access-Control-Allow-Credentials: true, sinon le navigateur signale une erreur réseau. - Le test se fait depuis un fichier local. Les requêtes CORS ne peuvent utiliser que les schémas HTTP ou HTTPS. D’après MDN, une page ouverte en
file:///a une origine opaque et provoque une erreur CORS dans Firefox comme dans Chrome. Lancez un petit serveur local à la place.
La correction d’un blocage CORS se fait presque toujours côté serveur, en configurant les en-têtes de réponse. Aucun code JavaScript côté client ne peut contourner proprement cette règle.
XHR ou Fetch : que choisir aujourd’hui ?
Pour un nouveau code, MDN conseille Fetch lorsque c’est possible, car l’API est plus simple et offre davantage de fonctionnalités. XHR reste fréquent dans les bases de code historiques : c’est l’API qui a précédé Fetch et la première à permettre AJAX (source MDN).
En pratique, vous croiserez XHR dans trois situations :
- une application ancienne à maintenir, où réécrire chaque appel n’est pas prioritaire ;
- une bibliothèque tierce qui utilise XHR en interne ;
- un besoin de suivi de progression d’envoi de fichier, où l’événement
progressde XHR reste pratique.
Pour la supervision, la bonne nouvelle est que le choix ne change pas l’essentiel : le RUM de Dynatrace capture les appels XMLHttpRequest comme les appels fetch(), et vous pouvez migrer progressivement sans perdre la visibilité sur vos appels.
Accessibilité : ne pas oublier ce qui change dans la page
Une mise à jour de contenu asynchrone est invisible pour une personne qui utilise un navigateur vocal si rien ne l’annonce. La norme WAI-ARIA fournit des spécifications pour limiter ce type de problème, comme le rappelle la page Wikipédia consacrée à XMLHttpRequest. Concrètement, signalez les changements importants avec une région aria-live et gérez le focus après un chargement partiel.
Superviser les requêtes XHR avec le Real User Monitoring
Votre code fonctionne sur votre machine, avec une bonne connexion. Mais vos utilisateurs ont des réseaux mobiles, des extensions de navigateur, des appareils anciens. Le Real User Monitoring collecte des mesures directement dans leur navigateur pour répondre à une question simple : que vivent réellement les utilisateurs ?
RUM et données de terrain
Google utilise les données RUM de terrain pour déterminer si un site respecte les seuils recommandés pour les Core Web Vitals, comme l’explique web.dev. Le même article note que les données RUM que vous collectez vous-même complètent les outils fondés sur CrUX, avec des retours plus détaillés et plus immédiats.
Ce que Dynatrace fait des requêtes XHR
Dans Dynatrace, une interaction utilisateur qui déclenche des XMLHttpRequest ou des appels fetch() crée une action XHR. La page « User actions » de la documentation Dynatrace précise que l’action commence au clic de l’utilisateur, que Dynatrace détecte aussi les XHR supplémentaires déclenchées dans le callback de la première, et qu’il attend la fin de toutes les requêtes avant de clore l’action. Une action web dure au maximum 3 minutes. Pour une application monopage, où presque toute la communication passe par XHR après le premier chargement, c’est ce qui rend les parcours mesurables.
Deux réglages à connaître dans la configuration de l’application web (RUM classique, SaaS et Managed) : la capture des XHR s’active dans Capturing > Async web requests and SPAs > Generic support, option « Capture XmlHttpRequest (XHR) », et des règles d’exclusion par expression régulière sur l’URL écartent les appels techniques (heartbeat, télémétrie) qui créeraient des actions parasites. Autre point documenté : la requête doit démarrer dans les 30 ms qui suivent l’interaction ; du code fondé sur des promesses peut dépasser cette fenêtre, et Dynatrace recommande alors l’API JavaScript RUM pour créer l’action soi-même.
Ce que vous pouvez lire ensuite dépend de votre configuration, mais les questions à poser sont toujours les mêmes :
- Quelle action est la plus lente pour les utilisateurs, et sur quel navigateur ou quel type d’appareil ?
- Quel appel XHR cause les erreurs, avec quel code HTTP ?
- La lenteur vient-elle du réseau ou du serveur ? Rapprochez la durée côté navigateur de la trace côté serveur.
- Les erreurs JavaScript apparaissent-elles juste après une réponse inattendue ?
Pour la mise en place de l’injection JavaScript, le choix des applications et la lecture des Core Web Vitals, suivez notre guide sur la configuration du RUM dans Dynatrace. Une fois vos actions mesurées, notre module sur le metric selector et les alertes montre comment interroger ces métriques et déclencher une alerte quand une durée dépasse votre seuil.
Un exemple de démarche de diagnostic
Imaginons une page de recherche dont l’utilisateur se plaint qu’elle « rame ». Voici une démarche réaliste, sans chiffres inventés :
- Dans le RUM, filtrez sur l’action XHR déclenchée par la recherche et regardez la répartition des durées plutôt que la moyenne.
- Segmentez par navigateur, pays et type de connexion, pour voir si le problème est général ou localisé.
- Si la durée est longue partout, ouvrez la trace distribuée associée et cherchez le service ou la requête de base de données responsable.
- Si elle n’est longue que sur mobile, examinez la taille de la réponse : une API qui renvoie trop de champs coûte cher sur un réseau lent.
- Après correction, comparez avant et après sur une même période pour confirmer l’effet.
Pour des objectifs de latence fondés sur la distribution plutôt que sur la moyenne, voyez aussi nos métriques histogrammes OpenPipeline. Et pour reproduire un appel lent depuis un agent de code, Chrome DevTools MCP donne accès au panneau Réseau depuis l’assistant.
Bonnes pratiques pour des requêtes XHR fiables
- Toujours tester
statusdansload, jamais seulement l’arrivée de l’événement. - Définir un
timeoutet un message clair pour l’utilisateur. - Annuler les requêtes devenues inutiles avec
abort(), par exemple quand l’utilisateur tape une nouvelle recherche. - Éviter le mode synchrone : il bloque l’interface, et
timeoutcommeresponseTypey sont interdits dans une page. - Préférer HTTPS et ne jamais placer de secret dans le code client.
- Mesurer en production : un appel qui paraît rapide en développement peut être lent chez vos utilisateurs.
Notre point de vue
Chez span.observer, nous constatons que la plupart des questions sur les requêtes XHR cachent une question de supervision : la requête part, mais personne ne sait combien de temps elle prend chez l’utilisateur ni pourquoi elle échoue.
Nous croyons qu’un développeur progresse plus vite quand il relie trois niveaux : le code (ce guide), la mesure côté navigateur (le RUM) et la trace côté serveur. C’est pourquoi nos tutoriels Dynatrace partent de problèmes concrets de production, en Managed comme en SaaS, et restent gratuits, indépendants et sans publicité.
Notre approche est de vous donner des gestes immédiatement applicables : configurer, lire, interroger, alerter. Vous apprenez à votre rythme, et vous pouvez partager ces ressources avec votre équipe.
Aller plus loin avec nos ressources gratuites
Si vous voulez passer de la requête XHR isolée à une vision complète de vos applications, notre formation observabilité gratuite suit un chemin progressif, des signaux jusqu’aux SLO. Elle s’adresse aux développeurs, aux SRE et aux responsables IT qui veulent former leurs équipes.
Questions fréquentes
Qu’est-ce qu’une requête XHR ?
C’est une requête HTTP envoyée par l’objet JavaScript XMLHttpRequest depuis le navigateur. Elle récupère ou envoie des données à un serveur sans recharger la page. Le format échangé est le plus souvent du JSON, même si XML figure dans le nom.
XHR et Fetch, quelle différence ?
Les deux envoient des requêtes HTTP depuis le navigateur. MDN conseille Fetch quand c’est possible, car il est plus simple et plus riche en fonctionnalités. XHR reste utile pour maintenir du code existant, et le RUM de Dynatrace capture les deux mécanismes au même titre.
Pourquoi ma requête XHR est-elle bloquée par CORS ?
Le serveur de destination n’autorise pas l’origine de votre page. Il faut configurer ses en-têtes de réponse CORS, et ajouter withCredentials côté client si des cookies doivent être envoyés. Vérifiez aussi que vous ne testez pas depuis une page ouverte en file:///.
Que mesure le Real User Monitoring sur une requête XHR ?
Il mesure, dans le navigateur de vrais utilisateurs, la durée et le résultat des appels déclenchés par leurs actions. Dans Dynatrace, ces appels forment des actions XHR que vous pouvez filtrer par navigateur, localisation ou application. Notre guide RUM détaille la configuration.
Sources
- Utiliser XMLHttpRequest, MDN
- XMLHttpRequest.send(), MDN
- Récupérer des données du serveur, MDN
- Ajax : Asynchronous JavaScript & XML, université de Caen Normandie
- En-tête Access-Control-Allow-Credentials, MDN
- Raison : la requête CORS n’utilise pas HTTP, MDN
- Premiers pas avec la mesure des Web Vitals, web.dev
- User actions (actions XHR), documentation Dynatrace
- Configure Real User Monitoring to capture XHR actions, documentation Dynatrace
- XMLHttpRequest, Wikipédia
span.observer est un blog indépendant, non affilié à Dynatrace LLC. Les noms de produits cités appartiennent à leurs propriétaires respectifs ; les exemples de code et les URL sont fictifs et donnés à titre pédagogique.