QUERY: a new kind of web request for big questions

Try it

A wholesale customer pastes their order list into your shop to check what is in stock. Drag the slider to make the list longer and watch what happens to the request on its way to your server.

Somewhere past 120 items, the first server says no.

A question written on the outside

Most websites and apps ask their questions with a GET request, the same kind your browser sends to open a page. The question goes into the web address itself, after the question mark: /api/stock?sku=KO-10000-BLK&sku=…. That part of the address is called the query stringQuery stringThe part of a web address after the question mark, such as ?colour=red&size=10, that carries the details of a search..

For a short search that works well. But every server, proxy and CDNCDNA content delivery network: servers around the world that sit in front of your site, keep copies of its answers and hand them out quickly. between your customer and your shop sets its own limit on how long an address may be, and nobody can know them all in advance. When a question grows past one of them, the request is turned away before your shop ever sees it.

Addresses also travel further than most people expect. They end up in server logs, analytics tools, browser history and bookmarks. A search for a customer by name, or the list of what a business is ordering, is written on the outside for every system on the way to keep.

Why not use an envelope?

The usual way around this is to send the question in the body of the request, like a letter in an envelope. Developers do that with a POST request, the kind a web form sends when someone places an order or signs up.

The catch is what POST tells every system on the way: this request may change something. So a cacheCacheA store of recent answers kept close to the visitor, so the same question can be answered again without asking your server. will not keep the answer, and nothing sends the request again on its own after a dropped connection, in case your customer ends up with the same order twice. A question that only reads stock levels gets treated like an order.

There is a third trick, a GET request with a body. The HTTP standard says such a body has no defined meaning, so servers and proxies may ignore it or refuse the request, and browsers will not send one at all.

What QUERY changes

QUERY is a new HTTP methodHTTP methodThe verb at the start of every web request that says what it wants: GET to fetch something, POST to send something, and now QUERY to ask a question., published as a standard in June 2026. It sends the question in the body, like POST, and makes the same promise GET makes: asking changes nothing on the server.

That promise is the whole point. Because QUERY is marked safe and idempotentIdempotentA request that has the same effect whether it is sent once or five times, so software can safely send it again after a dropped connection., a cache may keep the answer and hand it out the next time the same question comes in, and software may send the request again after a dropped connection without risk. The address stays short, /api/stock, and the order list stays out of logs and history.

The code

QUERY /api/stock HTTP/1.1
Host: shop.example
Content-Type: application/json
Accept: application/json

{ "skus": ["KO-10000-BLK", "KO-10037-RED"], "warehouse": "BNE" }

import { createServer } from 'node:http'

createServer(async (req, res) => {
  if (req.method !== 'QUERY' || req.url !== '/api/stock') {
    res.writeHead(404).end()
    return
  }
  const type = req.headers['content-type']?.split(';')[0].trim()
  if (type !== 'application/json') {
    res.writeHead(415, { 'Accept-Query': 'application/json' }).end()
    return
  }
  let body = ''
  for await (const chunk of req) body += chunk
  let skus
  try {
    ;({ skus } = JSON.parse(body))
  } catch {
    res.writeHead(400).end()
    return
  }
  // stockFor() is your own lookup; it only reads.
  const stock = await stockFor(skus)
  res.writeHead(200, {
    'Content-Type': 'application/json',
    'Cache-Control': 'max-age=60',
  })
  res.end(JSON.stringify(stock))
}).listen(3000)

const response = await fetch('/api/stock', {
  method: 'QUERY',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({ skus, warehouse: 'BNE' }),
})

Can you use it yet?