HTTP Headers

Priority header

HTTP Header

The HTTP Priority header signals a client’s preferred order for sending a requested resource’s response, relative to other requests on the same connection. If this header is absent from a request, a default priority is used. A server might also include this header in its responses to express an interest in altering the client’s advertised prioritization preferences. When present in responses, this information can serve as an input for the prioritization process on caching servers and other servers that forward the response.

Servers are not obligated to follow client-side prioritization and may only use client priorities as suggestions for their internal prioritization process. For instance, a server might recognize that a particular image is critical for user experience and should be delivered with the highest priority. Server prioritization can also be influenced by factors like network congestion.

This request can be cached, and the server is expected to manage the cacheability or relevance of the cached response using header fields that govern caching behavior, such as Cache-Control and Vary.

Header type	Request header, Response header
Forbidden request header	No

Syntax

Priority: u=<priority>
Priority: i
Priority: u=<priority>, i

Directives

u=<priority>

The u=<priority> parameter defines the importance level of a specific resource. This value is represented by an integer ranging from 0 to 7, where 0 represents the highest level of urgency. Generally, requests carry a default value of 3. If a server response does not include this header, it suggests that the server is adhering to the client’s original priority settings. A priority of 7 is typically reserved for non-essential tasks, such as software updates or background synchronization.

Browsers usually initiate requests for primary documents using the standard priority level. Subsequent resources are then requested with values that reflect how critical they are to the user’s immediate experience. While clients set the initial priority, servers can provide a different value to assist intermediate systems in managing traffic. If the Priority header is missing from a response, the intermediate server will simply follow the client’s initial instructions.

i

The i directive indicates whether a response is capable of being processed incrementally.

When a resource is marked for incremental processing, the recipient can begin using parts of the data as soon as they arrive, rather than waiting for the entire file to download. If a browser enables this setting, the server may deliver multiple incremental requests at once, sharing the available bandwidth. This allows all involved tasks to begin sooner, even if they take longer to finish individually.

Conversely, if this directive is not set, the browser is signaling that it cannot process the data in parts. In these instances, servers should deliver responses one at a time, following the sequence in which the requests were made.

Example

Adjusting Resource Importance

:method = GET
:scheme = https
:authority = example.net
:path = /index.html

The following request represents a typical follow-up for a CSS file. Here, the priority is set to 2, marking it as a high-priority resource. The incremental directive is omitted, however, as CSS cannot be rendered in parts.

:method = GET
:scheme = https
:authority = example.net
:path = /style.css
priority = u=2

Note: The snippets above use the text-based formatting common in HTTP/2 and HTTP/3. For those using the HTTP/1.1 protocol, the header structure would look like this:

GET /style.css HTTP/1.1
Host: example.net
Priority: u=2

A server response might look like the one below. In this instance, the priority header is absent, which tells intermediate servers that the original priority set by the client should remain unchanged.

:status: 200
content-type: text/css
content-length: 610
date: [current date]

Applying the Incremental Directive

:method = GET
:path = /image.jpg
:scheme = https
:authority = example.net
priority = u=4, i

The server may reply with a response similar to the one below. In this scenario, the server has assigned an urgency of 1, indicating that this particular image is critical and should be treated with high priority.

:status: 200
content-type = image/jpeg
content-length = 610
...
priority = u=1, i

How to Modify Header using Requestly

Requestly is a powerful Chrome extension that allows you to modify HTTP headers, including the Priority header. This header is used to indicate the relative importance of a request, helping servers and intermediaries decide how to prioritize resource delivery. It is especially useful when testing performance optimization and resource loading behavior during development or debugging. Steps to Modify the Priority Header:

Install and open the Requestly Chrome extension. You can find it on the Chrome Web Store.
Create a new rule: Click on “Create Rule” and choose “Modify Headers” from the list of available rule types.
Add a new header modification:
- Under “Action”, select “Add” or “Override”.
- In the “Header Name” field, enter Priority.
- In the “Header Value” field, enter the priority parameters (for example, u=1, i).
Set the URL condition: Specify the URL or pattern where this header should apply (for example, https://your-website.com/*).
Save the rule.

Once configured, Requestly will inject the Priority header into all matching requests. This allows you to simulate different request importance levels and observe how your server or CDN handles them.

You might need to modify the Priority header to test resource scheduling, optimize page load performance, or debug delivery behavior without changing your production server configuration. This helps ensure critical assets are served efficiently.