Una solicitud XHR es una petición HTTP enviada desde el navegador mediante el objeto JavaScript XMLHttpRequest. Permite intercambiar datos con un servidor sin recargar la página. Según MDN, la API sirve para enviar peticiones HTTP entre una página web y un servidor y, pese a su nombre, no se limita al formato XML.
En este artículo vas a escribir una solicitud XHR paso a paso, tratar la respuesta y los errores, entender los bloqueos CORS y, después, ver cómo el Real User Monitoring (RUM) mide estas peticiones en usuarios reales. La parte de Dynatrace vale tanto para Dynatrace SaaS como para Dynatrace Managed: el concepto de acción XHR es el mismo en el RUM clásico de ambas plataformas.
En resumen
- XHR es la API histórica de AJAX: se crea el objeto, se registran los escuchadores, se llama a
openy después asend. - Fetch es hoy la opción recomendada cuando es posible, pero XHR sigue muy presente en bases de código existentes y en muchas bibliotecas.
- Los errores proceden sobre todo de tres fuentes: el estado HTTP, la red y CORS. Cada una se diagnostica de forma distinta.
- El Real User Monitoring mide la duración y los fallos de estas peticiones en el navegador, en recorridos reales, algo que las pruebas de laboratorio no muestran.
Qué es una solicitud XHR, en concreto
Cuando haces clic en «Cargar más» y aparecen nuevos elementos sin que cambie la URL, lo más probable es que se haya enviado una solicitud XHR (o su equivalente Fetch) en segundo plano. El principio, que MDN describe en su guía sobre la obtención de datos del servidor, separa dos tareas: JavaScript pide los datos al servidor y después manipula el DOM para actualizar la interfaz, en lugar de provocar una navegación completa.
El acrónimo AJAX (Asynchronous JavaScript and XML) procede de una época en la que XML era el formato de intercambio habitual. Hoy el servidor devuelve casi siempre JSON, a veces HTML o texto, como recuerda la misma página de MDN. Un curso de la Universidad de Caen Normandía insiste en dos puntos: la respuesta no tiene por qué ser XML, y el escuchador debe añadirse antes de lanzar la petición con send.
La palabra «asíncrono» es central. El navegador no espera la respuesta para seguir mostrando la página y reaccionando a los clics. Tú describes lo que debe ocurrir cuando llegue la respuesta, y el código continúa.
Escribir una solicitud XHR paso a paso
Según MDN, una petición sigue tres etapas: crear el objeto, abrir la URL con open y enviar con send. El argumento async de open vale true por defecto o cuando se omite: la petición es entonces asíncrona. Este es un ejemplo mínimo que obtiene 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();
Las cuatro etapas que debes recordar
- Instanciar el objeto con
new XMLHttpRequest(). - Registrar los escuchadores de eventos. MDN precisa que deben añadirse antes de llamar a
open; de lo contrario, los eventosprogressno se capturan. - Abrir la petición con
open(método, url). Las cabeceras se definen después deopeny antes desend. - Enviar con
send(). Según la página XMLHttpRequest.send(), este método envía la petición al servidor y acepta un parámetro opcional para el cuerpo, usado sobre todo en peticiones como PUT. En GET o HEAD, ese cuerpo se ignora.
Enviar datos con POST
Para un POST en JSON, abre la petición con el método POST, declara el tipo de contenido y pasa el cuerpo a send. El ejemplo siguiente añade además un tiempo de espera, que se detalla más adelante:

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 }));
Elegir el tipo de respuesta
La propiedad responseType indica el formato esperado: text (valor por defecto), arraybuffer, blob, document o json. Para una API JSON, definir xhr.responseType = "json" antes del envío evita el JSON.parse manual: el resultado se lee entonces en xhr.response, que vale null si el servidor devuelve algo distinto de JSON válido. Para descargar un archivo, blob es la opción habitual.
Seguir el desarrollo: eventos, estado y errores
Una solicitud XHR pasa por varios estados, y la propiedad readyState indica su valor. El ejemplo histórico de MDN comprueba readyState === XMLHttpRequest.DONE (el valor 4) y status === 200 antes de leer la respuesta. Los eventos modernos son más legibles que el antiguo onreadystatechange.

| Evento | Cuándo se dispara | Uso típico |
|---|---|---|
progress |
Durante la transferencia | Barra de progreso de una descarga |
load |
Transferencia terminada | Leer la respuesta y el estado |
error |
Fallo de la petición (red, CORS) | Mensaje de error, nuevo intento |
abort |
Petición cancelada | Limpiar la interfaz |
timeout |
Tiempo xhr.timeout superado |
Informar al usuario |
loadend |
Fin, sea cual sea el resultado | Ocultar un indicador de carga |
Esta tabla recoge las definiciones de la documentación de MDN. Una trampa habitual: load también se dispara con una respuesta 404 o 500, porque la transferencia sí terminó. Comprueba siempre xhr.status dentro del gestor de load, como en el ejemplo anterior. El evento error, en cambio, indica que la petición no pudo completarse en absoluto.
Gestionar el tiempo de espera
Por defecto, xhr.timeout vale 0, es decir, sin límite: una petición puede quedarse esperando mucho tiempo. Define xhr.timeout en milisegundos y escucha el evento timeout para informar al usuario, en lugar de dejar un indicador girando indefinidamente. Este valor también es un buen punto de partida para decidir qué es «demasiado lento» en tu monitorización.
Por qué falla una solicitud XHR: HTTP, red y CORS
Tres familias de problemas se repiten sin cesar. Distinguirlas ahorra mucho tiempo.
Errores HTTP (4xx y 5xx)
El servidor respondió, pero con un estado de fallo. La petición «tuvo éxito» en la transferencia, el evento load se dispara y es tu código quien debe leer xhr.status. Un 401 o 403 apunta a la autenticación, un 404 a una URL errónea y un 500 a un problema del lado del servidor.
Errores de red
No hay respuesta aprovechable: conexión cortada, DNS no encontrado, certificado inválido. Solo se dispara el evento error, sin estado útil. En el navegador el detalle es deliberadamente vago, y la pestaña Red de las herramientas de desarrollo es tu mejor aliada.
Errores CORS
El navegador aplica la política del mismo origen. Una petición a otro dominio solo se completa si el servidor lo autoriza. MDN indica que XMLHttpRequest funciona siempre que el servidor esté configurado para aceptar el origen de tu aplicación web, mediante la cabecera de respuesta Access-Control-Allow-Origin. En el código, el síntoma se parece a un error de red, pero la consola del navegador indica una razón CORS precisa.
Dos casos frecuentes:
- Las cookies no se envían. Por defecto, las credenciales (cookies, cabeceras de autenticación) no se envían en una petición entre orígenes. El cliente debe poner
xhr.withCredentialsatrue, y el servidor debe responder con la cabecera Access-Control-Allow-Credentials: true; de lo contrario, el navegador señala un error de red. - La prueba se hace desde un archivo local. Las peticiones CORS solo pueden usar los esquemas HTTP o HTTPS. Según MDN, una página abierta con
file:///tiene un origen opaco y provoca un error CORS tanto en Firefox como en Chrome. Arranca un pequeño servidor local en su lugar.
La corrección de un bloqueo CORS se hace casi siempre en el servidor, configurando las cabeceras de respuesta. Ningún código JavaScript del lado del cliente puede saltarse limpiamente esta regla.
¿XHR o Fetch? Qué elegir hoy
Para código nuevo, MDN aconseja Fetch cuando sea posible, porque la API es más sencilla y ofrece más funcionalidades. XHR sigue siendo frecuente en bases de código históricas: es la API que precedió a Fetch y la primera que permitió AJAX (fuente MDN).
En la práctica, te encontrarás XHR en tres situaciones:
- una aplicación antigua que hay que mantener, donde reescribir cada llamada no es prioritario;
- una biblioteca de terceros que usa XHR internamente;
- una necesidad de seguir el progreso de una subida de archivo, donde el evento
progressde XHR sigue siendo práctico.
Para la monitorización, la buena noticia es que la elección no cambia lo esencial: el RUM de Dynatrace captura las llamadas XMLHttpRequest igual que las llamadas fetch(), y puedes migrar de forma progresiva sin perder visibilidad sobre tus llamadas.
Accesibilidad: no olvidar lo que cambia en la página
Una actualización de contenido asíncrona es invisible para una persona que usa un navegador por voz si nada la anuncia. La norma WAI-ARIA ofrece especificaciones para limitar este tipo de problema, como recuerda la página de Wikipedia dedicada a XMLHttpRequest. En concreto, señala los cambios importantes con una región aria-live y gestiona el foco tras una carga parcial.
Monitorizar las solicitudes XHR con el Real User Monitoring
Tu código funciona en tu máquina, con una buena conexión. Pero tus usuarios tienen redes móviles, extensiones de navegador y dispositivos antiguos. El Real User Monitoring recoge medidas directamente en su navegador para responder a una pregunta sencilla: ¿qué viven realmente los usuarios?
RUM y datos de campo
Google usa los datos RUM de campo para determinar si un sitio cumple los umbrales recomendados de las Core Web Vitals, como explica web.dev. El mismo artículo señala que los datos RUM que recoges tú mismo complementan las herramientas basadas en CrUX, con información más detallada e inmediata.
Qué hace Dynatrace con las solicitudes XHR
En Dynatrace, una interacción del usuario que desencadena XMLHttpRequest o llamadas fetch() crea una acción XHR. La página «User actions» de la documentación de Dynatrace precisa que la acción empieza con el clic del usuario, que Dynatrace detecta también las XHR adicionales lanzadas en el callback de la primera y que espera el final de todas las peticiones antes de cerrar la acción. Una acción web dura como máximo 3 minutos. En una aplicación de página única, donde casi toda la comunicación pasa por XHR tras la primera carga, esto es lo que hace medibles los recorridos.
Dos ajustes que conviene conocer en la configuración de la aplicación web (RUM clásico, SaaS y Managed): la captura de XHR se activa en Capturing > Async web requests and SPAs > Generic support, opción «Capture XmlHttpRequest (XHR)», y las reglas de exclusión por expresión regular sobre la URL descartan las llamadas técnicas (heartbeat, telemetría) que crearían acciones parásitas. Otro punto documentado: la petición debe empezar en los 30 ms siguientes a la interacción; el código basado en promesas puede superar esa ventana, y Dynatrace recomienda entonces la API JavaScript de RUM para crear la acción uno mismo.
Lo que puedas leer después depende de tu configuración, pero las preguntas que hay que hacerse son siempre las mismas:
- ¿Qué acción es la más lenta para los usuarios, y en qué navegador o tipo de dispositivo?
- ¿Qué llamada XHR causa los errores, y con qué código HTTP?
- ¿La lentitud viene de la red o del servidor? Compara la duración en el navegador con la traza del lado del servidor.
- ¿Los errores JavaScript aparecen justo después de una respuesta inesperada?
Para la puesta en marcha de la inyección de JavaScript, la elección de las aplicaciones y la lectura de las Core Web Vitals, sigue nuestra guía sobre la configuración del RUM en Dynatrace. Una vez medidas tus acciones, nuestro módulo sobre el metric selector y las alertas muestra cómo consultar esas métricas y lanzar una alerta cuando una duración supera tu umbral.
Un ejemplo de proceso de diagnóstico
Imagina una página de búsqueda de la que el usuario se queja porque «va lenta». Este es un proceso realista, sin cifras inventadas:
- En el RUM, filtra por la acción XHR que lanza la búsqueda y mira la distribución de las duraciones en lugar de la media.
- Segmenta por navegador, país y tipo de conexión para ver si el problema es general o localizado.
- Si la duración es larga en todas partes, abre la traza distribuida asociada y busca el servicio o la consulta de base de datos responsable.
- Si solo es larga en móvil, examina el tamaño de la respuesta: una API que devuelve demasiados campos sale cara en una red lenta.
- Tras la corrección, compara antes y después en un mismo periodo para confirmar el efecto.
Para objetivos de latencia basados en la distribución y no en la media, consulta también nuestras métricas de histograma de OpenPipeline. Y para reproducir una llamada lenta desde un agente de código, Chrome DevTools MCP da acceso al panel Red desde el asistente.
Buenas prácticas para solicitudes XHR fiables
- Comprobar siempre
statusenload, nunca solo la llegada del evento. - Definir un
timeouty un mensaje claro para el usuario. - Cancelar las peticiones que ya no sirven con
abort(), por ejemplo cuando el usuario escribe una nueva búsqueda. - Evitar el modo síncrono: bloquea la interfaz, y tanto
timeoutcomoresponseTypeestán prohibidos en él dentro de una página. - Preferir HTTPS y no poner nunca un secreto en el código del cliente.
- Medir en producción: una llamada que parece rápida en desarrollo puede ser lenta para tus usuarios.
Nuestro punto de vista
En span.observer comprobamos que la mayoría de las preguntas sobre solicitudes XHR esconden una cuestión de monitorización: la petición sale, pero nadie sabe cuánto tarda en el navegador del usuario ni por qué falla.
Creemos que un desarrollador progresa más rápido cuando conecta tres niveles: el código (esta guía), la medida en el navegador (el RUM) y la traza del lado del servidor. Por eso nuestros tutoriales de Dynatrace parten de problemas concretos de producción, en Managed y en SaaS, y siguen siendo gratuitos, independientes y sin publicidad.
Nuestro enfoque es darte gestos aplicables de inmediato: configurar, leer, consultar, alertar. Aprendes a tu ritmo y puedes compartir estos recursos con tu equipo.
Ir más lejos con nuestros recursos gratuitos
Si quieres pasar de la solicitud XHR aislada a una visión completa de tus aplicaciones, nuestra formación gratuita en observabilidad sigue un camino progresivo, de las señales a los SLO. Está pensada para desarrolladores, SRE y responsables de TI que quieren formar a sus equipos.
Preguntas frecuentes
¿Qué es una solicitud XHR?
Es una petición HTTP enviada por el objeto JavaScript XMLHttpRequest desde el navegador. Obtiene o envía datos a un servidor sin recargar la página. El formato intercambiado es casi siempre JSON, aunque XML figure en el nombre.
¿Qué diferencia hay entre XHR y Fetch?
Ambos envían peticiones HTTP desde el navegador. MDN aconseja Fetch cuando es posible, porque es más sencillo y tiene más funcionalidades. XHR sigue siendo útil para mantener código existente, y el RUM de Dynatrace captura los dos mecanismos por igual.
¿Por qué CORS bloquea mi solicitud XHR?
El servidor de destino no autoriza el origen de tu página. Hay que configurar sus cabeceras de respuesta CORS y añadir withCredentials en el cliente si deben enviarse cookies. Comprueba también que no estás probando desde una página abierta con file:///.
¿Qué mide el Real User Monitoring en una solicitud XHR?
Mide, en el navegador de usuarios reales, la duración y el resultado de las llamadas desencadenadas por sus acciones. En Dynatrace, esas llamadas forman acciones XHR que puedes filtrar por navegador, ubicación o aplicación. Nuestra guía de RUM detalla la configuración.
Fuentes
- Usar XMLHttpRequest, MDN
- XMLHttpRequest.send(), MDN
- Obtener datos del servidor, MDN
- Ajax: Asynchronous JavaScript & XML, Universidad de Caen Normandía
- Cabecera Access-Control-Allow-Credentials, MDN
- Motivo: la petición CORS no usa HTTP, MDN
- Primeros pasos con la medición de las Web Vitals, web.dev
- User actions (acciones XHR), documentación de Dynatrace
- Configure Real User Monitoring to capture XHR actions, documentación de Dynatrace
- XMLHttpRequest, Wikipedia
span.observer es un blog independiente de la comunidad, no afiliado a Dynatrace LLC. Dynatrace es una marca de Dynatrace LLC. Comprueba siempre los valores (puertos, versiones, tamaños) en la documentación oficial correspondiente a tu versión.