Skip to content

Build2 publishers3 min readPublished

HTTP QUERY moves the search filter into the request body without giving up cacheability

The IETF published RFC 10008 in June 2026 and IANA registered QUERY as safe and idempotent, so a structured read no longer has to travel as a POST. Whether the response stays cacheable depends on the caches on the path.

The Engineer · Build desk

Illustration accompanying HTTP QUERY moves the search filter into the request body without giving up cacheability

What happened

  • The IETF published RFC 10008 in June 2026, a Standards Track document at Proposed Standard that defines an HTTP method called QUERY for sending a query description in the request body.
  • IANA registered QUERY as both safe and idempotent, the pairing that lets a client retry a failed request and lets a cache store the response it gets back.
  • InfoQ calls it the biggest addition to HTTP in sixteen years and the first new standard HTTP verb since PATCH arrived in 2010.
  • A server can advertise that it accepts the method through a new response field, Accept-Query, so a client does not have to find out by sending a request.
  • Support has been merged into the Rust http crate, and InfoQ says it is being tracked across .NET, Axum, Quarkus and Bruno.

Compiled by The EngineerSomething wrong?How this is made

Why it matters

  • constraint The cacheability only arrives once every cache on the path folds the request body into its key. CDN and proxy vendors deliver that benefit.
  • decision An API design review now has three methods to choose between instead of two, and because the RFC keeps GET for small parameter sets, somebody has to pick the size and shape at which an endpoint switches to QUERY.
  • capability A client library can retry a timed-out structured read automatically, which it could not do while that read was a POST that any intermediary had to treat as a write.
  • precedent With adoption expected to take years, public API contracts will carry both a QUERY path and a POST fallback for the same search, and both will need tests.

InfoQ's account attaches one condition to the cacheability: responses stay cacheable as long as the cache key incorporates the request content [5]. That is a change to how a cache computes a key. Method plus URI no longer identifies a request, because two QUERY requests to /orders can differ only in their bodies. Anything on the path that wants to serve a stored response has to look at the body before it can look anything up.

The gap being closed sits at the middlebox. RFC 10008 notes that an intermediary seeing only POST /orders/search cannot know the operation was designed to be read-only, because that knowledge lives inside the application contract [8]. POST is neither safe nor idempotent, so caches skip it, clients cannot safely retry it, and intermediaries must assume it changes state [7]. QUERY carries a body like POST while keeping the safe, idempotent and cacheable semantics of a read [21]. The RFC also lists why the alternative gets ugly: URI length limits differ between components on the request path, some structures are awkward to encode, URIs land in logs and browser history, and every distinct parameter combination becomes a different URI [10].

The workarounds still matter today. GraphQL and Elasticsearch already tunnel complex reads through POST bodies [12]. One Hacker News commenter, quoted by InfoQ, described how Cloudflare caches those reads: "Their unofficial support for caching POST requests is to create a fake GET request to serve as cache key and use that to cache the response. This is the kind of hacks everyone is forced to go through instead of using something like QUERY" [11].

The obvious cheaper fix was a body on GET. In an r/webdev thread that drew more than 800 upvotes, one developer asked "Why not allow an optional request body in GET?" [14]. Another answered: "Failing silently is the most obvious to deal with a body on GET. Good luck debugging which server down the line dropped your body..." [15]. The same developer wrote that "By having a new method you ensure the party supports the body." [16].

Julian Reschke, James Snell and Mike Bishop wrote the specification after Asbjorn Ulsberg reopened the question at the 2019 HTTP Workshop [4]. That is roughly seven years from the corridor conversation to publication [19]. InfoQ says real adoption will likely be measured in years, as it was for PATCH [18], and the specification advises treating QUERY as additive, because a new method has to be understood by clients, servers, proxies and caches before it is dependable [17].

So QUERY beats POST /search on a given path only when the client library sends the method, the server framework routes it, and the caches in between key on the body. Servers can signal the middle part with the new Accept-Query field [6]. RFC 10008 keeps GET for small queries [9], which leaves a design review three options and a threshold someone has to pick.

What to watch

  • Whether a major CDN ships body-aware cache keys for QUERY, given that InfoQ reports Cloudflare currently fakes a GET cache key to cache POSTs.
  • Movement from tracked to shipped in .NET, Axum, Quarkus and Bruno. That determines whether a team can route the method at all.
  • Whether Accept-Query shows up in default server configurations, so clients can discover support without sending a request that fails.
Loading claim ledger
Loading source directory links
Loading share composer
Loading topic controls
Loading related stories