Skip to content

Build Independently confirmed2 publishers 3 min read Published Updated

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

Send a correction

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

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.

Why it matters

  • What it limits 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.
  • Who has to decide 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.
  • What's now possible 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.
  • What it sets up 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 [3]. 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 [6]. POST is neither safe nor idempotent, so caches skip it, clients cannot safely retry it, and intermediaries must assume it changes state [5]. QUERY carries a body like POST while keeping the safe, idempotent and cacheable semantics of a read [9]. 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 [11].

The workarounds still matter today. GraphQL and Elasticsearch already tunnel complex reads through POST bodies [19]. 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" [21].

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?" [13]. 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..." [14]. The same developer wrote that "By having a new method you ensure the party supports the body." [15].

Julian Reschke, James Snell and Mike Bishop wrote the specification after Asbjorn Ulsberg reopened the question at the 2019 HTTP Workshop [18]. That is roughly seven years from the corridor conversation to publication [20]. InfoQ says real adoption will likely be measured in years, as it was for PATCH [8], 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 [7].

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 [4]. RFC 10008 keeps GET for small queries [10], 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.

Clarity's read

What the record supports and how the coverage leans. The claims behind it follow.

Reality

Evidence68
Adoption15
Hype gap+5
Incentives
Not scored
Confidence65
Why these scores

Claim ledger

Ranked by verification strength, evidence, and original report placement.

  1. [1]

    In June 2026 the IETF published RFC 10008, The HTTP QUERY Method, a Standards Track document classified as a Proposed Standard.

    Reported SupportedView cited source
  2. [2]

    The new QUERY method was officially registered by IANA as both safe and idempotent.

    Reported SupportedView cited source
  3. [3]

    Responses stay cacheable as long as the cache key incorporates the request content.

    Reported SupportedView cited source
  4. [4]

    Servers can advertise support for QUERY through the new Accept-Query field.

    Reported SupportedView cited source
  5. [5]

    A POST can carry a rich body but is neither safe nor idempotent, so caches skip it, clients cannot safely retry it, and intermediaries must assume it changes state.

    Reported SupportedView cited source
  6. [6]

    If an intermediary sees only POST /orders/search it cannot know the operation was designed to be read-only; that knowledge lives inside the application contract.

    Reported SupportedView cited source
  7. [7]

    The specification advises treating QUERY as additive rather than a wholesale replacement, and new methods are rare because each one has to be understood by clients, servers, proxies and caches before it becomes dependable in practice.

    Reported SupportedView cited source
  8. [8]

    InfoQ reports that, like PATCH before it, real adoption of QUERY will likely be measured in years.

    Reported SupportedView cited source
  9. [9]

    QUERY is a request that carries a body like POST while keeping the safe, idempotent and cacheable semantics of a read.

    Reported SupportedView cited source
  10. [10]

    RFC 10008 itself makes the point that small queries are still likely better expressed using GET.

    Reported SupportedView cited source
  11. [11]

    RFC 10008 points out that different components along the request path may enforce different URI length limits, that some structures are inefficient or awkward to encode in a URI, that URIs are more likely to appear in logs, browser history and bookmarks, and that every distinct parameter combination effectively becomes a different URI.

    Reported SupportedView cited source
  12. [12]

    Tooling support has been merged into the Rust http crate and is tracked across .NET, Axum, Quarkus and Bruno.

    Reported SupportedView cited source
  13. [13]

    In an r/webdev thread that drew more than 800 upvotes, one developer asked: "Why not allow an optional request body in GET?"

    Reported SupportedView cited source
  14. [14]

    Another developer wrote: "Failing silently is the most obvious to deal with a body on GET. Good luck debugging which server down the line dropped your body..."

    Reported SupportedView cited source
  15. [15]

    The same developer wrote: "By having a new method you ensure the party supports the body."

    Reported SupportedView cited source
  16. [16]

    A Hacker News commenter wrote: "Just because it works, doesn't mean its the right way"

    Reported SupportedView cited source
  17. [17]

    QUERY is the first new standard HTTP verb since PATCH landed in 2010, and the biggest addition to HTTP in sixteen years.

    Reported SupportedView cited source
  18. [18]

    RFC 10008 was authored by Julian Reschke, James Snell and Mike Bishop after a conversation that Asbjorn Ulsberg reopened at the 2019 HTTP Workshop.

    Reported SupportedView cited source
  19. [19]

    GraphQL and Elasticsearch already tunnel complex reads through POST bodies, and QUERY offers a standards-based alternative that keeps those reads cacheable.

    Reported SupportedView cited source
  20. [20]

    Roughly seven years passed between the 2019 HTTP Workshop conversation and the June 2026 publication of RFC 10008.

    Derived Supported
  21. [21]

    A Hacker News commenter wrote of Cloudflare: "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"

    Reported InsufficientView cited source

Sources

2 independent publishers whose own reporting we read for this story.

  1. dev.to

    3 articles · September 10, 2026

    nginx silently rejects the new HTTP QUERY method
  2. infoq.com

    1 article · September 9, 2026

    IETF Publishes RFC 10008, Adding the QUERY Method for Safe Requests With a Body

Topics and entities

Topics