El nuevo método HTTP QUERY (RFC 10008): guía de implementación

El 15 de junio de 2026 el RFC Editor publicó el RFC 10008, titulado "The HTTP QUERY Method". Se trata del primer método HTTP genuinamente nuevo desde que PATCH se estandarizó en 2010 (RFC 5789), es decir, dieciséis años sin que se añadiera nada al vocabulario base del protocolo. El documento es un Proposed Standard dentro del IETF Standards Track, redactado por Julian Reschke (greenbytes), James M. Snell (Cloudflare) y Mike Bishop (Akamai).

¿Qué problema resuelve QUERY?

Cualquier desarrollador backend termina topándose con el mismo dilema. Un endpoint de búsqueda empieza siendo simple, algo como GET /productos?categoria=laptops&marca=acme, y con el tiempo crece: filtros anidados, lógica AND/OR, rangos de fechas, ordenamiento por múltiples campos, coordenadas geográficas, selección dinámica de campos. Llega un punto en que la cadena de consulta (query string) ya no alcanza.

Ante eso existían dos opciones, ninguna satisfactoria:

• Seguir usando GET: la especificación HTTP no impone un límite formal de tamaño a la URL, pero en la práctica los servidores, proxies y CDNs suelen cortar alrededor de 8000 octetos. Además, meter estructuras JSON complejas o filtros anidados dentro de una URL es incómodo y propenso a errores de escape.
• Usar POST: soluciona el problema técnico del cuerpo de la petición, pero introduce uno semántico. Nada en el protocolo le dice a un caché, un proxy o una librería cliente que ese POST en particular es en realidad seguro de reintentar o de almacenar, porque POST siempre se define como potencialmente mutador de estado.

QUERY llena exactamente ese hueco: permite enviar un cuerpo de petición como POST, pero conservando las garantías de seguridad e idempotencia de GET.

Comparación GET vs POST vs QUERY

Sintaxis básica de una petición QUERY

Una petición QUERY se ve así:

QUERY /feed HTTP/1.1 Host: ejemplo.org Content-Type: application/x-www-form-urlencoded q=gatos&limit=10&sort=-published

Igual que en POST, la entrada de la operación va en el cuerpo de la petición, no en la URI. A diferencia de POST, el método es explícitamente seguro e idempotente, lo que habilita comportamientos como reintentos automáticos ante fallos de conexión y almacenamiento en caché.

Un ejemplo típico con JSON, como el que se usaría para exponer una consulta de tipo GraphQL:

QUERY /api/buscar HTTP/1.1 Host: api.ejemplo.com Content-Type: application/json Accept: application/json {  "usuarios": {    "rol": "admin",    "campos": ["id", "nombre", "email"]  } }

Y la respuesta correspondiente:

HTTP/1.1 200 OK Content-Type: application/json Content-Location: /api/buscar/resultados/a7f3 {"data":{"usuarios":[{"id":"1","nombre":"Ada","email":"ada@ejemplo.com"}]}}

La cabecera Accept-Query

El RFC 10008 introduce la cabecera de respuesta Accept-Query, que permite a un servidor anunciar qué formatos de contenido acepta para consultas QUERY en ese recurso, del mismo modo en que Allow anuncia qué métodos soporta un recurso. Un servidor puede así responder algo como:

HTTP/1.1 200 OK
Allow: GET, HEAD, OPTIONS, QUERY
Accept-Query: application/json, application/x-www-form-urlencoded

Esto le permite a un cliente descubrir, antes de enviar la petición, si el recurso soporta QUERY y qué tipos de contenido acepta en el cuerpo.

Puntos clave que un programador debe implementar

• Enrutamiento del método: el servidor debe registrar QUERY como un verbo HTTP más, separado de GET y POST, en su router o framework.
• Negociación de contenido: el servidor procesa el cuerpo de la petición según su Content-Type (JSON, form-urlencoded, GraphQL, etc.) y debe anunciar los formatos soportados vía Accept-Query.
• Recurso equivalente: el servidor puede asignar una URI a una consulta concreta o a su resultado, para que un cliente pueda repetir esa misma consulta luego con un GET simple, usando las cabeceras Content-Location o Location en la respuesta.
• Peticiones condicionales: QUERY soporta cabeceras condicionales como If-None-Match o If-Modified-Since, igual que GET.
• Rango de bytes: también soporta Range y respuestas parciales (206), igual que GET.
• Caché: como es cacheable, cualquier caché frente al servidor (CDN, proxy, caché de aplicación) debe incluir el cuerpo de la petición dentro de la clave de caché, no solo la URL. Si no lo hace, se abre la puerta a "cache poisoning" o "cache deception": la respuesta cacheada para la consulta de un usuario podría entregarse a otro usuario con una consulta distinta.

Ejemplo de implementación en Node.js (Express)

Node.js soporta el parseo nativo de peticiones QUERY desde principios de 2024, así que en Express basta con registrar la ruta usando el verbo correspondiente:

const express = require('express');
const app = express();

app.use(express.json());

// Express 5 / versiones recientes permiten .query() como verbo de ruta.
// Si tu versión no lo soporta de forma nativa, usa app.use con
// una comprobación manual de req.method === 'QUERY'.

app.query('/buscar', (req, res) => {
  const filtros = req.body; // { rol: "admin", campos: [...] }

  const resultados = buscarUsuarios(filtros);

  res.set('Content-Location', '/buscar/resultados/' + resultados.id);
  res.json(resultados);
});

app.listen(3000);

Si el framework que usás todavía no expone un helper específico para QUERY, podés interceptarlo manualmente a nivel de middleware:

app.use((req, res, next) => {  if (req.method === 'QUERY') {    // tratarlo como una lectura segura con cuerpo  }  next(); });

Ejemplo de petición desde el cliente

Con curl:

curl -X QUERY https://api.ejemplo.com/buscar \
  -H "Content-Type: application/json" \
  -d '{"rol":"admin","campos":["id","nombre"]}'

Con fetch en el navegador (con la advertencia de que, a julio de 2026, el soporte de QUERY en navegadores todavía está en evaluación y no está garantizado en todos los motores):

const respuesta = await fetch('/buscar', {  method: 'QUERY',  headers: { 'Content-Type': 'application/json' },  body: JSON.stringify({ rol: 'admin', campos: ['id', 'nombre'] }) }); const datos = await respuesta.json();

Un detalle importante: QUERY no está en la lista de métodos "safelisted" de CORS, así que cualquier llamada desde JavaScript en el navegador hacia otro origen va a disparar una petición preflight (OPTIONS), igual que pasaría con un método personalizado.

Estado del soporte a julio de 2026

Consideraciones de seguridad e infraestructura

Adoptar un método nuevo no es solo un cambio de código de aplicación. Cualquier pieza de infraestructura que tome decisiones en base al nombre del método HTTP necesita actualizarse a propósito:

• WAFs, API gateways y balanceadores de carga suelen tener listas fijas de métodos permitidos (típicamente GET, POST, PUT, DELETE, PATCH). Las reglas escritas antes de junio de 2026 no saben qué hacer con QUERY: algunas lo van a rechazar directamente, otras lo van a enrutar o inspeccionar de forma distinta a como tratarían un POST al mismo path.
• Cachés y CDNs deben incluir el cuerpo de la petición en la clave de caché. Un caché que normalice o hashee el cuerpo de forma incorrecta puede terminar sirviendo la respuesta de un usuario a otro con una consulta diferente.
• Middleware de CSRF construido asumiendo una lista fija de métodos "seguros" puede no cubrir QUERY correctamente. Vale la pena revisar explícitamente si las políticas de CSRF contemplan QUERY a propósito, no por accidente.

Checklist antes de exponer QUERY en producción

• Confirmar que el framework de backend puede enrutar QUERY (revisar la versión exacta, no solo el nombre del framework).
• Confirmar que el WAF, el API gateway y el CDN entienden el método o están configurados para dejarlo pasar de forma deliberada.
• Confirmar que la capa de caché construye la clave de caché a partir del cuerpo completo de la petición, no solo de la URL.
• Confirmar que el middleware de protección CSRF cubre QUERY de forma explícita.
• Confirmar que las librerías HTTP y SDKs usados por los clientes soportan QUERY, o preparar una ruta de respaldo (fallback) hacia POST.

Estrategia de adopción recomendada

La recomendación práctica no es reemplazar de golpe los endpoints existentes. Lo razonable es mantener el endpoint POST /buscar que ya funciona, agregar un endpoint QUERY equivalente al lado, anunciar el soporte a través de la cabecera Accept-Query, y dejar que los clientes migren a su propio ritmo a medida que sus herramientas lo soporten, en lugar de forzar un corte abrupto que rompa a quien todavía espera POST.

Resumen

QUERY no reemplaza ni a GET ni a POST: cubre específicamente el caso de lecturas seguras que necesitan un cuerpo de petición. Para APIs servidor a servidor y backends en Node.js, ya es viable usarlo hoy. Para tráfico público desde navegador conviene tratarlo todavía como algo temprano, dado que el soporte de fetch() sigue en evaluación y el método dispara preflight de CORS. El respaldo formal es fuerte: RFC 10008 está en el IETF Standards Track, el mismo nivel que HTTP/1.1, HTTP/2 y HTTP/3.