Temario Lección 33 de 156 · HTTP por dentro
HTTP por dentro

Analizar una petición HTTP en bruto

Por qué importa Cada página que cargas empieza como un trozo corto de texto que tu navegador envía a un servidor, y ese texto es por donde viaja casi toda la información de rastreo: tus cookies, la página de la que venías, tu idioma. Una vez que sabes leerlo, no tiene nada oculto para ti, y todas las herramientas de esta etapa (el rastreador, el bloqueador, las mediciones) se construyen sobre él.

Piensa en una petición HTTP como una carta con un formato muy estricto. La primera línea dice lo que quieres, luego vienen notas con etiqueta en el sobre, luego una línea en blanco y luego (a veces) el contenido. Una respuesta es la carta de vuelta, con el mismo formato. Tu navegador escribe y lee miles de ellas al día.

HTTP: HyperText Transfer Protocol, el formato acordado que usan los navegadores y los servidores para pedir y enviar páginas, imágenes y datos.

Petición: el mensaje que envía el navegador: un método (qué hacer, como GET para traer o POST para enviar un formulario), un destino (qué ruta del servidor) y una versión.

Cabecera: una nota con etiqueta dentro del mensaje, escrita Name: value en su propia línea, como Accept-Language: en-GB.

Cómo es una petición en bruto

Aquí tienes una petición que el navegador de práctica envió para la página de la tienda de campaña de ShopA. Cada línea termina en dos caracteres invisibles, retorno de carro y salto de línea, que en Python se escriben \r\n. Una línea vacía (es decir, \r\n\r\n seguidos) marca el final de la cabecera.

GET /p/tent HTTP/1.1
Host: shopa.example
User-Agent: PracticeBrowser/1.0 (Linux) Practice Firefox 144
Accept-Language: en-ZA
Sec-Fetch-Site: none
Sec-Fetch-Mode: navigate
Sec-Fetch-Dest: document
  • Línea de petición: GET /p/tent HTTP/1.1, tres partes separadas por espacios simples.
  • Cabeceras: una por línea, el nombre, dos puntos y luego el valor.
  • Línea en blanco: la cabecera ha terminado.
  • Cuerpo: lo que venga después. Un GET normalmente no tiene; un POST de formulario lleva los campos del formulario, como user=sam.

Una respuesta tiene la misma forma, pero su primera línea es una línea de estado: HTTP/1.1 200 OK. La parte del medio es el código de estado (200 significa bien, 302 significa "ve a otro sitio", 404 significa "no encontrado") y el resto es la frase de motivo, una etiqueta para personas que puede tener espacios (Moved Permanently) o faltar del todo.

Código de estado: un número de tres cifras al principio de una respuesta que dice cómo fue. 2xx éxito, 3xx redirección, 4xx un problema con la petición, 5xx un problema en el servidor.

Tres herramientas de Python que necesitas

text.partition(sep) divide en el primer sep y devuelve tres trozos: antes, el separador y después. text.split(sep, 2) divide como mucho dos veces, así que una frase de motivo con espacios queda de una pieza. text.strip() quita los espacios de los dos extremos.

"Referer: https://shopa.example/".partition(":")
# ('Referer', ':', ' https://shopa.example/')
"HTTP/1.1 301 Moved Permanently".split(" ", 2)
# ['HTTP/1.1', '301', 'Moved Permanently']

Un error común

Dividir una línea de cabecera en todos los dos puntos. Referer: https://shopa.example/ tiene dos puntos dentro de su valor, así que line.split(":") parte la dirección por la mitad. Divide siempre solo en los primeros dos puntos. Los navegadores reales lo aprendieron por las malas: los analizadores descuidados son una fuente clásica de fallos de seguridad, cuando dos programas leen el mismo mensaje de forma distinta.

¿La web real sigue siendo así?

Sobre todo en espíritu. Hoy los navegadores suelen hablar HTTP/2 o HTTP/3, que envían los mismos métodos, cabeceras y cuerpos empaquetados en tramas binarias en lugar de líneas de texto. DevTools te los muestra como texto de todos modos, así que los campos que aprendes aquí son exactamente los que verás allí (comprobado en octubre de 2026). El mundo de práctica lo escribe todo como texto HTTP/1.1, que sigue siendo lo que usan muchos servidores y herramientas.

Pruébalo Abre DevTools (F12, o Cmd+Option+I en un Mac), elige la pestaña Network y recarga cualquier página. Haz clic en la primera petición y mira Request Headers. Muchos navegadores ofrecen un interruptor "Raw" que muestra la cabecera exactamente en este formato.

En otros lenguajes

JavaScript:

function parseRequest(raw) {
  const [head, ...rest] = raw.split("\r\n\r\n");
  const lines = head.split("\r\n");
  const [method, target, version] = lines[0].split(" ");
  const headers = lines.slice(1).map(line => {
    const i = line.indexOf(":");            // first colon only
    return [line.slice(0, i).trim(), line.slice(i + 1).trim()];
  });
  return { method, target, version, headers, body: rest.join("\r\n\r\n") };
}

Go:

// the standard library has a real parser: net/http.ReadRequest
req, err := http.ReadRequest(bufio.NewReader(strings.NewReader(raw)))
if err == nil {
    fmt.Println(req.Method, req.URL.Path, req.Header.Get("User-Agent"))
}

Rust:

let (head, body) = raw.split_once("\r\n\r\n").unwrap_or((raw, ""));
let mut lines = head.split("\r\n");
let mut first = lines.next().unwrap().splitn(3, ' ');
let (method, target) = (first.next(), first.next());
let headers: Vec<(&str, &str)> = lines
    .filter_map(|l| l.split_once(':'))
    .map(|(n, v)| (n.trim(), v.trim()))
    .collect();

Resumen

  • Una petición es una línea de petición, unas cabeceras, una línea en blanco y luego un cuerpo opcional; una respuesta empieza en cambio con una línea de estado.
  • Separa la cabecera del cuerpo en el primer \r\n\r\n, y cada cabecera en sus primeros dos puntos.
  • La frase de motivo puede tener espacios o faltar, así que divide la línea de estado como mucho dos veces.
  • HTTP/2 y HTTP/3 llevan los mismos campos en binario, así que esta imagen sigue siendo válida.
Tu turno

Escribe parse_request(raw) para que devuelva un diccionario con "method", "target" (ruta más consulta), "version", "headers" (una lista de pares (name, value) en orden, divididos en los primeros dos puntos, los dos sin espacios en los extremos) y "body" (todo lo que va después de la primera línea en blanco, "" si no hay nada). Después escribe parse_response(raw) para que devuelva "version", "status" (un int), "reason" ("" si falta), "headers" y "body" de la misma forma.

¿Has visto un problema en esta lección? Avísanos · Preguntar sobre esta lección

Este ejercicio se abre pronto

Termina la lección anterior y esta se desbloquea. Todo el curso es gratis, no hace falta cuenta, y puedes leer esta lección ahora mismo.