Skip to content

HTTP Hoja de referencia

Protocolo de transferencia de hipertexto para la comunicación cliente-servidor.

01

Primeros pasos

Petición y respuesta HTTP

HTTP es un protocolo de petición-respuesta. Los clientes envían peticiones (verbo, ruta, headers, body opcional) y los servidores responden con estado, headers y body. HTTP/1.1 es basado en texto; HTTP/2 y HTTP/3 usan entramado binario.

http
# HTTP Request
GET /api/users HTTP/1.1
Host: example.com
User-Agent: Mozilla/5.0
Accept: application/json

# HTTP Response
HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 45

{"id": 1, "name": "Alice", "email": "[email protected]"}

Estructura de la URL

Las URLs identifican recursos. El esquema selecciona el protocolo. El host se resuelve vía DNS. El puerto por defecto se sobreentiende si se omite. El fragmento (#) es solo del cliente y se elimina antes de enviar al servidor. Las query strings se usan comúnmente para filtrar/paginar.

http
# Generic URL format
scheme://userinfo@host:port/path?query#fragment

# Example
https://user:[email protected]:8443/api/v1/users?page=2#section

# Components
# scheme    - https (protocol)
# userinfo  - user:pass (rare, deprecated)
# host      - example.com (domain or IP)
# port      - 8443 (default: 80 for http, 443 for https)
# path      - /api/v1/users (resource location)
# query     - page=2 (key=value pairs, & separated)
# fragment  - section (client-only, never sent to server)

Visión general de las versiones HTTP

HTTP/0.9 era un prototipo mínimo. HTTP/1.0 añadió headers y tipos de contenido, pero abría una conexión nueva por petición. HTTP/1.1 introdujo las conexiones persistentes, el header Host obligatorio (habilitando hosts virtuales) y el pipelining. HTTP/2 añadió la multiplexación binaria. HTTP/3 corre sobre QUIC, eliminando el bloqueo de cabeza de línea en la capa de transporte.

http
# HTTP/0.9 (1991) - single GET, no headers
GET /page.html

# HTTP/1.0 (1996) - headers, status codes, multiple types
GET /page.html HTTP/1.0

# HTTP/1.1 (1997) - persistent connections, Host header, pipelining
GET /page.html HTTP/1.1
Host: example.com

# HTTP/2 (2015) - binary, multiplexing, header compression
# (negotiated via ALPN or h2c upgrade)

# HTTP/3 (2022) - over QUIC (UDP-based)
# (negotiated via Alt-Svc header)

Ciclo de vida de la conexión

HTTP/1.1 mantiene las conexiones TCP abiertas por defecto (keep-alive), evitando el coste de handshakes repetidos. Varias peticiones pueden enviarse por una misma conexión. El header Connection: close señala la última petición. HTTP/2 multiplexa muchos streams sobre una sola conexión. El timeout y el máximo de Keep-Alive son configurables en el servidor.

http
# HTTP/1.1 persistent connection (keep-alive)
GET /page1 HTTP/1.1
Host: example.com
Connection: keep-alive

# (server responds, connection stays open)
HTTP/1.1 200 OK
Content-Length: 128
Connection: keep-alive

# Client reuses same TCP connection for next request
GET /page2 HTTP/1.1
Host: example.com

# Closing the connection
GET /final HTTP/1.1
Host: example.com
Connection: close

Formato del mensaje

Los mensajes HTTP empiezan con una línea inicial (request-line o status-line), seguida de headers, una línea en blanco y un body opcional. Las líneas usan finales CRLF. Los nombres de header no distinguen mayúsculas. La línea en blanco es obligatoria y señala el inicio del body. Los bodies pueden ser de longitud variable (chunked) o fija (Content-Length).

http
# Request format
<METHOD> <PATH> <VERSION>

<Header-Name>: <value>

...



<optional body>

# Response format
<VERSION> <STATUS> <REASON>

<Header-Name>: <value>

...



<optional body>

# Lines end with CRLF (
). Headers are case-insensitive.
# A blank line (
) separates headers from body.

Depuración HTTP cruda con Telnet

Puedes hablar HTTP crudo sobre TCP usando nc o telnet (puerto 80) u openssl s_client (HTTPS). Esto es inestimable para depurar. Debes incluir el header Host en HTTP/1.1+. Dos líneas en blanco terminan la petición. curl -v muestra la conversación en formato de cable, incluidos los headers.

http
# Manual HTTP request via netcat/nc
nc example.com 80
GET / HTTP/1.1
Host: example.com

# (press Enter twice to send blank line)

# Using openssl for HTTPS
openssl s_client -connect example.com:443
GET / HTTP/1.1
Host: example.com

# curl with --http1.1 to force version
curl -v --http1.1 https://example.com
curl -v --http2 https://example.com
curl -v --http3 https://example.com
02

Verbos HTTP

GET — obtener recurso

GET obtiene una representación de un recurso. Debe ser seguro (sin efectos secundarios) e idempotente (repetible). Las peticiones GET son cacheables y se pueden guardar en marcadores. Aunque la especificación permite un body, está desaconsejado — proxies y CDNs pueden recortarlo. Usa parámetros de query para filtrar en su lugar.

http
# Basic GET
GET /api/users/42 HTTP/1.1
Host: api.example.com
Accept: application/json

# GET with query parameters
GET /api/users?role=admin&active=true HTTP/1.1
Host: api.example.com

# GET should be safe & idempotent
# - safe: no server state change
# - idempotent: repeating yields same result
# - cacheable: yes
# - body allowed but discouraged (some clients/servers reject)

POST — crear recurso

POST envía datos para ser procesados. Se usa para crear recursos nuevos donde el servidor asigna el URI (por ejemplo, /api/users → /api/users/43). POST no es seguro ni idempotente — enviar dos veces puede crear dos recursos. La respuesta 201 Created debería incluir un header Location apuntando al recurso nuevo.

http
# POST creating a new resource
POST /api/users HTTP/1.1
Host: api.example.com
Content-Type: application/json
Content-Length: 52

{"name": "Bob", "email": "[email protected]", "age": 30}

# Response typically 201 Created with Location header
HTTP/1.1 201 Created
Location: /api/users/43
Content-Type: application/json

{"id": 43, "name": "Bob"}

# POST is neither safe nor idempotent.
# Repeating may create duplicate resources.

PUT — reemplazar recurso

PUT reemplaza por completo el recurso en el URI objetivo con el body de la petición. Es idempotente — repetir el mismo PUT produce el mismo estado final. PUT apunta a un URI específico (por ejemplo, /users/43), a diferencia de POST que apunta a una colección. Si un campo se omite en PUT, normalmente se elimina (reemplazo completo).

http
# PUT replaces the entire resource at the given URI
PUT /api/users/43 HTTP/1.1
Host: api.example.com
Content-Type: application/json
Content-Length: 60

{"id": 43, "name": "Robert", "email": "[email protected]", "age": 31}

# Idempotent: sending the same PUT again yields the same state.
# If the resource doesn't exist, PUT may create it (server-dependent).

# Response
HTTP/1.1 200 OK
# or 204 No Content if no body returned

PATCH — actualización parcial

PATCH aplica actualizaciones parciales a un recurso, a diferencia de PUT que lo reemplaza entero. La forma más simple es JSON Merge Patch (RFC 7396): envía solo los campos a cambiar. JSON Patch (RFC 6902) usa un array de operaciones (add, remove, replace, move, copy, test). PATCH NO es idempotente por defecto, aunque merge-patch sí lo es.

http
# PATCH applies partial modifications
PATCH /api/users/43 HTTP/1.1
Host: api.example.com
Content-Type: application/merge-patch+json
Content-Length: 22

{"email": "[email protected]"}

# Only the email field is updated; other fields remain.

# JSON Patch (RFC 6902) - structured operations
PATCH /api/users/43 HTTP/1.1
Content-Type: application/json-patch+json

[
  {"op": "replace", "path": "/email", "value": "[email protected]"},
  {"op": "remove", "path": "/age"}
]

DELETE — eliminar recurso

DELETE elimina el recurso objetivo. Es idempotente — eliminar el mismo recurso dos veces debería dejar al servidor en el mismo estado. Los códigos de éxito comunes son 204 (sin body), 200 (con body confirmando) o 202 (eliminación asíncrona). La mayoría de APIs exigen autenticación. Si devolver 404 ante un recurso ausente es debatido — 204 es más seguro para la idempotencia.

http
# Delete a resource
DELETE /api/users/43 HTTP/1.1
Host: api.example.com
Authorization: Bearer <token>

# Successful responses:
HTTP/1.1 204 No Content        # most common
HTTP/1.1 200 OK                 # if body returned
HTTP/1.1 202 Accepted           # async deletion queued

# Idempotent: deleting an already-deleted resource
# should still return 204 (or 404 — debatable).

HEAD y OPTIONS

HEAD es idéntico a GET pero el servidor devuelve solo headers (sin body) — útil para comprobar Content-Length, Content-Type o Last-Modified sin descargar el body. OPTIONS pregunta qué verbos están permitidos (header Allow) y lo usan los navegadores para el preflight de CORS. Ambos son seguros e idempotentes.

http
# HEAD: like GET but returns headers only (no body)
HEAD /api/users/42 HTTP/1.1
Host: api.example.com

HTTP/1.1 200 OK
Content-Type: application/json
Content-Length: 128
# (no body)

# OPTIONS: describe communication options
OPTIONS /api/users HTTP/1.1
Host: api.example.com

HTTP/1.1 200 OK
Allow: GET, POST, HEAD, OPTIONS
Access-Control-Allow-Methods: GET, POST
03

Códigos de estado

1xx informativos

Los códigos 1xx son informativos, indicando que la petición fue recibida y el procesamiento continúa. 100 Continue permite a un cliente comprobar si enviar un body grande (emparejado con el header Expect: 100-continue). 101 Switching Protocols habilita WebSocket. 103 Early Hints permite al servidor insinuar al navegador precargar recursos antes de que la respuesta final esté lista.

http
# 100 Continue - server received headers, client may send body
POST /upload HTTP/1.1
Host: example.com
Expect: 100-continue
Content-Length: 1048576

# Server replies:
HTTP/1.1 100 Continue
# (client now sends the request body)

# 101 Switching Protocols - used for WebSocket upgrade
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade

# 103 Early Hints - preload resources before final response
HTTP/1.1 103 Early Hints
Link: </style.css>; rel=preload; as=style

2xx de éxito

Los códigos 2xx indican éxito. 200 OK es el éxito genérico. 201 Created indica que se creó un recurso nuevo (con un header Location). 202 Accepted significa que la petición está en cola para procesamiento asíncrono (por ejemplo, un trabajo largo). 204 No Content señala éxito sin body — común para DELETE/PUT. 206 Partial Content devuelve parte de un recurso (petición Range).

http
# 200 OK - standard success
HTTP/1.1 200 OK

# 201 Created - new resource created (POST/PUT)
HTTP/1.1 201 Created
Location: /api/users/43

# 202 Accepted - request queued for async processing
HTTP/1.1 202 Accepted

# 204 No Content - success, no body (DELETE, PUT)
HTTP/1.1 204 No Content

# 206 Partial Content - Range request result
HTTP/1.1 206 Partial Content
Content-Range: bytes 0-1023/2048

3xx de redirección

Los códigos 3xx indican redirección. 301/308 son permanentes (cacheables, el valor SEO de los enlaces pasa); 302/307 son temporales. La diferencia crucial: 301 y 302 históricamente permitían la conversión POST→GET (causando pérdida de datos), mientras que 307 y 308 conservan estrictamente el verbo. 304 Not Modified se devuelve en peticiones condicionales cuando la caché es válida — sin body.

http
# 301 Moved Permanently - cacheable, change bookmarks
HTTP/1.1 301 Moved Permanently
Location: https://newsite.com/page

# 302 Found - temporary redirect (don't update bookmarks)
HTTP/1.1 302 Found
Location: /login

# 304 Not Modified - cache is still valid (conditional GET)
HTTP/1.1 304 Not Modified
ETag: "abc123"

# 307 Temporary Redirect - preserves method (POST stays POST)
HTTP/1.1 307 Temporary Redirect
Location: /new-endpoint

# 308 Permanent Redirect - permanent, preserves method
HTTP/1.1 308 Permanent Redirect
Location: https://newsite.com/api

Errores del cliente 4xx

Los códigos 4xx significan que el cliente cometió un error. 400 Bad Request es una entrada malformada. 401 significa autenticación ausente/inválida (debe incluir WWW-Authenticate). 403 significa autenticado pero sin permiso. 404 es un recurso ausente. 429 indica rate limiting (incluye Retry-After). Otros comunes: 405 Method Not Allowed, 409 Conflict, 422 Unprocessable Entity.

http
# 400 Bad Request - malformed syntax
HTTP/1.1 400 Bad Request
Content-Type: application/json

{"error": "Invalid JSON in request body"}

# 401 Unauthorized - authentication required
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer realm="api"

# 403 Forbidden - authenticated but not allowed
HTTP/1.1 403 Forbidden

# 404 Not Found - resource doesn't exist
HTTP/1.1 404 Not Found

# 429 Too Many Requests - rate limit hit
HTTP/1.1 429 Too Many Requests
Retry-After: 60

Errores del servidor 5xx

Los códigos 5xx significan que el servidor falló. 500 es el cajón de sastre para errores no manejados (revisa los logs del servidor). 501 significa que el servidor no implementa el verbo. 502 significa que un proxy/gateway recibió una respuesta errónea del upstream. 503 significa sobrecarga temporal (usa Retry-After). 504 significa timeout del upstream. Los clientes pueden reintentar 502/503/504 con backoff.

http
# 500 Internal Server Error - generic server failure
HTTP/1.1 500 Internal Server Error

# 501 Not Implemented - server doesn't support the method
HTTP/1.1 501 Not Implemented

# 502 Bad Gateway - upstream server returned invalid response
HTTP/1.1 502 Bad Gateway

# 503 Service Unavailable - temporary overload or maintenance
HTTP/1.1 503 Service Unavailable
Retry-After: 300

# 504 Gateway Timeout - upstream didn't respond in time
HTTP/1.1 504 Gateway Timeout

Patrones de códigos de estado

Un mapeo consistente de códigos de estado hace las APIs predecibles. Usa 2xx para el éxito con precisión semántica (201 para crear, 204 sin body). 4xx para errores del cliente con el código más específico (409 para conflictos, 422 para validación). 401 vs 403 es la confusión más común: 401 = '¿quién eres?', 403 = 'sé quién eres, pero no puedes hacer esto'.

http
# REST API common mapping
GET     /users      -> 200
POST    /users      -> 201 (Created)
GET     /users/42   -> 200 | 404
PUT     /users/42   -> 200 | 201 (if created) | 404
PATCH   /users/42   -> 200 | 404
DELETE  /users/42   -> 204 | 404

# Validation errors
400 -> malformed JSON, missing required field
409 -> duplicate resource / version conflict
422 -> semantic validation failure (some APIs)

# Auth flow
401 -> no/invalid token (login required)
403 -> logged in but lacking permission
404 -> hide existence from unauthorized users

# Use 418 I'm a teapot for fun (RFC 2324 joke).
04

Headers de petición

Headers de petición comunes

Los headers de petición comunes transmiten la identidad del cliente (User-Agent), el formato de respuesta deseado (familia Accept), el control de conexión (Connection), la autenticación (Authorization), el estado (Cookie) y el origen (Referer/Origin). Host es obligatorio en HTTP/1.1+ para el alojamiento virtual. Content-Type y Content-Length describen cualquier body de petición.

http
GET /api/data HTTP/1.1
Host: api.example.com          # target host (mandatory in HTTP/1.1)
User-Agent: Mozilla/5.0        # client identity
Accept: application/json        # desired response format
Accept-Language: en-US,en;q=0.9
Accept-Encoding: gzip, deflate, br
Connection: keep-alive
Authorization: Bearer <token>
Cookie: session=abc123; theme=dark
Referer: https://example.com/
Origin: https://example.com
Content-Type: application/json
Content-Length: 42

Headers Accept (negociación de contenido)

La familia Accept guía la negociación de contenido. Los valores de calidad (q, 0-1) expresan preferencia — mayor es más preferido. */* es el comodín general. El servidor elige la mejor coincidencia de lo que soporta; si ninguna coincide, devuelve 406 Not Acceptable (aunque la mayoría de servidores recurren a un valor por defecto en lugar del 406). Brotli (br) y zstd ofrecen mejor compresión que gzip.

http
# Accept: desired media types with quality (q) values
Accept: text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8

# Accept-Language: preferred languages
Accept-Language: en-US,en;q=0.9, zh-CN;q=0.8, fr;q=0.7

# Accept-Encoding: accepted compression algorithms
Accept-Encoding: gzip, deflate, br, zstd;q=0.9

# q=1.0 is default. Higher q = more preferred.
# */* matches any type.
# Server responds with 406 Not Acceptable if it can't satisfy.

Headers de autorización y autenticación

Authorization lleva las credenciales. La autenticación Basic envía usuario:contraseña codificado en base64 en cada petición (usa siempre HTTPS). Los tokens Bearer son cadenas opacas (a menudo JWTs) usados en OAuth 2.0. Los esquemas de autenticación personalizados (X-API-Key) son comunes en API gateways. El base64 de Basic es codificación, no cifrado — no ofrece seguridad sin TLS.

http
# Basic Authentication (base64 of user:pass)
Authorization: Basic dXNlcjpwYXNz
# dXNlcjpwYXNz = base64("user:pass")

# Bearer Token (OAuth 2.0 / JWT)
Authorization: Bearer eyJhbGciOiJIUzI1NiIs...

# API Key in header (custom)
X-API-Key: abc123def456

# Proxy authentication
Proxy-Authorization: Basic dXNlcjpwYXNz

# WARNING: Basic auth sends credentials on every request.
# Always use HTTPS to prevent eavesdropping.

User-Agent y Referer

User-Agent identifica al cliente, pero la mayoría de navegadores simulan Mozilla/5.0 por compatibilidad hacia atrás (sniffing histórico). Referer (mal escrito en la especificación, nunca corregido) indica al servidor qué página enlazó a la petición — usado para analítica y protección contra hotlink. Origin es el esquema+host+puerto, enviado por los navegadores en peticiones CORS y POST.

http
# User-Agent identifies the client software
User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36

# Common browsers prepend "Mozilla/5.0" for historical compatibility
# (servers used to serve different content to different browsers)

# Referer: page that linked to this request
Referer: https://example.com/search?q=hello

# Origin: scheme + host + port (used by CORS)
Origin: https://example.com

# Note: "Referer" is the official spelling (misspelled in the original spec)

Headers de petición condicional

Los headers condicionales habilitan el almacenamiento en caché eficiente y el control de concurrencia. If-None-Match (con ETag) e If-Modified-Since (con Last-Modified) hacen condicional el GET — el servidor devuelve 304 si la caché es válida. If-Match e If-Unmodified-Since protegen PUT/PATCH contra actualizaciones perdidas (concurrencia optimista). If-Range habilita peticiones de rango atómicas.

http
# Conditional GET - only fetch if changed
If-Modified-Since: Wed, 21 Oct 2023 07:28:00 GMT
If-None-Match: "abc123"

# If-Match / If-Unmodified-Since - for safe PUT/PATCH
If-Match: "abc123"
If-Unmodified-Since: Wed, 21 Oct 2023 07:28:00 GMT

# If-Range - for range requests (all-or-nothing)
If-Range: "abc123"
Range: bytes=0-1023

# Typical flow:
# 1. Server sends ETag/Last-Modified with response
# 2. Client sends If-None-Match/If-Modified-Since on next request
# 3. Server replies 304 if unchanged, 200 if changed

Headers personalizados y X-

Los headers personalizados usaban históricamente el prefijo X-, pero la RFC 6648 desaconsejó esa convención en 2012. Los headers nuevos deberían prescindir del X- (por ejemplo, Request-ID en lugar de X-Request-ID). X-Forwarded-For y X-Forwarded-Proto llevan la información del cliente a través de proxies (ojo: falsificables). La alternativa estandarizada es Forwarded (RFC 7239). Traceparent/Tracestate habilitan el trazado distribuido (W3C).

http
# X- prefixed headers (deprecated convention, but widely used)
X-Request-ID: 550e8400-e29b-41d4-a716-446655440000
X-Correlation-ID: abc-123
X-Forwarded-For: 203.0.113.1, 70.41.3.18
X-Forwarded-Proto: https
X-Real-IP: 203.0.113.1
X-RateLimit-Remaining: 42

# Modern recommendation: avoid X- prefix (RFC 6648)
# Use a namespace instead:
Request-ID: 550e8400-e29b-41d4-a716-446655440000
Traceparent: 00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01

# Forwarded (RFC 7239) - standardized proxy info
Forwarded: for=203.0.113.1; proto=https; host=example.com
05

Headers de respuesta

Headers de respuesta comunes

Los headers de respuesta comunes describen el servidor (Server), el body de la respuesta (Content-Type, Content-Length), el control de conexión (Connection), el almacenamiento en caché (Cache-Control, ETag, Last-Modified), la negociación de contenido (Vary), el estado (Set-Cookie) y CORS (Access-Control-*). Date es obligatorio y usa el formato RFC 1123 en GMT.

http
HTTP/1.1 200 OK
Server: nginx/1.25.0
Date: Wed, 21 Oct 2023 07:28:00 GMT
Content-Type: application/json; charset=utf-8
Content-Length: 128
Connection: keep-alive
Cache-Control: public, max-age=3600
ETag: "abc123"
Last-Modified: Mon, 20 Oct 2023 10:00:00 GMT
Vary: Accept-Encoding
Set-Cookie: session=xyz; HttpOnly; Secure
Access-Control-Allow-Origin: https://example.com

Headers de contenido

Los headers Content-* describen el body. Content-Type es el tipo MIME y es crítico. Content-Length da el recuento exacto de bytes (obligatorio salvo que uses codificación chunked). Content-Encoding indica la compresión (gzip, br). Content-Disposition fuerza la descarga con un nombre de archivo. Content-Range acompaña las respuestas 206 Partial Content.

http
# Body metadata
Content-Type: application/json; charset=utf-8
Content-Length: 128                # exact byte count
Content-Encoding: gzip             # applied encoding
Content-Language: en-US
Content-Location: /api/users/42.json
Content-Disposition: attachment; filename="report.pdf"
Content-Range: bytes 0-1023/2048   # for partial content

# For chunked transfer (no Content-Length known upfront)
Transfer-Encoding: chunked

# MIME type format: type/subtype; parameter=value
# e.g., text/html; charset=UTF-8

Headers de seguridad

Los headers de seguridad endurecen los navegadores ante ataques comunes. HSTS fuerza HTTPS y previene el SSL stripping. X-Content-Type-Options: nosniff previene el MIME sniffing. X-Frame-Options (o CSP frame-ancestors) bloquea el clickjacking. CSP es el más potente — controla qué recursos pueden cargarse y ejecutarse. Referrer-Policy limita la información de referente filtrada. Fija estos en cada respuesta.

http
# Force HTTPS for 6 months (incl. subdomains)
Strict-Transport-Security: max-age=15768000; includeSubDomains; preload

# Prevent MIME-type sniffing
X-Content-Type-Options: nosniff

# Prevent clickjacking
X-Frame-Options: DENY
# Or modern CSP frame-ancestors:
Content-Security-Policy: frame-ancestors 'none'

# Referrer policy
Referrer-Policy: strict-origin-when-cross-origin

# Permissions policy (feature lockdown)
Permissions-Policy: geolocation=(), camera=()

# Full Content-Security-Policy
Content-Security-Policy: default-src 'self'; script-src 'self' https://cdn.example.com

Headers de respuesta CORS

Los headers CORS (Cross-Origin Resource Sharing) permiten a un servidor optar por aceptar peticiones entre orígenes. Access-Control-Allow-Origin es obligatorio para cualquier lectura entre orígenes; o un origen específico o *. Si hay credenciales de por medio, Allow-Credentials: true Y un origen específico (sin comodín). Las respuestas de preflight (OPTIONS) incluyen Allow-Methods/Headers. Expose-Headers permite a JS leer headers de respuesta no predeterminados.

http
# Allow a specific origin
Access-Control-Allow-Origin: https://example.com
# Or wildcard (but credentials won't work with *)
Access-Control-Allow-Origin: *

# Allow credentials (cookies, Authorization)
Access-Control-Allow-Credentials: true

# Allowed methods (preflight response)
Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS

# Allowed headers (preflight response)
Access-Control-Allow-Headers: Content-Type, Authorization

# How long browser can cache preflight (seconds)
Access-Control-Max-Age: 86400

# Headers the JS can read from the response
Access-Control-Expose-Headers: X-Request-ID, X-Total-Count

Headers de caché

Cache-Control es el header de caché moderno (HTTP/1.1) con directivas: public/private (quién puede cachear), max-age (frescura en segundos), no-cache (debe revalidar), no-store (nunca cachear), immutable (la URL nunca cambia). ETag y Last-Modified son validadores usados con peticiones condicionales. Expires (HTTP/1.0) es un respaldo. Age indica cuánto tiempo lleva una respuesta cacheada.

http
# Cache-Control directives (HTTP/1.1 - preferred)
Cache-Control: public, max-age=3600
Cache-Control: private, max-age=600
Cache-Control: no-cache              # revalidate before use
Cache-Control: no-store              # never cache
Cache-Control: must-revalidate
Cache-Control: immutable

# Validators
ETag: "abc123"                       # opaque version tag
Last-Modified: Wed, 21 Oct 2023 07:28:00 GMT

# HTTP/1.0 fallbacks (deprecated)
Expires: Wed, 21 Oct 2023 08:28:00 GMT
Pragma: no-cache

# Age: time a response has been in a cache (seconds)
Age: 120
06

Cookies y Set-Cookie

Fijar cookies (Set-Cookie)

Set-Cookie instruye al navegador a guardar una cookie. Cada atributo controla el ámbito y la vida útil: Domain/Path restringen dónde se envía; Max-Age (segundos) o Expires fijan la vida útil; Secure la limita a HTTPS; HttpOnly bloquea el acceso desde JS; SameSite controla el envío entre sitios. Para eliminar una cookie, fija Max-Age=0 con el mismo Path/Domain.

http
# Basic cookie
HTTP/1.1 200 OK
Set-Cookie: session=abc123

# With attributes
Set-Cookie: session=abc123; Path=/; Domain=example.com; Max-Age=3600; HttpOnly; Secure; SameSite=Lax

# Multiple cookies = multiple Set-Cookie headers
Set-Cookie: session=abc123; HttpOnly; Secure
Set-Cookie: theme=dark; Max-Age=86400
Set-Cookie: lang=en-US; Path=/

# Deleting a cookie: set Max-Age=0 or expired Expires
Set-Cookie: session=; Max-Age=0; Path=/

Atributos de cookie

Los atributos de cookie controlan la seguridad y el ámbito. Secure + HttpOnly + SameSite es la línea base moderna. SameSite=Lax es el valor por defecto del navegador — permite cookies en navegaciones de nivel superior pero las bloquea en contextos de terceros (neutraliza la mayoría del CSRF). El prefijo __Host- fuerza Path=/, sin Domain, y Secure — previniendo la inyección de cookies de subdominio. __Secure- exige Secure.

http
# Security attributes
Secure           # only sent over HTTPS
HttpOnly         # not accessible via document.cookie (XSS protection)
SameSite=Strict  # never sent on cross-site requests
SameSite=Lax     # sent on top-level navigation (default in modern browsers)
SameSite=None    # sent cross-site (requires Secure)

# Scope attributes
Domain=example.com    # visible to subdomains too
Path=/                # visible to all paths
Path=/api             # only /api and below

# Lifetime attributes
Max-Age=3600          # seconds (preferred)
Expires=Wed, 21 Oct 2025 07:28:00 GMT  # absolute date

# __Host- and __Secure- prefixes (extra protection)
Set-Cookie: __Host-session=abc; Path=/; Secure; HttpOnly; SameSite=Lax

Enviar cookies (Cookie)

El header de petición Cookie envía todas las cookies coincidentes como pares nombre=valor (sin atributos). Las cookies se envían automáticamente por el navegador en cada petición coincidente. Para fetch entre orígenes con cookies, el cliente debe fijar credentials: 'include' Y el servidor debe devolver un origen específico (no *) con Access-Control-Allow-Credentials: true.

http
# Browser sends stored cookies back to the server
GET /api/profile HTTP/1.1
Host: example.com
Cookie: session=abc123; theme=dark; lang=en-US

# Format: name=value pairs separated by "; "
# No attributes are sent back - only name=value

# Server reads cookies (Express.js example)
# const sessionId = req.headers.cookie
#   .split(';').find(c => c.trim().startsWith('session='))
#   .split('=')[1];

# Cross-site requests (with credentials)
fetch('https://api.example.com/data', {
  credentials: 'include'  # sends cookies cross-origin
});
# Server must respond with:
# Access-Control-Allow-Origin: https://app.example.com (specific, no *)
# Access-Control-Allow-Credentials: true

Cookie vs token

Las cookies se almacenan y envían automáticamente por el navegador; los tokens (JWT) se guardan en JS y se envían manualmente. Las cookies son vulnerables al CSRF (mitigado con SameSite). Los tokens son vulnerables al XSS (mitigado con vidas cortas y almacenamiento seguro). Las cookies encajan en apps web del mismo origen; los tokens en APIs y SPAs. Lo mejor de ambos: guarda el refresh token en una cookie HttpOnly y el access token en memoria.

http
# Cookie-based auth (stateful server-side session)
POST /login HTTP/1.1
Host: example.com
Content-Type: application/json

{"user": "alice", "password": "secret"}

# Server response
HTTP/1.1 200 OK
Set-Cookie: session=abc123; HttpOnly; Secure; SameSite=Lax

# Subsequent requests carry cookie automatically
GET /api/profile HTTP/1.1
Cookie: session=abc123

# Token-based auth (stateless, e.g., JWT)
# Server response
HTTP/1.1 200 OK
Content-Type: application/json

{"token": "eyJhbGc..."}

# Subsequent requests carry token in header (manual)
GET /api/profile HTTP/1.1
Authorization: Bearer eyJhbGc...

Cookies de terceros y SameSite

Las cookies de terceros las fija un dominio distinto al de la página que el usuario visita — usadas durante mucho tiempo para rastrear y anunciar. SameSite=None+Secure es obligatorio para ellas. Los navegadores modernos (Chrome, Firefox, Safari) están eliminando las cookies de terceros. Alternativas: CHIPS (cookies Partitioned, acotadas por sitio de nivel superior), la Storage Access API y el rastreo del lado del servidor. ITP (Safari) las bloquea directamente.

http
# First-party cookie: domain matches the page
Set-Cookie: session=abc; Domain=example.com
# Visiting example.com -> sent to example.com (first-party)

# Third-party cookie: embedded in another site's page
# e.g., analytics.com cookie loaded via <img> on shop.com
Set-Cookie: tracker=xyz; Domain=analytics.com; SameSite=None; Secure

# SameSite behavior:
# Strict  -> NOT sent on shop.com -> analytics.com requests
# Lax     -> NOT sent on embedded cross-site requests
#            (sent on top-level navigation)
# None    -> sent cross-site (requires Secure)

# Browsers are phasing out third-party cookies (2024+).
# Alternatives: Partitioned cookies (CHIPS)
Set-Cookie: tracker=xyz; Partitioned; Secure; SameSite=None
07

Autenticación

Autenticación Basic

La autenticación Basic envía credenciales codificadas en base64 en cada petición. Es simple y universalmente soportada, pero no ofrece ninguna seguridad sin HTTPS — base64 es trivialmente decodificable. El header WWW-Authenticate desafía al cliente (los navegadores muestran un diálogo de login nativo). Basic es rara en apps web modernas pero común para tokens de API y herramientas internas.

http
# Basic auth: base64(user:pass) sent on every request
GET /api/data HTTP/1.1
Host: example.com
Authorization: Basic dXNlcjpwYXNz

# dXNlcjpwYXNz = base64("user:pass")
# In curl: curl -u user:pass https://example.com/api/data

# Server challenge (401 with WWW-Authenticate)
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Basic realm="Restricted Area", charset="UTF-8"

# WARNING: base64 is encoding, NOT encryption.
# Always pair Basic auth with HTTPS.

Token Bearer (OAuth 2.0)

Los tokens Bearer son cadenas opacas presentadas como prueba de autorización. El servidor solo necesita validarlos — son sin estado si son autosuficientes (JWT) o se buscan en un almacén. OAuth 2.0 define flujos para obtener tokens (authorization code, client credentials, refresh token). Envía siempre los tokens Bearer por HTTPS. Los tokens tienen vidas finitas; usa refresh tokens para obtener nuevos.

http
# Bearer token: opaque string proving authorization
GET /api/profile HTTP/1.1
Host: api.example.com
Authorization: Bearer SlAV32hkKG...

# Token obtained from OAuth 2.0 flow:
POST /oauth/token HTTP/1.1
Content-Type: application/x-www-form-urlencoded

grant_type=password&username=alice&password=secret&client_id=...

# Response
HTTP/1.1 200 OK
Content-Type: application/json

{
  "access_token": "SlAV32hkKG...",
  "token_type": "Bearer",
  "expires_in": 3600,
  "refresh_token": "GmR..."
}

Estructura del JWT

Un JWT tiene tres partes codificadas en base64url separadas por puntos: header (algoritmo), payload (claims) y firma. La firma prueba que el token no fue manipulado. Claims comunes: sub (sujeto), iat (emitido en), exp (expiración), iss (emisor), aud (audiencia). El payload NO está cifrado — nunca pongas secretos ahí. Algoritmos de firma: HS256 (HMAC), RS256 (RSA), ES256 (ECDSA).

http
# JWT = header.payload.signature (base64url-encoded)
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkFsaWNlIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c

# Decoded:
# Header
{"alg": "HS256", "typ": "JWT"}

# Payload (claims)
{
  "sub": "1234567890",        # subject (user id)
  "name": "Alice",
  "iat": 1516239022,          # issued at
  "exp": 1516242622,          # expiration
  "iss": "example.com",       # issuer
  "aud": "api.example.com"    # audience
}

# Signature (HMAC-SHA256 of header.payload with secret)
HMAC-SHA256(secret, "eyJhbGc...")

Validación del JWT

Validación de JWT: verifica la firma (detecta manipulaciones) y luego comprueba los claims (exp, iss, aud). exp es el más importante — rechaza los tokens expirados con 401. Los JWT son sin estado: una vez emitidos, no pueden revocarse hasta que expiren. Para la revocación, usa access tokens de vida corta (5-15 min) + refresh tokens guardados en el servidor, o mantiene una lista negra (rompe la falta de estado).

http
# Server-side JWT validation steps:
# 1. Parse three parts (header.payload.signature)
# 2. Verify signature using secret (HS256) or public key (RS256)
# 3. Check claims:
#    - exp (must be in future)
#    - iat (must be in past, optional)
#    - iss (must match expected issuer)
#    - aud (must match expected audience)
# 4. Check revocation list (if using short-lived + refresh)

# Common errors:
# 401 - invalid signature, expired, wrong issuer
# 401 - "Bearer" prefix missing
# 403 - valid token but lacking permission (scope)

# Token expired response
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer error="invalid_token", error_description="The token has expired"

Flujo Authorization Code de OAuth 2.0

El flujo Authorization Code es el estándar para apps web del lado del servidor. Paso 1: redirige al usuario al servidor de autenticación. Paso 2: devuelve un código de vida corta al URI de redirección. Paso 3: intercambia el código (más el client_secret) por tokens servidor a servidor. PKCE (Proof Key for Code Exchange) reemplaza el secreto por un par code challenge/verifier — esencial para SPAs y apps móviles donde el secreto no puede guardarse con seguridad.

http
# Step 1: Redirect user to authorization endpoint
GET /authorize?response_type=code&client_id=CLIENT_ID&redirect_uri=https://app.com/callback&scope=read&state=random123 HTTP/1.1
Host: auth.example.com

# Step 2: User logs in & grants consent, redirected back with code
HTTP/1.1 302 Found
Location: https://app.com/callback?code=AUTH_CODE&state=random123

# Step 3: Server exchanges code for token (server-to-server)
POST /oauth/token HTTP/1.1
Host: auth.example.com
Content-Type: application/x-www-form-urlencoded
Authorization: Basic base64(client_id:client_secret)

grant_type=authorization_code&code=AUTH_CODE&redirect_uri=https://app.com/callback

# Step 4: Token response
{"access_token": "...", "refresh_token": "...", "expires_in": 3600}

# Use PKCE for SPAs/mobile (no client_secret)
# code_challenge = base64url(SHA256(code_verifier))

API keys

Las API keys son secretos opacos simples que identifican a un cliente. Se envían en headers (preferido) o query strings (evítalo — quedan en las URLs y logs de proxies). Las API keys tienen estado (el servidor las busca) y son revocables. A diferencia de los JWTs, no llevan claims — el servidor guarda los permisos. Buena práctica: hashea las claves en reposo, acota su ámbito, rotálalas y ofrece una UI de rotación de autoservicio.

http
# API key in header (most common)
GET /api/data HTTP/1.1
X-API-Key: abc123def456

# API key as Bearer token
Authorization: Bearer abc123def456

# API key in query string (less secure - logged in URLs)
GET /api/data?api_key=abc123def456 HTTP/1.1

# API key in custom header with prefix
Authorization: ApiKey abc123def456

# Best practices:
# - Rotate keys periodically
# - Scope keys to specific permissions
# - Store keys hashed at rest (like passwords)
# - Never commit keys to source control
08

Negociación de contenido

Header Accept

El header Accept lista los tipos de medios que el cliente puede manejar, con valores de calidad (q) que expresan preferencia. Los comodines (text/*, */*) amplían la coincidencia. El servidor elige la mejor coincidencia y responde con el Content-Type elegido. Si ningún tipo de medio coincide, el servidor idealmente devuelve 406, pero en la práctica muchas APIs recurren a un formato por defecto.

http
# Single type
Accept: application/json

# Multiple types with preferences (q values, 0-1)
Accept: text/html, application/xhtml+xml, application/xml;q=0.9, */*;q=0.8

# Wildcard media types
Accept: text/*           # any text/* subtype
Accept: */*              # anything
Accept: image/png, image/*;q=0.8

# Parameters
Accept: text/html;charset=utf-8

# Server picks best match and returns it in Content-Type.
# If no match, server returns 406 Not Acceptable (or a default).

Accept-Language

Accept-Language indica al servidor los idiomas preferidos del usuario, con valores de calidad para el orden. La RFC 5646 define las etiquetas de idioma (idioma[-script][-región]). El servidor responde con Content-Language. Los navegadores lo fijan según la configuración de SO/locale del usuario. Para i18n, recurre con elegancia: si el idioma solicitado no está disponible, devuelve el predeterminado. Las CDNs a veces varían las cachés por Accept-Language — usa el header Vary.

http
# Single language
Accept-Language: en-US

# Multiple languages with preferences
Accept-Language: en-US,en;q=0.9, zh-CN;q=0.8, fr;q=0.7, de;q=0.5

# Wildcard
Accept-Language: *

# Server responds with the selected language:
Content-Language: en-US

# RFC 5646 language tags:
# en       - language
# en-US    - language + region
# zh-Hans  - language + script (Simplified Chinese)
# es-419   - language + region (Latin America)

Accept-Encoding

Accept-Encoding lista los algoritmos de compresión que el cliente puede decodificar. El servidor elige uno, lo aplica y devuelve Content-Encoding. Brotli (br) comprime el texto mejor que gzip y está soportado en cualquier navegador moderno. zstd va emergiendo con mejor velocidad/ratio aún. identity significa sin compresión. Activa siempre la compresión para respuestas de texto (HTML, CSS, JS, JSON) — ahorro importante de ancho de banda, pero sáltatelo en formatos ya comprimidos (imágenes, vídeo).

http
# Accepted compression algorithms
Accept-Encoding: gzip, deflate, br, zstd

# With preferences
Accept-Encoding: br;q=1.0, gzip;q=0.8, identity;q=0.5, *;q=0

# identity = no encoding (raw)
# * = any encoding not listed

# Server response
Content-Encoding: br

# Common algorithms:
# gzip     - widespread, RFC 1952
# deflate  - zlib, RFC 1950
# br       - Brotli, better for text (modern browsers)
# zstd     - Zstandard, fast + good ratio (newer)
# identity - no compression

Header Vary

El header Vary indica a las cachés (navegador, CDN, proxy) qué headers de petición afectan a la respuesta. Si un servidor devuelve contenido distinto según Accept-Encoding, debe fijar Vary: Accept-Encoding para que la caché no sirva una respuesta gzip a un cliente que solo acepta br. El exceso de Vary perjudica la tasa de aciertos de caché; el defecto causa envenenamiento de caché (contenido equivocado servido). Vary: * desactiva efectivamente la caché.

http
# Server response telling caches to vary by Accept-Encoding
HTTP/1.1 200 OK
Content-Type: text/html
Content-Encoding: gzip
Vary: Accept-Encoding

# Vary on multiple headers
Vary: Accept-Encoding, Accept-Language

# Vary on Accept (full content negotiation)
Vary: Accept

# Vary: * means "varies on everything" (effectively no-cache)
Vary: *

# CDN/cache key includes the Vary header values.
# A gzip+en response is cached separately from a br+fr response.

Valores de calidad (q)

Los valores de calidad (q, 0-1) expresan la fuerza de la preferencia en los headers de la familia Accept. q=1.0 es el valor por defecto (el más preferido); q=0 significa 'inaceptable'. El servidor lista lo que puede producir, lo compara con la lista del cliente y elige la coincidencia con la q más alta. La especificidad desempata: application/json gana a */* incluso con la misma q. Se permiten tres decimales, pero rara vez hacen falta.

http
# q values appear in Accept, Accept-Language, Accept-Encoding, Accept-Charset
# Format: ;q=0.000 to ;q=1.000 (default is 1.0)

Accept: text/html;q=1.0, application/json;q=0.9, */*;q=0.1

# Meaning:
# q=1.0    - strongly preferred
# q=0.5    - acceptable
# q=0      - NOT acceptable (refuse)

# Server algorithm (RFC 7231):
# 1. List media types the server can produce
# 2. Match each against the client's Accept
# 3. Pick the match with the highest q value
# 4. Ties broken by specificity (concrete > wildcard)

# Example: client prefers JSON over XML
Accept: application/json, application/xml;q=0.5
09

Almacenamiento en caché

Directivas de Cache-Control

Cache-Control es el header de caché moderno con directivas. public/private controla quién puede cachear; max-age fija la frescura en segundos; no-cache fuerza la revalidación; no-store prohíbe el caché; must-revalidate prohíbe servir rancio; s-maxage fija un TTL aparte para cachés compartidas (CDNs). immutable indica a los navegadores que el recurso nunca cambia — se salta la revalidación al recargar. Stale-while-revalidate y stale-if-error habilitan la degradación elegante.

http
# Response directives (server -> cache)
Cache-Control: public, max-age=3600           # cacheable by all, fresh 1h
Cache-Control: private, max-age=600           # browser only, fresh 10min
Cache-Control: no-cache                       # revalidate before use
Cache-Control: no-store                       # never cache (sensitive data)
Cache-Control: must-revalidate                # never serve stale
Cache-Control: proxy-revalidate               # proxies must revalidate
Cache-Control: immutable                      # URL never changes
Cache-Control: max-age=0, must-revalidate     # always revalidate
Cache-Control: s-maxage=3600, max-age=600     # CDN caches 1h, browser 10min

# Request directives (client -> cache)
Cache-Control: no-cache                       # send request to origin
Cache-Control: no-store                       # don't store the response
Cache-Control: only-if-cached                 # only from cache

ETag e If-None-Match

ETag es una etiqueta de versión opaca (a menudo un hash del contenido) adjunta a una respuesta. En la siguiente petición, el cliente envía If-None-Match con el ETag guardado. Si el recurso no cambió, el servidor devuelve 304 Not Modified sin body — ahorrando ancho de banda. Los ETags fuertes garantizan contenido idéntico byte a byte; los débiles (W/) permiten respuestas semánticamente equivalentes (por ejemplo, diferencias de espacios en blanco).

http
# Server tags a response with an ETag
HTTP/1.1 200 OK
ETag: "abc123"
Content-Type: application/json

{"data": "..."}

# Client sends conditional request on next fetch
GET /api/data HTTP/1.1
If-None-Match: "abc123"

# Server compares:
# - If matches: 304 Not Modified (no body)
HTTP/1.1 304 Not Modified
ETag: "abc123"

# - If changed: 200 OK with new body + new ETag
HTTP/1.1 200 OK
ETag: "def456"

# Strong vs weak ETags:
# "abc123"      - strong (byte-identical)
# W/"abc123"    - weak (semantically equivalent)

Last-Modified e If-Modified-Since

Last-Modified es un validador basado en marca de tiempo. Tiene precisión de 1 segundo — los cambios de menos de un segundo pueden perderse. If-Modified-Since dispara un 304 si no cambió. If-Unmodified-Since protege contra actualizaciones perdidas: si otro cliente modificó el recurso, el servidor devuelve 412 Precondition Failed. ETag es preferible cuando está disponible (más preciso), pero Last-Modified es un respaldo útil.

http
# Server includes Last-Modified
HTTP/1.1 200 OK
Last-Modified: Wed, 21 Oct 2023 07:28:00 GMT

# Client sends conditional request
GET /api/data HTTP/1.1
If-Modified-Since: Wed, 21 Oct 2023 07:28:00 GMT

# Server: if not modified since that time -> 304
HTTP/1.1 304 Not Modified

# Server: if modified since -> 200 with new content
HTTP/1.1 200 OK
Last-Modified: Thu, 22 Oct 2023 09:00:00 GMT

# If-Unmodified-Since (for safe updates - optimistic locking)
PUT /api/users/42 HTTP/1.1
If-Unmodified-Since: Wed, 21 Oct 2023 07:28:00 GMT
# 412 Precondition Failed if modified elsewhere

Flujo de validación de caché

Flujo de caché: fresco (dentro de max-age) → servido desde la caché, sin red. Rancio (tras max-age) → petición condicional con validadores. Un 304 refresca el temporizador de caché sin volver a descargar el body. Un 200 reemplaza la entrada cacheada. Esto recorta drásticamente el ancho de banda y la carga del origen. Para datos que cambian a menudo pero donde toleras cierta obsolescencia, usa stale-while-revalidate.

http
# 1. First request - server sends validators
GET /api/users HTTP/1.1

HTTP/1.1 200 OK
Cache-Control: max-age=60
ETag: "v1"
Last-Modified: Wed, 21 Oct 2023 07:28:00 GMT

# 2. Within max-age (60s): cache serves directly, no network
GET /api/users  (served from cache)

# 3. After max-age: stale - revalidate (conditional GET)
GET /api/users HTTP/1.1
If-None-Match: "v1"
If-Modified-Since: Wed, 21 Oct 2023 07:28:00 GMT

# 4a. Unchanged -> 304 (revalidate resets the cache timer)
HTTP/1.1 304 Not Modified
Cache-Control: max-age=60
ETag: "v1"

# 4b. Changed -> 200 with new body
HTTP/1.1 200 OK
Cache-Control: max-age=60
ETag: "v2"

Rotura e invalidación de caché

Rotura de caché: da a los recursos inmutables (JS, CSS, imágenes) URLs versionadas (app.v1a2b3c.js) y cachea un año con immutable. Al desplegar, cambia la URL — los navegadores obtienen el archivo nuevo. El punto de entrada HTML usa no-cache para que los usuarios siempre revaliden y recojan las nuevas URLs de recursos. Este patrón da tanto actualizaciones instantáneas como cachés de larga vida. Evita el versionado por query string (?v=123) — algunos proxies no lo cachean.

http
# Immutable assets with long cache + versioned URLs
GET /assets/app.v1a2b3c.js HTTP/1.1
HTTP/1.1 200 OK
Cache-Control: public, max-age=31536000, immutable

# When deploying a new version, the URL changes:
GET /assets/app.v4d5e6f.js HTTP/1.1
# (browser fetches new file; old one stays cached but unused)

# HTML entry point: short cache, must revalidate
GET /index.html HTTP/1.1
HTTP/1.1 200 OK
Cache-Control: no-cache
# (revalidate every time, but 304 if unchanged)

# Anti-pattern: caching HTML forever (users see stale entry)
# Anti-pattern: querying JS with ?ts=123 (defeats CDN caching)

# Manual cache purge via CDN API (vendor-specific)
10

CORS (entre orígenes)

Same-Origin Policy y CORS

Same-Origin Policy (SOP) es un modelo de seguridad del navegador que impide por defecto que las páginas web lean respuestas de otros orígenes. CORS (Cross-Origin Resource Sharing) es la forma de optar por permitirlo: el servidor declara qué orígenes pueden leer sus respuestas. Origin se define como esquema+host+puerto — que cualquiera de estos difiera significa entre orígenes. CORS solo importa en peticiones de navegador; las llamadas servidor a servidor no tienen restricción.

http
# Same-Origin Policy (SOP): browsers block cross-origin reads by default
# Origin = scheme + host + port
# https://app.com  vs  https://api.com  -> DIFFERENT origins
# http://app.com   vs  https://app.com  -> DIFFERENT (scheme)
# https://app.com  vs  https://app.com:8443 -> DIFFERENT (port)

# CORS lets a server OPT IN to cross-origin requests
# via Access-Control-Allow-Origin response header.

# Simple cross-origin GET (no preflight)
GET /api/data HTTP/1.1
Host: api.example.com
Origin: https://app.example.com

# Server allows the origin
HTTP/1.1 200 OK
Access-Control-Allow-Origin: https://app.example.com

Peticiones simples (sin preflight)

Las peticiones simples se saltan el paso de preflight y van directas al servidor. Las restricciones son conservadoras: solo GET/HEAD/POST, solo headers de la lista segura y solo Content-Types simples. Cualquier desviación (por ejemplo, Content-Type: application/json, headers personalizados, PUT/DELETE) hace la petición 'no simple' y dispara un preflight. El servidor igualmente debe incluir headers CORS en la respuesta o el navegador bloquea su lectura.

http
# A "simple" request is sent directly (no preflight):
# - Method: GET, HEAD, or POST
# - Only CORS-safelisted headers:
#     Accept, Accept-Language, Content-Language, Content-Type
# - Content-Type limited to:
#     application/x-www-form-urlencoded
#     multipart/form-data
#     text/plain
# - No event listeners on upload
# - No ReadableStream

# Example: simple cross-origin POST form submit
POST /api/login HTTP/1.1
Host: api.example.com
Origin: https://app.example.com
Content-Type: application/x-www-form-urlencoded

user=alice&pass=secret

# Server must respond with Allow-Origin for browser to expose response

Peticiones de preflight (OPTIONS)

Un preflight es una petición OPTIONS que el navegador envía antes de una petición entre orígenes no simple. Comprueba si el verbo y los headers reales están permitidos. El servidor responde con Allow-Methods y Allow-Headers. Access-Control-Max-Age cachea el resultado del preflight (5s por defecto, los navegadores tienen tope de 24h). Los preflights añaden latencia — evítalos en los caminos calientes limitándote a peticiones simples cuando sea posible.

http
# Browser sends preflight OPTIONS before non-simple requests
OPTIONS /api/data HTTP/1.1
Host: api.example.com
Origin: https://app.example.com
Access-Control-Request-Method: PUT
Access-Control-Request-Headers: Content-Type, Authorization

# Server preflight response
HTTP/1.1 204 No Content
Access-Control-Allow-Origin: https://app.example.com
Access-Control-Allow-Methods: GET, POST, PUT, DELETE, OPTIONS
Access-Control-Allow-Headers: Content-Type, Authorization
Access-Control-Max-Age: 86400  # cache preflight for 24h

# Only then does the browser send the actual request
PUT /api/data HTTP/1.1
Host: api.example.com
Origin: https://app.example.com
Content-Type: application/json
Authorization: Bearer ...

{"key": "value"}

CORS con credenciales

Por defecto, los fetch entre orígenes no envían cookies. Para incluirlas, el cliente fija credentials: 'include'. El servidor debe responder con Access-Control-Allow-Credentials: true Y devolver el origen específico (no el comodín *). Incluye siempre Vary: Origin para que las cachés no sirvan a un origen una respuesta negociada para otro. Un CORS+credenciales mal configurado es un agujero de seguridad — restringe los orígenes a una lista permitida conocida.

http
# Client: opt in to sending cookies/auth
fetch('https://api.example.com/data', {
  credentials: 'include'   # send cookies cross-origin
});

# Browser sends:
GET /data HTTP/1.1
Origin: https://app.example.com
Cookie: session=abc123

# Server response MUST:
# 1. Echo the SPECIFIC origin (NOT *)
# 2. Set Allow-Credentials: true
HTTP/1.1 200 OK
Access-Control-Allow-Origin: https://app.example.com
Access-Control-Allow-Credentials: true
Vary: Origin   # important: caches must vary by Origin

# Wildcard origin + credentials = browser blocks response
# (Access-Control-Allow-Origin: * with credentials fails)

Errores CORS comunes

Los errores CORS aparecen en la consola del navegador. Los más comunes: falta Allow-Origin (el servidor no optó por permitirlo), comodín con credenciales (combinación prohibida) y falta Allow-Headers/Methods en las respuestas de preflight. CORS lo aplica el navegador, no el servidor — la petición sigue llegando al servidor, pero el navegador oculta la respuesta al JS. Comprueba la pestaña Network: si el preflight OPTIONS falla, la petición real nunca se envía.

http
# Error: No 'Access-Control-Allow-Origin' header
# Cause: server didn't send CORS header, or origin not allowed
# Fix: add Access-Control-Allow-Origin on the server

# Error: Credentials flag is true, but Allow-Origin is *
# Cause: wildcard not allowed with credentials
# Fix: echo the specific request Origin instead of *

# Error: preflight missing Allow-Methods / Allow-Headers
# Cause: server didn't allow the method/header
# Fix: add them to Access-Control-Allow-Methods/Headers

# Error: Allow-Origin doesn't match Origin
# Cause: server echoed a different origin (or scheme mismatch)
# Fix: dynamically echo req.headers.origin if allowlisted

# Debug:
# - Check browser DevTools Console for exact error
# - Check Network tab -> see the OPTIONS preflight response
# - Verify headers in the response
11

HTTPS y SSL/TLS

Handshake TLS (HTTPS)

HTTPS envuelve HTTP en cifrado TLS. El handshake TLS autentica al servidor (certificado), negocia el cifrado e intercambia claves. TLS 1.2 tarda 2 viajes de ida y vuelta; TLS 1.3 tarda 1 (o 0 con reanudación). SNI (Server Name Indication) envía el hostname objetivo en claro para que el servidor elija el certificado correcto — esto filtra el hostname a los escuchas; ECH (Encrypted Client Hello) lo cifra.

http
# HTTPS = HTTP over TLS
# 1. TCP connection (port 443)
# 2. TLS handshake:
ClientHello -> server
  - supported TLS versions, cipher suites, extensions
  - SNI: hostname (example.com)
ServerHello + Certificate + ServerHelloDone <- server
  - selected cipher, certificate (public key)
ClientKeyExchange + ChangeCipherSpec -> server
  - encrypted pre-master secret (RSA) or ECDHE params
ChangeCipherSpec + Finished <- server
# 3. Encrypted HTTP exchange begins
GET /page HTTP/1.1
Host: example.com

# TLS 1.3 collapses this to 1 round trip (1-RTT)
# 0-RTT resumption for returning connections

Conexión HTTPS

HTTPS es HTTP sobre TLS, normalmente en el puerto 443. Los mensajes HTTP en sí no cambian — TLS solo cifra el tráfico TCP subyacente. Para aplicar HTTPS, redirige HTTP→HTTPS (301) y fija el header HSTS para que los navegadores recuerden usar HTTPS durante el tiempo especificado. Las listas de preload de HSTS (mantenidas por los navegadores) fijan este comportamiento, de modo que incluso la primera petición va por HTTPS.

http
# HTTP on port 80 (plaintext)
GET /page HTTP/1.1
Host: example.com

# HTTPS on port 443 (TLS-encrypted)
# Same HTTP messages, but the wire traffic is encrypted.
GET /page HTTP/1.1
Host: example.com

# Force HTTPS via redirect
HTTP/1.1 301 Moved Permanently
Location: https://example.com/page

# Force HTTPS via HSTS (browser remembers)
Strict-Transport-Security: max-age=31536000; includeSubDomains; preload

# Modern browsers default to https:// for bare domains
# (some even refuse plain HTTP for sensitive endpoints)

Certificados

Los certificados X.509 vinculan una clave pública a un dominio, firmados por una Autoridad Certificadora (CA). La cadena de confianza va del certificado del servidor a través de los intermedios hasta una CA raíz preinstalada en el navegador. Los navegadores verifican la cadena, la fecha de expiración y que el SAN (Subject Alternative Name) coincida con el hostname solicitado. Los certificados comodín (*.example.com) y multidominio (múltiples SANs) cubren varios hostnames.

http
# X.509 certificate contains:
# - Subject: example.com (CN is deprecated; use SAN)
# - Subject Alternative Name (SAN): example.com, www.example.com
# - Issuer: Let's Encrypt / DigiCert (CA)
# - Validity: Not Before / Not After
# - Public key (RSA or ECDSA)
# - Signature by CA

# Chain of trust:
# Root CA (self-signed, in browser trust store)
#   -> Intermediate CA
#     -> Server cert (your domain)

# Server sends leaf + intermediate during handshake.
# Browser verifies: signature chain back to a trusted root.

# Inspect a cert:
openssl s_client -connect example.com:443 -showcerts
openssl x509 -in cert.pem -text -noout

HSTS (HTTP Strict Transport Security)

HSTS indica a los navegadores que usen siempre HTTPS para un dominio, previniendo ataques de SSL-stripping. max-age va en segundos (1 año = 31536000). includeSubDomains lo extiende a cada subdominio. preload somete el dominio a una lista fija de los navegadores para que incluso la primera visita sea HTTPS — protección fuerte pero difícil de revertir (quitarlo tarda meses). Redirige primero HTTP→HTTPS, luego añade HSTS y opcionalmente preload.

http
# Tell browser to use HTTPS for 6 months
Strict-Transport-Security: max-age=15768000

# Include subdomains
Strict-Transport-Security: max-age=15768000; includeSubDomains

# Submit to preload list (browsers hardcode the domain)
Strict-Transport-Security: max-age=31536000; includeSubDomains; preload

# Effects:
# - http://example.com -> browser rewrites to https://
# - Self-signed cert -> browser blocks (no override)
# - prevents SSL stripping attacks (downgrade to HTTP)

# Preload list: https://hstspreload.org
# Once preloaded, removal is slow and difficult.

Versiones TLS y cifrados

Desactiva SSLv2/v3 y TLS 1.0/1.1 — tienen vulnerabilidades conocidas (POODLE, BEAST). TLS 1.3 (2018) es el estándar moderno: handshake más rápido, elimina cifrados débiles y exige secreto forward. TLS 1.2 con ECDHE + AES-GCM es aceptable. Usa herramientas como SSL Labs para calificar tu configuración. El secreto forward (ECDHE) garantiza que el tráfico pasado sigue cifrado incluso si la clave privada se filtra después.

http
# TLS versions (deprecate old ones!)
# SSLv2, SSLv3  - BROKEN (POODLE), disable
# TLS 1.0, 1.1  - deprecated (2020), disable
# TLS 1.2       - widely supported, OK
# TLS 1.3       - fastest, most secure (preferred)

# Modern cipher suites (TLS 1.3):
# TLS_AES_256_GCM_SHA384
# TLS_CHACHA20_POLY1305_SHA256
# TLS_AES_128_GCM_SHA256

# TLS 1.2 recommended:
# ECDHE-ECDSA-AES256-GCM-SHA384 (forward secrecy + AEAD)
# ECDHE-RSA-AES256-GCM-SHA384

# Server config (nginx example)
ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers off;
ssl_ciphers ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384;

# Test: https://www.ssllabs.com/ssltest/
12

HTTP/2

Características de HTTP/2

HTTP/2 conserva la semántica HTTP (verbos, códigos de estado, headers) pero cambia el formato de cable a tramas binarias. Ventajas clave: multiplexación de muchas peticiones sobre una conexión TCP (sin bloqueo de cabeza de línea a nivel HTTP), compresión de headers HPACK y priorización de streams. Negociado vía ALPN sobre TLS (lo más común) o actualización h2c sobre texto plano. Server Push quedó obsoleto en 2022 por su pobre rendimiento real.

http
# HTTP/2 (RFC 9113, 2015) - binary, multiplexed
# - Binary framing (not text)
# - Multiplexing: many streams over 1 TCP connection
# - Header compression (HPACK)
# - Server Push (deprecated in 2022)
# - Stream prioritization
# - Single connection per origin

# Negotiation:
# - Over TLS: ALPN extension advertises "h2"
# - Over plaintext: h2c upgrade (rare in practice)

#curl with HTTP/2:
curl -v --http2 https://example.com
# (Connection header shows HTTP/2)

# Backward compatible: same methods, status codes, headers, semantics
# Only the wire format changes.

Multiplexación

La multiplexación es la característica estrella de HTTP/2. Muchos streams comparten una conexión TCP, con tramas intercaladas — adiós al límite de 6 conexiones por origen y al bloqueo de cabeza de línea en la capa HTTP. Esto elimina los hacks de HTTP/1.1 como el domain sharding, la concatenación de archivos y la incrustación de imágenes. Ojo: el bloqueo de cabeza de línea a nivel TCP sigue existiendo (un paquete perdido estanca el conjunto de streams hasta la retransmisión) — eso es lo que HTTP/3 corrige con QUIC.

http
# HTTP/1.1: 6 parallel connections per origin, each request blocks its connection
# (head-of-line blocking at the HTTP level)

# HTTP/2: 1 connection, many parallel streams
# Each request/response is a stream with a unique ID.

# Frames carry data for multiple streams interleaved:
# Stream 1: HEADERS, DATA (request 1)
# Stream 3: HEADERS, DATA (request 2)
# Stream 5: HEADERS, DATA (request 3)
# Server responds with interleaved frames on each stream.

# Browser opens one TCP+TLS connection per origin,
# then sends all requests as concurrent streams.

# Eliminates: domain sharding, concatenation, inlining
# (those were HTTP/1.1 optimization hacks)

Server Push (obsoleto)

Server Push permitía al servidor enviar recursos antes de que el cliente los pidiera. En teoría ahorra un viaje de ida y vuelta para los recursos críticos. En la práctica quedó obsoleto en 2022: el servidor no puede conocer el estado de la caché del cliente, así que sobreenvía, desperdiciando a menudo ancho de banda. Los navegadores ahora ignoran las tramas PUSH_PROMISE. Alternativas modernas: <link rel=preload> en el HTML, o 103 Early Hints (el servidor envía pistas de preload antes de la respuesta final).

http
# Server proactively sends resources the client will need
GET /index.html HTTP/2
Host: example.com

HTTP/2 200 OK
Content-Type: text/html
Link: </style.css>; rel=preload; as=style

# Server then pushes style.css on a new stream
PUSH_PROMISE (stream 2, /style.css)
<headers + body of /style.css>

# Then the actual /index.html body follows.

# DEPRECATED (2022): browsers ignore it because:
# - Client cache might already have the asset
# - Server can't know what client has cached
# - Net performance negative in real deployments

# Modern alternative: <link rel="preload" href="...">
# or 103 Early Hints

Priorización de streams

HTTP/2 permitía a los clientes expresar la prioridad de los streams vía un árbol de dependencias con pesos. El servidor lo usaba para repartir el ancho de banda: por ejemplo, CSS antes que imágenes. La RFC 9113 (2022) eliminó la trama explícita PRIORITY, dejando la planificación al servidor — muchos implementaron la suya propia. El Extensible Prioritization Scheme (RFC 9218) es una alternativa moderna opcional. La priorización importa más en conexiones lentas.

http
# HTTP/2 streams have priority (weight + dependency tree)
# Originally: client sends PRIORITY frames
# Client says: "CSS (stream 3) is more important than image (stream 5)"

# PRIORITY frame (original model):
# - stream dependency (parent)
# - weight (1-256)

# RFC 9113 (2022) removed explicit prioritization
# - Leaves it to the server
# - Many servers implement their own scheduler

# Practical effect: server allocates bandwidth
# - HTML, CSS, JS -> high priority
# - Images, fonts -> lower priority
# - Critical render path optimized

# Clients can still signal via Extensible Prioritization Scheme
# (RFC 9218) - optional.

Compresión de headers HPACK

HPACK comprime los headers HTTP usando una tabla estática de headers comunes, una tabla dinámica por conexión que aprende los valores recién enviados, y codificación Huffman. Esto recorta drásticamente la sobrecarga — una cookie de 1KB enviada en cada petición se convierte en una referencia indexada minúscula. HPACK está cuidadosamente diseñado para evitar los ataques de oráculo de compresión CRIME/BREACH que azotaron a la compresión TLS anterior. HTTP/3 usa un esquema similar llamado QPACK.

http
# HTTP/1.1: headers sent as plaintext on every request (redundant)
# Cookies alone can exceed 1KB per request.

# HTTP/2: HPACK compresses headers
# - Static table: 61 common headers (e.g., :method GET)
# - Dynamic table: per-connection, learns recently sent headers
# - Huffman coding for strings

# Example: first request sends full User-Agent (200 bytes)
# Subsequent requests reference the dynamic table entry (2 bytes)

# Indexed header representation:
# 1 bit set + index -> "use entry N"

# Literal with incremental indexing:
# "add this to the dynamic table for future reuse"

# Security: CRIME attack exploited compression oracles.
# HPACK mitigates by never compressing sensitive + attacker-controlled
# data together.
13

HTTP/3 y QUIC

Protocolo QUIC

QUIC es un protocolo de transporte sobre UDP que integra TLS 1.3 y proporciona streams fiables y multiplexados. Pasar a UDP permite a QUIC evolucionar más rápido que el TCP del kernel. Ventajas clave: sin bloqueo de cabeza de línea a nivel TCP (un paquete perdido solo estanca un stream), reanudación 0-RTT para conexiones recurrentes y migración de conexión (un teléfono que cambia de Wi-Fi a red móvil conserva la conexión). HTTP/3 corre sobre QUIC.

http
# QUIC = Quick UDP Internet Connections (Google, then IETF)
# - Transport protocol over UDP (not TCP)
# - Built-in TLS 1.3 encryption
# - Multiple streams, independent per-stream delivery
# - 0-RTT connection resumption
# - Connection migration (survives IP changes)
# - Better loss recovery than TCP

# Why UDP? TCP is in the kernel and hard to evolve.
# QUIC moves reliability + congestion control to user space.

# Wire format: UDP packets containing QUIC packets
# - Initial, Handshake, 1-RTT, 0-RTT packets
# - Frames carry stream data, acks, flow control

# Negotiation:
# Server advertises HTTP/3 via Alt-Svc header on HTTP/2 response:
Alt-Svc: h3=":443"; ma=86400
# Browser caches this and uses HTTP/3 next time.

Características de HTTP/3

HTTP/3 conserva la semántica HTTP pero corre sobre QUIC en lugar de TCP. La gran ventaja: sin bloqueo de cabeza de línea. En HTTP/2 un único paquete TCP perdido estanca el conjunto de streams multiplexados hasta la retransmisión; en HTTP/3 solo espera el stream afectado. Además, reanudación 0-RTT y migración de conexión. El coste: más CPU (QUIC en espacio de usuario) y UDP a veces bloqueado/limitado por las redes. La adopción crece — la mayoría de sitios grandes lo soportan.

http
# HTTP/3 (RFC 9114, 2022) - HTTP semantics over QUIC
# Same methods, status codes, headers as HTTP/2
# - Binary framing (similar to HTTP/2)
# - Multiplexing over QUIC streams (no HoL blocking!)
# - QPACK header compression (HPACK variant)
# - 0-RTT for returning clients
# - Connection migration

# Loss recovery: per-stream, not per-connection
# A lost packet stalls only that stream, others continue.

# Head-of-line blocking eliminated at the transport layer:
# HTTP/2: lost TCP packet blocks ALL streams (kernel retransmit)
# HTTP/3: lost QUIC packet blocks only that stream

# curl with HTTP/3 (requires special build):
curl -v --http3 https://example.com

Reanudación de conexión 0-RTT

0-RTT permite a los clientes recurrentes enviar datos en su primer vuelo (sin viaje de ida y vuelta antes de la petición). Esto recorta decenas a cientos de milisegundos en las visitas repetidas. El problema: los datos tempranos pueden ser reenviados por un atacante, así que deben limitarse a operaciones idempotentes (GET, HEAD, PUT/DELETE si son idempotentes). Los servidores deberían rechazar 0-RTT para POST y otros verbos que cambian de estado. Los mecanismos anti-replay añaden complejidad.

http
# TLS 1.3 + QUIC: 0-RTT resumption for returning clients
# First visit: full handshake (1-RTT in TLS 1.3)
Client -> Server: ClientHello + key share
Server -> Client: ServerHello + key share + Finished
Client -> Server: Finished + first HTTP request

# Returning visit (0-RTT):
Client -> Server: ClientHello + early data (HTTP request)
# Server can respond immediately, no round trip!

# Trade-offs:
# + Saves 1 RTT on subsequent visits (faster page loads)
# - Vulnerable to replay attacks on early data
# - Only safe for idempotent methods (GET, HEAD)
# - Server should reject 0-RTT for non-idempotent requests

# Configure carefully:
# - Limit early data to safe methods
# - Use anti-replay mechanisms

Migración de conexión

Las conexiones QUIC se identifican por un ID de conexión en lugar de la tupla de 4 IP/puerto. Esto significa que una conexión sobrevive a cambios de IP — un teléfono que pasa de Wi-Fi a red móvil, o un portátil que se mueve entre redes, conserva la conexión. El servidor valida la nueva ruta con PATH_CHALLENGE/PATH_RESPONSE. TCP no puede hacer esto porque el kernel identifica las conexiones por la tupla de 4. Gran ventaja para móviles.

http
# TCP connection identified by 4-tuple:
# (src IP, src port, dst IP, dst port)
# If your phone switches Wi-Fi -> cellular, IP changes ->
# the TCP connection dies. Browser must reconnect.

# QUIC uses a connection ID (random, in every packet).
# The 4-tuple can change mid-connection; the connection ID
# identifies the connection.

# Scenario:
# 1. Phone on Wi-Fi, downloading a large file over HTTP/3
# 2. Phone walks out, switches to cellular
# 3. Packets now arrive from a new IP, same connection ID
# 4. Server continues serving the same connection!
# 5. No reconnect, no re-handshake, no failed download.

# Validation: server sends PATH_CHALLENGE, client replies PATH_RESPONSE.

HTTP/1.1 vs HTTP/2 vs HTTP/3

HTTP/1.1 es texto sobre TCP con 6 conexiones en paralelo. HTTP/2 es binario sobre TCP con multiplexación (pero bloqueo de cabeza de línea a nivel TCP). HTTP/3 es binario sobre QUIC sin bloqueo de cabeza de línea, cifrado obligatorio, 0-RTT y migración de conexión. La adopción es incremental: los servidores anuncian HTTP/3 vía el header Alt-Svc en las respuestas HTTP/2, y los navegadores actualizan en la siguiente visita. Los tres comparten la semántica HTTP.

http
# Feature comparison
# Property         | HTTP/1.1     | HTTP/2       | HTTP/3
# -----------------+--------------+--------------+--------------
# Transport        | TCP          | TCP          | QUIC (UDP)
# Format           | Text         | Binary       | Binary
# Multiplexing     | No (6 conns) | Yes          | Yes
# HoL blocking     | HTTP-level   | TCP-level    | None
# Header compress  | No           | HPACK        | QPACK
# Server Push      | No           | Yes (deprecated) | No
# Encryption       | Optional     | Optional     | Mandatory (TLS 1.3)
# 0-RTT            | No           | No           | Yes
# Connection migration | No       | No           | Yes
# Handshake RTT    | 1+           | 1+           | 0-1 (with resumption)

# Most sites today: HTTP/2 over TLS, with HTTP/3 available via Alt-Svc
14

Redirección (3xx)

301 vs 302

301 significa permanente: los navegadores cachean la redirección, los marcadores se actualizan y el valor SEO de los enlaces pasa a la nueva URL. 302 significa temporal: nada se cachea y el SEO se queda con el original. Históricamente, ambos convertían POST→GET (una violación de la especificación que se volvió de facto). Para conservar estrictamente el verbo, usa 307 (temporal) o 308 (permanente). Para migraciones de SEO usa 301; para redirecciones de login usa 302 o 307.

http
# 301 Moved Permanently
HTTP/1.1 301 Moved Permanently
Location: https://newsite.com/page
# - Permanent; browser & SEO caches it
# - Link juice transfers to new URL (SEO)
# - Bookmark updates
# - HTTP/1.1 spec: should preserve method, but historically
#   POST -> GET (causing data loss)

# 302 Found
HTTP/1.1 302 Found
Location: /login
# - Temporary
# - Don't update bookmarks
# - SEO link juice stays with original URL
# - HTTP/1.1 spec: should preserve method, but historically
#   POST -> GET

# Use 301 for permanent moves (site migrations).
# Use 302 for temporary redirects (login flows, A/B tests).

307 vs 308

307 y 308 son los homólogos que conservan el verbo de 302 y 301. Corrigen el bug histórico de conversión POST→GET. 307 es temporal, 308 es permanente — ambos mantienen el verbo y el body originales. Úsalos al redirigir peticiones no GET, especialmente en APIs donde una conversión POST→GET descartaría silenciosamente el body. 308 es la elección moderna para mover endpoints de API de forma permanente.

http
# 307 Temporary Redirect (HTTP/1.1, method-preserving)
HTTP/1.1 307 Temporary Redirect
Location: /new-endpoint
# - Temporary
# - Method PRESERVED: POST stays POST, body stays intact
# - Browser prompts before re-issuing POST to different host

# 308 Permanent Redirect (RFC 7538)
HTTP/1.1 308 Permanent Redirect
Location: https://newsite.com/api
# - Permanent
# - Method PRESERVED
# - Like 301 but without the POST->GET conversion

# When to use:
# - 307: temporary redirect that must preserve method
# - 308: permanent redirect that must preserve method
#   (e.g., API endpoint moved, clients still POSTing)

# Most browsers support both since ~2015.

303 See Other (patrón PRG)

303 See Other indica explícitamente al navegador que continúe con un GET — la herramienta correcta para el patrón Post/Redirect/Get (PRG). Tras procesar un POST, redirige con 303 a una página GET. Si el usuario refresca, reenvía el GET seguro (no el POST), evitando envíos de formulario duplicados. Usa 303 para PRG, 307/308 cuando necesites conservar el verbo original, 301/302 para navegación simple.

http
# 303 See Other - explicitly converts to GET
HTTP/1.1 303 See Other
Location: /success
# - Always converts to GET (no body)
# - Used in Post/Redirect/Get (PRG) pattern

# PRG pattern: avoid double-submit on refresh
# 1. User submits form
POST /checkout HTTP/1.1
Host: shop.com
Content-Type: application/x-www-form-urlencoded

item=book&qty=1

# 2. Server processes, redirects to a GET page
HTTP/1.1 303 See Other
Location: /order/123/confirmation

# 3. Browser issues GET (safe to refresh)
GET /order/123/confirmation HTTP/1.1
Host: shop.com

HTTP/1.1 200 OK
# "Order confirmed!"

Cadenas y bucles de redirección

Las cadenas de redirección añaden latencia (cada salto = un viaje de ida y vuelta) y deberían aplanarse — apunta la URL original directamente al destino final. Los bucles de redirección son fatales: los navegadores los detectan tras unos saltos y muestran una página de error. Causas comunes: configuración incorrecta HTTPS↔HTTP detrás de un balanceador (usa X-Forwarded-Proto), o conflictos de barra final. HSTS evita los bucles de redirección HTTP→HTTPS haciendo que el navegador reescriba internamente.

http
# Redirect chain: A -> B -> C
GET /a  -> 301 -> /b
GET /b  -> 301 -> /c
GET /c  -> 200 OK

# Each hop adds a round trip; chains hurt performance.
# Browsers cap redirects (typically 20), then error.

# Redirect loop (fatal):
GET /a -> 302 -> /b
GET /b -> 302 -> /a
GET /a -> 302 -> /b  (browser detects loop, shows error)

# Common cause: HTTPS <-> HTTP loop
# Server A redirects HTTP -> HTTPS
# Server B (behind TLS terminator) sees HTTP internally,
# redirects to HTTPS again -> loop

# Fix: trust X-Forwarded-Proto, or use HSTS instead of redirects

# Common cause: trailing slash mismatch
# /api/users -> 301 -> /api/users/ -> 301 -> /api/users/
# (server config bug)

Casos de uso comunes de redirección

Casos de uso comunes de redirección: HTTP→HTTPS (301), dominio raíz↔www (301), migraciones de URL antigua→nueva (301), redirecciones de login (302/303), patrón PRG (303), movimientos de endpoints de API (308) y respaldos de origen de CDN. Prefiere siempre 301/308 para movimientos permanentes para que las cachés y el SEO se actualicen. Usa HSTS en lugar de redirecciones HTTP→HTTPS donde sea posible — evita el viaje de ida y vuelta de la redirección en las visitas siguientes.

http
# 1. HTTP -> HTTPS upgrade
HTTP/1.1 301 Moved Permanently
Location: https://example.com/

# 2. www -> apex (or vice versa)
HTTP/1.1 301 Moved Permanently
Location: https://example.com/

# 3. Old URL -> new URL (site migration)
HTTP/1.1 301 Moved Permanently
Location: https://example.com/new-page

# 4. Login required (temporary)
HTTP/1.1 302 Found
Location: /login?return=/dashboard

# 5. POST form -> confirmation (PRG)
HTTP/1.1 303 See Other
Location: /success

# 6. API endpoint moved (preserve method)
HTTP/1.1 308 Permanent Redirect
Location: /v2/users

# 7. CDN origin fallback (when content not cached)
HTTP/1.1 302 Found
Location: https://origin.example.com/asset
15

Tipos de contenido (MIME)

Tipos MIME comunes

Los tipos MIME (tipos de medios) describen el formato de un body. Consisten en tipo/subtipo y parámetros opcionales (charset, boundary). Tipos comunes: text/html para páginas, application/json para APIs, image/* y video/* para medios. application/octet-stream es el respaldo para datos binarios desconocidos — los navegadores lo descargarán en lugar de intentar renderizarlo. IANA mantiene el registro oficial.

http
# Text
text/html                    # HTML pages
text/plain                   # plain text
text/css                     # stylesheets
text/csv                     # comma-separated values
text/javascript              # JavaScript (legacy, was application/javascript)

# Application
application/json             # JSON
application/xml              # XML
application/javascript       # JavaScript (modern, text/javascript also OK)
application/pdf              # PDF
application/zip              # ZIP archive
application/octet-stream     # binary (unknown type, forces download)
application/x-www-form-urlencoded  # form data
application/ld+json          # JSON-LD (linked data)

# Image
image/jpeg, image/png, image/gif, image/webp, image/svg+xml, image/avif

# Audio/Video
audio/mpeg, audio/ogg, video/mp4, video/webm

# Multipart
multipart/form-data          # file uploads
multipart/byteranges         # partial content

Header Content-Type

El header Content-Type declara el tipo MIME del body. Para tipos de texto, charset especifica la codificación (el valor por defecto de text/* es ISO-8859-1; fija siempre UTF-8 explícitamente). Para bodies multipart, boundary separa las partes. Los navegadores pueden 'olfatear' el tipo si falta o es ambiguo — evítalo con X-Content-Type-Options: nosniff, que les obliga a respetar el tipo declarado (endurecimiento de seguridad contra XSS vía subida de archivos).

http
# Response Content-Type
HTTP/1.1 200 OK
Content-Type: application/json; charset=utf-8

# Request Content-Type (for bodies)
POST /api/users HTTP/1.1
Content-Type: application/json

{"name": "Alice"}

# charset parameter (text types)
Content-Type: text/html; charset=UTF-8

# boundary parameter (multipart)
Content-Type: multipart/form-data; boundary=----WebKitFormBoundary

# X-Content-Type-Options: nosniff
# tells browser not to sniff/override the declared type

multipart/form-data

multipart/form-data codifica varias partes (campos y archivos) en un solo body, separadas por un boundary. Cada parte tiene su propio Content-Disposition (con filename opcional) y Content-Type. Es el formato que usan los navegadores al enviar formularios con inputs de archivo. Es la única forma práctica de subir archivos vía formularios HTML, aunque para APIs, base64-en-JSON o un PUT directo a una URL de almacenamiento suele ser más simple.

http
# File upload form
POST /upload HTTP/1.1
Content-Type: multipart/form-data; boundary=----boundary123

------boundary123
Content-Disposition: form-data; name="title"

My Photo
------boundary123
Content-Disposition: form-data; name="file"; filename="photo.jpg"
Content-Type: image/jpeg

<binary JPEG bytes>
------boundary123--

# Each part has its own headers (Content-Disposition, Content-Type).
# Final boundary has trailing --.
# Used for file uploads (browsers' <input type="file">).
# Less efficient than JSON for plain fields - overhead per part.

application/json

application/json es el formato de API dominante — ligero, legible por humanos y soportado nativamente en cualquier lenguaje. JSON es UTF-8 por defecto (el parámetro charset es redundante pero inofensivo). Los tipos de medios específicos de fabricante (application/vnd.api+json, application/vnd.github.v3+json) habilitan el versionado y la negociación de perfiles. La RFC 7807 (application/problem+json) estandariza las respuestas de error.

http
# Most common API Content-Type
POST /api/users HTTP/1.1
Content-Type: application/json
Accept: application/json

{
  "name": "Alice",
  "age": 30,
  "tags": ["admin", "user"],
  "metadata": null
}

# Variants:
# application/json             - standard
# application/json; charset=utf-8  - JSON is UTF-8 by default, charset is redundant
# application/ld+json          - JSON-LD (linked data with @context)
# application/vnd.api+json     - JSON:API spec
# application/problem+json     - RFC 7807 problem details for errors

# Vendor types: application/vnd.company.v1+json
# (custom versioned JSON)

Parámetro charset

El parámetro charset declara la codificación del texto. Fíjalo siempre para tipos text/* — el valor por defecto ISO-8859-1 causa mojibake con caracteres no ASCII. UTF-8 es la elección universal mejor. Para JSON, charset es redundante (JSON es UTF-8 por especificación). Para XML, la especificación usa UTF-8 por defecto, pero declararlo explícitamente evita la sobrecarga del olfateo de BOM. Los charsets que no coinciden producen caracteres basura.

http
# charset specifies the text encoding
Content-Type: text/html; charset=UTF-8      # preferred
Content-Type: text/html; charset=iso-8859-1 # legacy

# For JSON, charset is redundant (JSON spec mandates UTF-8)
Content-Type: application/json              # correct
Content-Type: application/json; charset=utf-8  # harmless but redundant

# Default charsets (when omitted):
# text/*                  -> ISO-8859-1 (legacy, problematic)
# application/json        -> UTF-8 (mandatory per spec)
# application/xml         -> UTF-8 (per XML spec)

# Always declare charset for text types to avoid mojibake.
# Mismatched charset = broken characters.

# In HTML, also declare in the document:
<meta charset="UTF-8">
16

Transferencia por fragmentos

Transfer-Encoding: chunked

La codificación de transferencia chunked permite al servidor transmitir un body sin conocer de antemano su longitud total. Cada fragmento va precedido de su longitud en hexadecimal, seguido de CRLF, los datos y CRLF. Un fragmento de longitud cero señala el final. Es esencial para respuestas generadas dinámicamente (renderizado de plantillas, consultas de base de datos) donde el tamaño no se conoce hasta que se producen los datos. HTTP/2 y HTTP/3 no usan la codificación chunked — tienen su propio entramado.

http
# When the server doesn't know the final Content-Length
# (e.g., streaming, dynamically generated content),
# it sends the body in chunks.

HTTP/1.1 200 OK
Content-Type: text/plain
Transfer-Encoding: chunked

4

Wiki

6

pedia 

E

in chunks.

0




# Each chunk: <hex-length>
<data>

# Final chunk: 0
 (zero length)
# Then optional trailer headers + final 

Respuestas en streaming

Las respuestas en streaming usan la codificación chunked para enviar datos de forma incremental. Server-Sent Events (SSE) es el patrón canónico: el servidor mantiene la conexión abierta y escribe eventos como 'data: <payload>\n\n'. La API EventSource del navegador los recibe a medida que llegan. Otros usos: renderizado progresivo de HTML (vaciar a medida que avanzas), arrays JSON grandes, seguimiento de logs. Asegúrate de que ningún proxy intermedio almacene en búfer la respuesta — fija X-Accel-Buffering: no para nginx.

http
# Server-Sent Events (SSE): one-way streaming over HTTP
HTTP/1.1 200 OK
Content-Type: text/event-stream
Cache-Control: no-cache
Connection: keep-alive
Transfer-Encoding: chunked

data: {"msg": "hello"}


data: {"msg": "world"}


data: {"msg": "done"}



# Each event: "data: <payload>

"
# Browser keeps the connection open via EventSource API.

# Other streaming patterns:
# - Server-side rendering: flush HTML as it's generated
# - Large JSON: stream array elements
# - Logs tailing: continuous chunk stream

# Don't buffer: set X-Accel-Buffering: no (nginx)

Headers de trailer

Los headers de trailer se envían después del body al usar la codificación chunked. Son útiles para estadísticas de resumen calculadas durante el streaming — por ejemplo, un recuento de filas, un checksum o la duración del procesamiento. El header Trailer anuncia qué trailers aparecerán. Algunos headers están prohibidos como trailers (Host, Content-Length, Transfer-Encoding, headers de autenticación) porque afectan al entramado de la conexión. El soporte del cliente es irregular — muchos clientes ignoran los trailers.

http
# Trailer headers are sent AFTER the body (with chunked encoding)
HTTP/1.1 200 OK
Content-Type: application/json
Transfer-Encoding: chunked
Trailer: X-Total-Count, X-Duration

5

{"a":1

5

,"b":2

0

X-Total-Count: 2

X-Duration: 0.045s




# Use case: compute summary stats during streaming
# (e.g., total count, checksum) and send at the end.

# The "Trailer" header declares which trailers to expect.
# Some headers are forbidden as trailers:
# - Transfer-Encoding, Content-Length, Host
# - Authentication-related headers

Content-Length vs chunked

Content-Length indica al cliente el tamaño exacto del body de antemano — simple, habilita barras de progreso y permite reutilizar la conexión limpiamente. La codificación chunked permite transmitir sin conocer el tamaño. Debes usar una u otra (o cerrar la conexión al final). Enviar ambas es ambiguo; según la especificación gana chunked, pero los clientes antiguos pueden comportarse mal. Para archivos estáticos, usa siempre Content-Length; para dinámico/streaming, usa chunked.

http
# Content-Length: known body size up front
HTTP/1.1 200 OK
Content-Type: text/plain
Content-Length: 11

Hello World

# Pros: simple, allows progress bars, enables persistent conn reuse
# Cons: requires knowing the size before sending

# Transfer-Encoding: chunked: stream without knowing size
HTTP/1.1 200 OK
Content-Type: text/plain
Transfer-Encoding: chunked

5
Hello

6
 World

0



# Pros: can stream as data is produced
# Cons: no progress bar, slightly more overhead per chunk

# Rule: you must use ONE of these (or close the connection).
# Using both is ambiguous - chunked wins per spec but is buggy in old clients.

Streaming en HTTP/2 (sin chunked)

HTTP/2 y HTTP/3 no usan la codificación chunked — tienen su propio entramado binario. Las tramas DATA llevan los bytes del body; el flag END_STREAM señala el final. Esto da la misma capacidad de streaming sin la sobrecarga por fragmento del entramado de longitud hexadecimal. El header Transfer-Encoding es ilegal en HTTP/2 (RFC 9113). Content-Length sigue permitido pero es opcional. La semántica del streaming se conserva; solo cambia el mecanismo de cable.

http
# HTTP/2 and HTTP/3 don't use Transfer-Encoding: chunked.
# They have their own framing: DATA frames carry body bytes,
# END_STREAM flag marks the end.

# In HTTP/2, "streaming" means sending multiple DATA frames
# on a single stream, with the END_STREAM flag on the last.

# Server push of partial response:
# HEADERS frame (status, headers)
# DATA frame (chunk 1)
# DATA frame (chunk 2)
# DATA frame + END_STREAM (chunk 3, final)

# Effect: same streaming behavior as chunked,
# but at the framing layer, not the encoding layer.

# Transfer-Encoding header is illegal in HTTP/2.
# Content-Length is allowed but optional.
17

Peticiones de rango

Header Range

Las peticiones de rango permiten a un cliente obtener parte de un recurso — esencial para descargas reanudables, búsqueda en vídeo y descargas paralelas por fragmentos. El header Range especifica rangos de bytes. El servidor responde con 206 Partial Content y un header Content-Range que muestra lo que devolvió. Si el servidor no soporta rangos, ignora el header y devuelve 200 con el body completo. Comprueba siempre Accept-Ranges primero.

http
# Request a portion of a resource (e.g., resume downloads, video seeking)
GET /video.mp4 HTTP/1.1
Host: example.com
Range: bytes=0-1023        # first 1024 bytes

# Server response: 206 Partial Content
HTTP/1.1 206 Partial Content
Content-Range: bytes 0-1023/1048576
Content-Length: 1024
Content-Type: video/mp4

<1024 bytes of video>

# Range formats:
Range: bytes=0-1023        # bytes 0 through 1023
Range: bytes=1024-         # from byte 1024 to end
Range: bytes=-1024         # last 1024 bytes
Range: bytes=0-1023,2048-3071  # multiple ranges (multipart response)

Header Accept-Ranges

El header Accept-Ranges anuncia si el servidor soporta peticiones de rango. bytes significa sí; none (o su ausencia) significa no. Los clientes deberían comprobarlo antes de depender de Range — un servidor que ignora Range devolverá el body completo con 200. Los navegadores lo usan automáticamente para la búsqueda en <video> (saltar a una marca de tiempo = petición de rango) y las descargas reanudables. La mayoría de CDNs y servidores estáticos soportan rangos; los endpoints dinámicos a menudo no.

http
# Server advertises range support
HTTP/1.1 200 OK
Accept-Ranges: bytes        # supports byte-range requests
Content-Length: 1048576

# Server doesn't support ranges
HTTP/1.1 200 OK
Accept-Ranges: none

# (or omit the header entirely - same as "none")

# Client checks before sending Range:
# 1. HEAD or GET request to inspect Accept-Ranges
# 2. If "bytes", send Range: bytes=...
# 3. If "none" or missing, expect 200 with full body

# Browsers handle this transparently for video/audio,
# resumable downloads, and PDF preview.

Respuesta de contenido parcial (206)

206 Partial Content es la respuesta a una petición de rango exitosa. Content-Range muestra la unidad (bytes), el rango devuelto y el tamaño total. Si el rango solicitado excede el recurso, el servidor devuelve 416 Range Not Satisfiable. If-Range hace condicional el rango: si el validador (ETag o fecha) coincide, devuelve 206; si el recurso cambió, devuelve 200 con el body completo — previniendo problemas de corrupción parcial.

http
# Single range request
GET /file.bin HTTP/1.1
Range: bytes=100-199

# 206 Partial Content
HTTP/1.1 206 Partial Content
Content-Range: bytes 100-199/1024
Content-Length: 100
Content-Type: application/octet-stream

<100 bytes>

# Content-Range format: <unit> <start>-<end>/<total>
# total can be "*" if unknown (streaming)

# If range is out of bounds:
# Range: bytes=1000-2000 on a 500-byte file ->
HTTP/1.1 416 Range Not Satisfiable
Content-Range: bytes */500

# If-Range: only return range if validator still matches
GET /file.bin HTTP/1.1
Range: bytes=0-1023
If-Range: "etag123"
# If etag matches: 206 (partial)
# If etag differs: 200 (full body, resource changed)

Peticiones multi-rango

Las peticiones multi-rango piden varios rangos de bytes en una sola petición. El servidor responde con multipart/byteranges — cada parte tiene su propio Content-Type y Content-Range. En la práctica, el multi-rango se usa poco: los clientes suelen emitir en su lugar peticiones de rango único en paralelo (más simple, más amigable con la caché, más fácil de recuperar de errores). Algunos servidores limitan el número de rangos o fusionan los solapados. Evita depender del multi-rango en caminos críticos.

http
# Request multiple ranges in one request
GET /file.bin HTTP/1.1
Range: bytes=0-99,200-299,400-499

# Server responds with multipart/byteranges
HTTP/1.1 206 Partial Content
Content-Type: multipart/byteranges; boundary=THIS_STRING_SEPARATES

--THIS_STRING_SEPARATES
Content-Type: application/octet-stream
Content-Range: bytes 0-99/1024

<100 bytes>
--THIS_STRING_SEPARATES
Content-Type: application/octet-stream
Content-Range: bytes 200-299/1024

<100 bytes>
--THIS_STRING_SEPARATES
Content-Type: application/octet-stream
Content-Range: bytes 400-499/1024

<100 bytes>
--THIS_STRING_SEPARATES--

# Most clients use single-range; multi-range is rare in practice.

Casos de uso del rango

Las peticiones de rango alimentan la búsqueda en vídeo (saltar a una marca de tiempo), las descargas reanudables (continuar tras una pausa), las descargas paralelas (los gestores de descarga dividen los archivos en fragmentos), la vista previa de páginas PDF y la lectura de metadatos guardados al final del archivo (etiquetas ID3). Para ello, el servidor debe soportar rangos y anunciarlo vía Accept-Ranges: bytes. Sin soporte de rangos, la búsqueda en vídeo degrada a descarga completa y las descargas reanudables son imposibles.

http
# 1. Video seeking (HTML5 <video>)
# Browser sends Range when user jumps to a timestamp
GET /video.mp4 HTTP/1.1
Range: bytes=5242880-    # seek to ~5MB offset

# 2. Resumable downloads
# Pause at 50%, resume later
GET /bigfile.zip HTTP/1.1
Range: bytes=524288000-  # continue from 500MB

# 3. Parallel downloads (download managers)
# Split file into N chunks, fetch concurrently
GET /bigfile.zip HTTP/1.1
Range: bytes=0-10485759      # chunk 1 (first 10MB)
# (parallel connection)
GET /bigfile.zip HTTP/1.1
Range: bytes=10485760-20971519  # chunk 2

# 4. PDF preview (load only visible pages)
GET /doc.pdf HTTP/1.1
Range: bytes=102400-204800   # specific page region

# 5. Streaming audio with metadata at the end
# Fetch ID3 tag without downloading the whole file
18

Gestión de sesiones

Sesiones basadas en cookies

Las sesiones basadas en cookies guardan una sesión del lado del servidor (en memoria, Redis o una base de datos) indexada por un ID de sesión aleatorio. La cookie contiene solo el ID. Ventajas: revocable (borra la sesión), cookie pequeña, maduro. Desventajas: con estado (el servidor debe guardar las sesiones), el escalado horizontal exige almacenamiento de sesiones compartido (Redis), vulnerable al CSRF (mitigar con SameSite). Lo mejor para apps web tradicionales con páginas renderizadas por el servidor.

http
# 1. User logs in
POST /login HTTP/1.1
Host: example.com
Content-Type: application/json

{"username": "alice", "password": "secret"}

# 2. Server validates, creates session, stores in DB/Redis,
#    returns session ID in a cookie
HTTP/1.1 200 OK
Set-Cookie: session=abc123; HttpOnly; Secure; SameSite=Lax

# 3. Subsequent requests carry the cookie
GET /dashboard HTTP/1.1
Cookie: session=abc123

# 4. Server looks up session ID, finds user, serves request
# 5. Logout: delete session server-side, expire cookie
POST /logout HTTP/1.1
Cookie: session=abc123

HTTP/1.1 200 OK
Set-Cookie: session=; Max-Age=0; Path=/

Sesiones basadas en tokens (JWT)

Las sesiones basadas en tokens (normalmente JWT) guardan el estado de la sesión EN el token. El servidor valida la firma sin consultar una base de datos — sin estado. Ventajas: escalable (sin almacén de sesiones), funciona entre servicios, amigable con móviles. Desventajas: no puede revocarse hasta la expiración (mitigar con access tokens de vida corta + refresh tokens guardados en el servidor), más grande que un ID de sesión, vulnerable al XSS si se guarda en localStorage. Lo mejor para APIs y SPAs.

http
# 1. Login returns a JWT (no server-side state)
POST /login HTTP/1.1

HTTP/1.1 200 OK
Content-Type: application/json
{"token": "eyJhbGciOiJIUzI1NiJ9..."}

# 2. Client stores token (memory, sessionStorage)
# 3. Each request includes the token in a header
GET /api/profile HTTP/1.1
Authorization: Bearer eyJhbGciOiJIUzI1NiJ9...

# 4. Server validates signature + claims, no DB lookup needed
# 5. Logout: client discards token (no server-side invalidation
#    until exp - this is the stateless tradeoff)

# Refresh token flow:
# - Short-lived access token (5-15 min)
# - Long-lived refresh token (days), stored server-side, revocable
# - When access token expires, exchange refresh token for new one

Sesión en headers

Las sesiones vía headers (Authorization, X-API-Key) son sin estado y funcionan para cualquier cliente (navegadores, móviles, CLI, servidor a servidor). El flujo de refresh-token maneja la expiración: los access tokens de vida corta limitan el radio de impacto de un token robado, mientras que el refresh token (guardado con seguridad, idealmente en una cookie HttpOnly) permite al cliente obtener nuevos access tokens sin volver a autenticarse. Detecta los refresh tokens robados vía rotación.

http
# Bearer token in Authorization header
GET /api/data HTTP/1.1
Authorization: Bearer eyJhbGc...

# Custom header (e.g., API gateway)
GET /api/data HTTP/1.1
X-API-Key: abc123def456

# Basic auth (per-request credentials)
GET /api/data HTTP/1.1
Authorization: Basic dXNlcjpwYXNz

# Bearer + refresh flow:
# 1. Access token expires -> API returns 401
HTTP/1.1 401 Unauthorized
WWW-Authenticate: Bearer error="invalid_token"

# 2. Client uses refresh token to get a new access token
POST /token HTTP/1.1
Content-Type: application/x-www-form-urlencoded

grant_type=refresh_token&refresh_token=GmR...

# 3. New access token returned
{"access_token": "...", "expires_in": 900}

Expiración y sesiones deslizantes

Políticas de expiración de sesión: absoluta (vida fija desde el login), deslizante (se reinicia con la actividad) o combinada (lo que ocurra primero). La combinada es la más segura — acota la longitud total de la sesión mientras permite un tiempo de inactividad razonable. Las cookies usan Max-Age; las sesiones del lado del servidor tienen un TTL aparte. Los JWT no pueden deslizarse — el claim exp queda fijo al emitirse. Para 'extender' un JWT, emite uno nuevo (flujo de refresh-token) en lugar de mutar el antiguo.

http
# Absolute expiration: session dies after fixed time from login
# e.g., 8 hours after login, regardless of activity
session.expires_at = session.created_at + 8h

# Sliding/Idle expiration: resets on each activity
# e.g., session dies after 30 min of inactivity
session.expires_at = NOW() + 30min   # updated on each request

# Combined (most secure):
# - Absolute cap (e.g., 24h max from login)
# - Idle timeout (e.g., 30min inactivity)
# Whichever comes first.

# Set-Cookie with Max-Age sets cookie lifetime,
# but server-side session may expire earlier (DB cleanup).
Set-Cookie: session=abc; Max-Age=1800  # 30 min

# JWT exp claim (absolute):
# {"exp": 1516242622}  # hardcoded, can't slide

Protección CSRF

Los ataques CSRF explotan que los navegadores envían cookies automáticamente. Las cookies SameSite (Lax por defecto en los navegadores modernos) bloquean la mayoría del CSRF al negarse a enviar cookies en POST entre sitios. El patrón del token CSRF añade un token generado por el servidor a los formularios y lo valida al enviar — los atacantes no pueden leer el token por la SOP. Las defensas de double-submit y de header personalizado añaden profundidad de defensa. Las APIs que usan tokens Bearer (sin cookies) son inherentemente inmunes al CSRF.

http
# CSRF (Cross-Site Request Forgery): attacker tricks the user's
# browser into sending a state-changing request using their cookies.

# Defense 1: SameSite cookies (modern default)
Set-Cookie: session=abc; SameSite=Lax   # blocks most CSRF
Set-Cookie: session=abc; SameSite=Strict # blocks all cross-site

# Defense 2: CSRF token (synchronizer pattern)
# Server embeds a random token in the form
<form action="/transfer" method="POST">
  <input type="hidden" name="csrf" value="randomtoken123">
  ...
</form>
# Server validates the token on POST

# Defense 3: Double-submit cookie
Set-Cookie: csrf=xyz
# JS reads cookie, includes value in a custom header
X-CSRF-Token: xyz
# (custom headers can't be sent cross-site without preflight)

# Defense 4: Require custom header on state-changing requests
# (browsers block cross-site custom headers without CORS preflight)
19

WebSocket

Actualización a WebSocket

WebSocket empieza como una petición HTTP con el header Upgrade. Si el servidor acepta, devuelve 101 Switching Protocols. Después, la misma conexión TCP habla el protocolo binario de WebSocket — full-duplex, con poca sobrecarga y sin sobrecarga HTTP por mensaje. El valor Sec-WebSocket-Accept (SHA-1 de la clave del cliente más un GUID fijo) prueba que el servidor actualizó intencionadamente. Origin permite al servidor autorizar la fuente de la actualización.

http
# Client initiates HTTP upgrade
GET /ws HTTP/1.1
Host: example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13
Origin: https://example.com

# Server accepts upgrade
HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

# After 101, the TCP connection is "upgraded" - HTTP is done.
# Both sides send WebSocket frames (binary protocol).

# Sec-WebSocket-Accept = base64(SHA1(key + magic GUID))
# Server must compute this to prove it understood the upgrade.

Handshake de WebSocket (cliente JS)

La API WebSocket del navegador es guiada por eventos: onopen se dispara tras el éxito de la actualización, onmessage en cada trama entrante, onclose al desconectarse, onerror ante fallos. Envía cadenas o binario (ArrayBuffer, Blob). Cierra con un código (1000 = normal) y un motivo. La conexión es full-duplex — ambos lados pueden enviar en cualquier momento. WSS (WebSocket Secure) usa TLS, equivalente a HTTPS.

http
# Browser client
const ws = new WebSocket('wss://example.com/ws');

ws.onopen = () => {
  console.log('connected');
  ws.send('Hello Server');
};

ws.onmessage = (event) => {
  console.log('received:', event.data);
};

ws.onclose = (event) => {
  console.log('closed:', event.code, event.reason);
};

ws.onerror = (error) => {
  console.error('error:', error);
};

# Send binary
ws.send(new ArrayBuffer(8));

# Close
ws.close(1000, 'normal closure');

Tramas WebSocket

Las tramas WebSocket son binarias: un bit FIN (fin de mensaje), opcode (texto/binario/close/ping/pong), bit de máscara (las tramas del cliente deben ir enmascaradas para evitar el envenenamiento de caché por intermediarios), longitud del payload y datos. Los códigos de close transmiten por qué terminó la conexión — 1000 es normal, 1006 es anormal (sin trama de cierre, a menudo una caída de red). Las tramas ping/pong mantienen la conexión viva y detectan pares muertos. Las tramas pueden fragmentarse en varias tramas.

http
# After the handshake, communication is via binary frames:
# - FIN bit (1 = final fragment of a message)
# - Opcode (4 bits): 0x1 text, 0x2 binary, 0x8 close,
#                    0x9 ping, 0xA pong
# - Mask bit (client->server frames are masked)
# - Payload length (7, 7+16, or 7+64 bits)
# - Masking key (4 bytes, client->server only)
# - Payload data

# Close codes:
# 1000  Normal closure
# 1001  Endpoint going away
# 1006  Abnormal closure (no close frame)
# 1008  Policy violation
# 1011  Internal server error
# 4000-4999  Application-defined

# Ping/Pong: keep-alive and liveness check
# Server: ping -> Client: pong (within timeout)

# Frames can be fragmented (FIN=0) and reassembled.

WebSocket vs HTTP

WebSocket es full-duplex y bidireccional, ideal para apps en tiempo real (chat, juegos, dashboards en vivo, edición colaborativa). HTTP es de petición-respuesta — el cliente pregunta, el servidor responde. Para actualizaciones unidireccionales de servidor a cliente, SSE es más simple (construido sobre HTTP, se reconecta solo, se lleva bien con los proxies). Para CRUD sin estado, HTTP/REST es lo correcto. WebSocket tiene la menor sobrecarga por mensaje pero el mayor coste de configuración (actualización, entramado).

http
# HTTP: request-response, half-duplex (client initiates)
# WebSocket: full-duplex, either side can send anytime

# Use HTTP when:
# - Client asks, server answers (CRUD APIs)
# - Stateless, cacheable resources
# - Occasional data fetches

# Use WebSocket when:
# - Real-time updates (chat, live sports, dashboards)
# - Bidirectional streaming (collaborative editing, gaming)
# - High-frequency, low-latency messaging
# - Server pushes events without client polling

# Alternatives:
# - SSE (Server-Sent Events): one-way server->client over HTTP
# - HTTP/2 streaming: server can push via DATA frames
# - Long polling: HTTP hack (client polls, server holds open)

# WebSocket has lower per-message overhead than HTTP.

Casos de uso de WebSocket

WebSocket brilla en apps bidireccionales en tiempo real: chat, dashboards en vivo, juegos multijugador, edición colaborativa, notificaciones y señalización WebRTC. El reto es escalar: un cliente se conecta a un servidor concreto, así que hacer broadcast entre los clientes conectados necesita un backend pub/sub (Redis, Kafka) para repartir entre instancias del servidor. Usa sesiones sticky en el balanceador, o diseña servidores sin estado que enruten los mensajes vía la capa pub/sub.

http
# 1. Chat application
# Client sends: {"type": "message", "text": "hi"}
# Server broadcasts to all connected clients

# 2. Live dashboard (stock prices, sports scores)
# Server pushes updates every second
# Client just listens

# 3. Multiplayer game
# Low-latency bidirectional: position, actions, events

# 4. Collaborative editing (Google Docs style)
# Operational Transform / CRDT messages both ways

# 5. Live notifications
# Server pushes: "you have a new message"

# 6. Voice/video signaling (WebRTC)
# WS carries SDP offers/answers before media flows over UDP

# Scaling WebSockets: sticky sessions or a pub/sub backend
# (Redis Pub/Sub, Kafka) so any server can reach any client.
20

Diseño de APIs REST

Nomenclatura de recursos

Los recursos REST son sustantivos (en plural: /users y no /user), con los verbos HTTP expresando la acción. No pongas verbos en las URLs (/createUser está mal — POST /users está bien). Los subrecursos expresan relaciones (/users/42/orders). Los parámetros de query manejan filtrado, ordenación y paginación — nunca los hornees en la ruta. Usa kebab-case para los segmentos de ruta de varias palabras (/password-resets, no /passwordResets). La consistencia es la regla más importante.

http
# Resources are nouns, pluralized
GET /api/users            # list users
POST /api/users           # create user
GET /api/users/42         # get user 42
PUT /api/users/42         # replace user 42
PATCH /api/users/42       # update user 42
DELETE /api/users/42      # delete user 42

# Sub-resources for relationships
GET /api/users/42/orders              # user 42's orders
GET /api/users/42/orders/1001         # specific order

# Use query params for filtering/sorting/pagination
GET /api/users?role=admin&sort=-created_at&page=2&limit=20

# Bad (verbs in URL):
POST /api/createUser     # should be POST /api/users
GET /api/getUser/42      # should be GET /api/users/42

# Good: nouns + HTTP methods express the action.

Verbos HTTP en REST

El mapeo CRUD REST estándar: POST=crear, GET=leer, PUT=reemplazar, PATCH=actualizar, DELETE=eliminar. GET/HEAD/OPTIONS son seguros (sin efectos secundarios). PUT y DELETE son idempotentes. POST no lo es (repetir crea duplicados). Para acciones que no encajan en CRUD (bloquear, archivar, enviar correo), usa un subrecurso con POST: /users/42/lock. Esta 'válvula de escape RPC' es pragmática — el REST puro no modela limpiamente toda operación.

http
# Standard CRUD mapping:
POST    /users         # Create (server assigns ID)
GET     /users         # List (with filtering/pagination)
GET     /users/:id     # Read one
PUT     /users/:id     # Replace (full update)
PATCH   /users/:id     # Update (partial)
DELETE  /users/:id     # Delete

# Safe (no side effects): GET, HEAD, OPTIONS
# Idempotent (repeatable): GET, HEAD, OPTIONS, PUT, DELETE
# Neither: POST (creates new resource each time)
# PATCH: idempotency depends on the patch format

# Custom "actions" on a resource (RPC-style escape hatch):
POST /users/42/lock      # lock the user (not pure REST)
POST /users/42/unlock
POST /users/42:lock      # Google AIP style
POST /users/42/actions/lock  # explicit escape hatch

Códigos de estado en REST

Usa los códigos de estado con semántica. 200 es el éxito genérico; 201 indica creación (con Location); 204 significa éxito sin body. 400 es una entrada malformada; 422 (WebDAV) está bien formada pero es semánticamente inválida (validación). 401 vs 403 es el par más confundido: 401 = '¿quién eres?', 403 = 'sé quién eres, pero no puedes hacer esto'. 5xx significa que el servidor la pifió — los clientes pueden reintentar con backoff. Sé consistente en toda tu API.

http
# Success (2xx)
200 OK              # generic success, returns data
201 Created         # POST/PUT created a resource (Location header)
202 Accepted        # async job queued (return job URL)
204 No Content      # success, no body (DELETE, PUT)

# Client errors (4xx)
400 Bad Request     # malformed input, validation failure
401 Unauthorized    # not authenticated (needs login)
403 Forbidden       # authenticated but lacks permission
404 Not Found       # resource doesn't exist
409 Conflict        # version conflict, duplicate
422 Unprocessable   # semantic error (well-formed but invalid)
429 Too Many Requests  # rate limited (Retry-After)

# Server errors (5xx)
500 Internal Server Error  # unexpected failure
503 Service Unavailable    # maintenance, overload

# Idempotency: 204 for DELETE/PUT is conventional.
# 201 vs 200 for POST: 201 if a resource was created.

Paginación

La paginación por página (offset/limit) es simple pero ineficiente en datasets grandes (OFFSET escanea las filas pasadas) e inestable (las inserciones nuevas desplazan filas). La paginación basada en cursor usa un token opaco que apunta al último ítem — estable ante inserciones concurrentes y rápida (búsqueda indexada en la columna del cursor). Usa cursor para scrolls infinitos y feeds grandes; usa página para UIs de administración que necesiten 'saltar a la página N'. El header Link (RFC 5988) es una forma estilo HATEOAS de exponer las URLs de paginación.

http
# Page-based (offset/limit)
GET /api/users?page=2&limit=20
# Response:
{
  "data": [...],
  "page": 2,
  "limit": 20,
  "total": 1000,
  "total_pages": 50
}

# Cursor-based (token, better for large/realtime datasets)
GET /api/users?cursor=abc123&limit=20
# Response:
{
  "data": [...],
  "next_cursor": "def456",
  "has_more": true
}

# Link header (RFC 5988):
Link: <https://api.example.com/users?page=3>; rel="next",
      <https://api.example.com/users?page=50>; rel="last"

# Pros of cursor: stable under inserts/deletes,
# faster on large datasets (no OFFSET scan).
# Cons: can't jump to arbitrary page.

Versionado de APIs

El versionado de APIs evita que los cambios que rompen compatibilidad dañen a los clientes existentes. El versionado por URI (/v1/, /v2/) es el enfoque más común y explícito — fácil de depurar, enrutar y cachear. El versionado por header mantiene las URLs limpias pero es más difícil de probar en un navegador. Al desaprobar, usa los headers Sunset y Deprecation (RFC 8594) para anunciar la fecha de fin de vida, da a los clientes tiempo suficiente (6-24 meses) y documenta la ruta de migración. Los cambios que no rompen compatibilidad (añadir campos opcionales) no necesitan subir versión.

http
# 1. URI versioning (most common, explicit)
GET /api/v1/users
GET /api/v2/users

# 2. Header versioning (cleaner URLs)
GET /api/users
Accept: application/vnd.example.v2+json

# 3. Custom header
X-API-Version: 2

# 4. Query parameter
GET /api/users?version=2

# Deprecation flow:
# - Mark old version as deprecated (Sunset header)
Sunset: Sat, 31 Dec 2025 23:59:59 GMT
Deprecation: true
# - Document migration guide
# - Maintain old version for a transition period (6-24 months)
# - Notify clients via email, response headers, logs
# - Eventually shut down the old version

# Breaking changes require a new major version.
# Non-breaking changes (adding fields) don't.

Buenas prácticas REST

Buenas prácticas REST: sustantivos en plural, verbos que expresan acciones, códigos de estado semánticos, paginación por defecto, filtrado vía query strings, formato de error consistente (RFC 7807 problem+json es el estándar) y enlaces de hipermedia para el descubrimiento (HATEOAS). Para endpoints POST que no son idempotentes naturalmente (pagos, creación de pedidos), acepta un header Idempotency-Key para que los clientes puedan reintentar con seguridad sin duplicar efectos — el servidor guarda la respuesta indexada por el UUID y la reenvía en los reintentos.

http
# 1. Use plural nouns: /users not /user
# 2. HTTP methods express actions (no verbs in URLs)
# 3. Status codes are semantic (201 for create, 404 for missing)
# 4. Pagination on list endpoints (default limit, max cap)
# 5. Filtering via query params: ?role=admin&active=true
# 6. Consistent error format (RFC 7807 problem+json):
HTTP/1.1 422 Unprocessable Entity
Content-Type: application/problem+json

{
  "type": "https://example.com/errors/validation",
  "title": "Validation failed",
  "status": 422,
  "detail": "Email is required",
  "instance": "/api/users",
  "errors": [{"field": "email", "message": "required"}]
}

# 7. Hypermedia (HATEOAS) links in responses (optional):
{"data": {...}, "_links": {"self": "/users/42", "orders": "/users/42/orders"}}
# 8. Idempotency keys for safe POST retries (Stripe pattern)
Idempotency-Key: client-generated-uuid

Was this helpful?

Learning path

Learn from scratch

Learn this language from the ground up with structured lessons.