An Evolution in HTTP: The QUERY Method

What this article contains:

• What is QUERY?
• Why need a new method?
• HTTP Foundation
• Terminology: Cache Server and Idempotent
• Working of the QUERY Method
• Comparing GET, POST and QUERY Methods
• The Practical Demonstration of the QUERY Method
• Can the QUERY Method replace the GET Method?
• Future with the QUERY Method
• Conclusion

What is QUERY?

QUERY is a new HTTP method, such as GET, POST, PUT, DELETE, etc. It was officially introduced in June 2026 under RFC 10008.

Why need a new method: QUERY?

We all know how big and complex the internet is. When we talk about internet communication, there are two major protocols used for establishing communication between two internet entities.

1. Transmission Control Protocol (TCP)
2. User Datagram Protocol (UDP)

These both protocol works on the Transport Layer of the TCP/IP Model, whose main task is to establish a communication channel between the two entities and allow communication.

The HTTP Foundation

Whereas the Hypertext Transfer Protocol (HTTP) is an Application Layer Protocol, which works on TCP. HTTP is used for web communication and allows transmission of data in the form of hypertext files and documents such as (.html, .css, .js files).

HTTP uses a specific standard that follows a structured way for communication, which we call an HTTP Packet. This packet follows a specific structure in which the HTTP Request and HTTP Response are made, which essentially allows communication.

Each HTTP Packet includes the HTTP method and the resource the user wants to access. The HTTP methods can be GET, POST, PUT, PATCH, DELETE, etc.

We will be focusing on the Two Methods: GET and POST

• The GET method is used to fetch or request a resource from the server.
• The POST method is used to create a change on the server (such as sending data for creation)

Cache Servers & Idempotent

Now, imagine a user is frequently requesting the same resource or URL. In such a case, the server has to process each request, fetch data from the database and deliver the resource to the user.

This may cause low server performance, delaying responses and increasing traffic load.

To handle such problems, we introduced Cache Servers. Now, frequently asked requests & responses are stored in cache servers. So that whenever a user requests a resource, it first goes to the cache server. If it contains the resource, it directly sends the response to the user without even sending it to the server.

This solves all the problems. But here is the catch. Not every request can be cached into the CND/Cache Server. The request's ability to be cached into the Cache Server is called "Idempotent".

Not every request can be cached. Only GET Method requests can be cached, not POST Method requests.

Now the real problem comes in: the GET method request's parameters are shown directly in the URL, exposing sensitive data. Besides, GET Method requests have a length limit that depends on the browser.

The legacy browser (Internet Explorer) can only process a GET Request with ~2000 characters, which becomes the baseline. But in the modern internet era, if you closely look at the URLs, you can notice that URLs are becoming lengthy and complex.

To solve this problem, developers used a simple hack. They started using POST requests to fetch the resources from the server. This solves the above problem too: the sensitive data is hidden, and there is no limit to the parameters.

Now, another problem comes. You cannot cache a POST Request into cache server. Because a POST method represents creation or change on the server. This way, the whole logic changes.

For many years, we have been using this trick and breaking the logic. But finally, in June 2026, the New HTTP method was introduced: The QUERY Method.

Working of the QUERY Method

The QUERY method can be considered a combination of the GET and POST methods.

It combines both features,

• The requesting parameters are not revealed in the URL.
• The requesting parameters are passed into the body of the QUERY method, which hides the sensitive data, preventing it from being leaked and also solves the length limit of the parameters.

Also, the QUERY method is "Idempotent", which means it can be cached. This solves all the problems and also does not break the rules.

Comparing QUERY with GET and POST Requests.

There is a condition in the QUERY Request stated in RFC 10008.

You can read the official release doc here: https://www.rfc-editor.org/info/rfc10008/

The Practical Demonstration of the QUERY Method

Let's see the practical demo of the QUERY Method.

You can visit: https://httpquery.com/test/

Once you open the link, you can see the screen below.

Here you can apply many filters and see how the request looks in GET, POST and QUERY requests.

You can see the difference:

• In the GET Request: The parameters are being revealed in the URL
• In the POST Request: The parameters are being transferred in JSON format in the request body.
• In the QUERY Request: It looks the same as the POST Request. Hides the parameters in the request body. The main difference here is: It can be cached.

Can the QUERY Method replace the GET Method?

After all of this, some of you may have the above question, and even I was one of you too. But when I researched a bit, I found something interesting.

You can't bookmark the QUERY Method Requests.

There is a simple logic behind it. Browsers only store the request URL when you bookmark something. If any request parameters are in the request body, browsers cannot save those parameters in the bookmark.

So, the GET Method cannot be replaced.

The Future with the QUERY Method

We have understood everything; now what's the future?

Surely, it's just new and may change a lot, as we found security gaps in the QUERY Method.

So definitely this becomes a honey for bug bounty hunters.

Apart from this, Industries will soon start utilising the QUERY Method. This may affect both negatively and positively.

• Negatively, because it's new and may find security issues very soon.
• Positively, because it reduces traffic load, maintains the internet logic, and prevents sensitive data from being leaked.

Conclusion

So, here is the conclusion.

As the Internet is growing, things are becoming larger and more complex. To deal with all of this, we have to keep things simple, clean and logically and practically true.

It's just the beginning; in future, this may lead to another evolution.

What's your opinion on this?

Feel free to discuss things in the comments below.

Give me feedback on this article and share this in your group circles, so others won't miss the internet evolution.

Hit the clap if you found this article informative.