HTTP has been around for decades, and most developers are already familiar with methods like GET, POST, PUT, and DELETE. These methods are the building blocks behind many of the websites, applications, and APIs we use every day. For simple tasks, they work remarkably well. But as modern applications handle more data and more complex searches, some use cases start to push these familiar methods a little further.

One example is querying data. A simple search can easily fit into a GET request, but things become more complicated when a query involves multiple filters, conditions, or large amounts of structured information. Developers often turn to POST in these situations because it allows them to place the query inside the request body. While this works, it does not clearly communicate that the request is meant only to retrieve information.

Meet QUERY: A New Way to Send Complex Queries

This is where RFC 10008 introduces something interesting: a new HTTP method called QUERY. Published in June 2026, QUERY is designed to make complex queries easier to send while keeping the request safe and idempotent, much like GET.

At first glance, QUERY may seem like another way of doing what POST already does. The key difference, however, is its purpose. POST can be used for many different operations, including ones that modify data, while QUERY is specifically designed for retrieving information without changing the target resource. It gives developers another option when GET starts to feel too limiting, without having to use POST for a task that is essentially read-only.

For anyone working with APIs, cloud applications, or networked systems, this small addition to HTTP could be worth paying attention to. And from an engineering perspective, it is also a good example of how communication protocols continue to evolve as the systems using them become more sophisticated.

Why do we need the QUERY method?

For a long time, GET has been the standard choice when retrieving information from a server. It works especially well when the query is simple:

GET /shirts?color=black HTTP/1.1
Host: shopdojo.com

There is nothing wrong with this approach. In fact, for simple requests, GET is still one of the most practical options. The challenge starts when a query becomes more complex. A search might need to include multiple filters, conditions, categories, or other pieces of information. As more parameters are added, the URL can quickly become long and difficult to read and manage.

For example, a simple search for products might look like:

GET /shirts?color=black&size=large HTTP/1.1
Host: shopdojo.com

This is still manageable. But if the search needs to include multiple certifications, different certification levels, update dates, and other conditions, the URL can become much more complicated:

GET /shirts?colors=black,white&sizes=small,medium,large&minPrice=20&maxPrice=100&material=cotton&inStock=true HTTP/1.1
Host: shopdojo.com

As queries grow, representing all of this information in a URL is not always the most convenient approach. This becomes even more noticeable when the query contains nested data, multiple values, or more advanced filtering conditions.

Using POST as a Workaround

One common solution is to use POST and place the query inside the request body. Instead of putting every parameter into the URL, the query can be represented as structured JSON:

POST /api/shirts/search HTTP/1.1
Host: shopdojo.com
Content-Type: application/json
{
"colors": [
"black",
"white"
],
"sizes": [
"small",
"medium",
"large"
],
"minPrice": 20,
"maxPrice": 100,
"material": "cotton",
"inStock": true
}

This is much easier to read and gives developers more flexibility when working with complex queries. However, there is a small issue: POST is a general-purpose method and can be used for many different operations, including operations that create or modify data. In this case, we are only trying to retrieve information. Using POST works, but the method itself does not clearly communicate that the operation is intended to be a safe, read-only query.

This is the gap that the new QUERY method is designed to address.

Meet the QUERY Method

RFC 10008 introduces QUERY as a method specifically designed for querying a resource while allowing the query itself to be included in the request content.

Using the same example, the previous request could instead be represented as:

QUERY /api/shirts HTTP/1.1
Host: shopdojo.com
Content-Type: application/json
Accept: application/json
{
"colors": [
"black",
"white"
],
"sizes": [
"small",
"medium",
"large"
],
"minPrice": 20,
"maxPrice": 100,
"material": "cotton",
"inStock": true
}

The difference may look small, but the meaning behind the request is important. QUERY is defined as a safe and idempotent HTTP method. In simple terms, it is intended to retrieve information without changing the state of the target resource, and repeating the same request should not cause additional changes to that resource.

This gives developers another option between GET and POST. GET remains a great choice for simple queries, while POST is still useful for operations that may create or modify resources. QUERY is designed for situations where the operation is read-only, but the query itself is too complex or too large to comfortably represent in a URL.

Why QUERY Matters for Modern Applications

The ability to place a structured query in the request body can be especially useful for applications that rely heavily on search and filtering. For example, a query could include multiple certifications, certification levels such as Foundational, Associate, Specialty, and Professional, date ranges, status filters, and other conditions without having to pack everything into a single URL.

More importantly, QUERY gives this type of request its own meaning at the HTTP level. Instead of relying on developers to know that a particular POST endpoint is only being used for searching, the method itself communicates that the request is intended to perform a query.

From an engineering perspective, this is also an interesting example of how communication protocols evolve as systems become more complex. As the amount and structure of information being exchanged increases, existing methods may not always be the best fit. QUERY adds another option to HTTP, giving developers a clearer way to communicate that a request contains a complex query while still being intended for safe data retrieval.

QUERY vs. GET vs. POST

Although GET, POST, and QUERY can all be used to send information between a client and a server, they have different purposes and HTTP semantics. Understanding these differences helps clarify what kind of operation a client is requesting.

To make the differences easier to see, let’s use our very own Tutorials Dojo Portal as an example. Imagine a user searching for practice exams based on certification, certification level, and status. The same type of query can be handled differently depending on the HTTP method being used.

GET is designed for retrieving a representation of a resource and is both safe and idempotent. Query parameters are commonly included in the URL, making GET a good choice for straightforward searches and filters:

GET /practice-exams?certification=SAA-C03&level=Associate HTTP/1.1
Host: portal.tutorialsdojo.com

POST, on the other hand, is more flexible. It can be used to submit data for processing, create resources, or perform other operations defined by the target resource. Unlike GET, POST is not inherently safe or idempotent. This is why it has sometimes been used for complex searches where the query needs to be placed in the request body:

POST /api/practice-exams/search HTTP/1.1
Host: tutorialsdojo.com
Content-Type: application/json
{
"certifications": [
"CLF-C02",
"SAA-C03",
"SAP-C02"
],
"levels": [
"Foundational",
"Associate",
"Professional"
],
"status": "active"
}

QUERY is designed for this particular use case. It allows the client to send query content in the request body while defining the method as safe and idempotent. This means complex queries do not have to be squeezed into a URL, while the method still communicates that the operation is intended for retrieving information.

The same query can therefore be represented using QUERY:

QUERY /api/practice-exams HTTP/1.1
Host: tutorialsdojo.com
Content-Type: application/json
Accept: application/json
{
"certifications": [
"CLF-C02",
"SAA-C03",
"SAP-C02"
],
"levels": [
"Foundational",
"Associate",
"Professional"
],
"status": "active"
}

The distinction becomes clearer when we look at what each method is communicating. GET essentially says that the client wants to retrieve a resource, with any query information commonly expressed through the URI. POST tells the server that the client is submitting content for processing, without making the same safety and idempotency guarantees. QUERY, meanwhile, specifically indicates that the client is sending a query and expects information to be returned without modifying the target resource.

This does not mean that QUERY will replace GET or POST. Simple queries will still be well suited to GET, while POST remains useful for operations involving submitted or modified data. QUERY simply provides another option when a query is complex enough to benefit from a request body but still needs safe and idempotent semantics.

Put simply, think of HTTP methods as different instructions given to a server. GET is like saying, “Give me this information.” POST is more like saying, “Here is some information; do something with it.“ QUERY is more specific: “Here are the details of what I’m looking for; give me the matching information.“ The important difference is what the HTTP method tells the server and the rest of the network about what the request is supposed to do.

Conclusion

The QUERY method gives developers a clearer way to handle complex searches over HTTP. It allows structured query data to be sent in the request body while keeping the request safe and idempotent. This gives applications another option when GET becomes difficult to use for detailed queries, without taking away the role of GET for simple requests or POST for operations that submit and process data.

More importantly, QUERY shows how good system design often comes from identifying gaps and finding a better way to handle them. Whether designing an API, building a networked application, or working with communication protocols, engineers need to consider how systems exchange information and whether existing approaches still meet their requirements. QUERY is a small addition to HTTP, but it reflects a larger idea: as systems evolve, the way they communicate must evolve with them.

References:

https://www.rfc-editor.org/info/rfc10008/

https://www.rfc-editor.org/rfc/rfc9110.html