The Server-Timing Header It transmits self-collected backend metrics via an HTTP response. You can associate them with the respective request in the browser’s DevTools or retrieve them via the Performance API. This requires that the application or another responding component collect and output the values. The header is not an automatic profiler: Only documented measurement boundaries indicate the work involved in a given duration. Overlaps, network paths, and cached responses can alter the interpretation.
What Server Timing Reveals
A slow page can lose time in the browser, during network transmission, or during processing on the server. The Server-Timing Header combines these perspectives: It transmits metrics that a participating server component has collected itself, along with an HTTP response. The browser can then associate them with the corresponding request and display them.
To do this, for example, the application must measure the duration of a database operation and include that value in the response header. A proxy or other component that generates a response can also provide metrics. Without such instrumentation, the browser cannot determine afterward how long individual server-side steps took.
The header is therefore a Transport Format, not an automatic profiler. It does not specify which internal functions are analyzed or how much detail an application must measure. The metrics that appear depend on what the responsible component collects and releases for output.
For the Backend Performance This is helpful because a section you measure yourself appears right next to the information about the browser request. A high value is initially a starting point for further investigation, but it is not yet proof of why a page is slow. The metric alone explains neither the cause nor all other factors affecting web performance.
For practical use, you therefore need access to the application or another component that can influence the response. If metrics are already provided, however, you can examine them in the browser without having to change the server configuration yourself. Even then, you should clarify where the values come from and what they actually represent.
Understanding Metrics and Header Syntax
An HTTP response may contain one or more Server-Timing header lines. Within a line, commas separate the individual metrics; a semicolon introduces each parameter. Each metric requires a name, while duration and description are optional. A reported duration is specified in the parameter dur and is measured in milliseconds.
The following example shows an HTTP response header line with two metrics. The numbers are arbitrary and do not represent actual measurements; the line is merely a syntax example and does not assume any specific application or server configuration.
Here, this refers to db a metric with duration and description; render has a duration but no description. The information according to desc are provided for explanatory purposes. They do not replace documentation specifying when each measurement begins and ends.
| Component | Meaning | Mandatory Status | Example |
|---|---|---|---|
| Name | Refers to the metric | Required | db |
| dur | Duration in milliseconds | Optional | dur=42.5 |
| desc | Description of the Metric | Optional | desc="Database" |
A name like db in and of itself does not reveal the Measurement Limits nor the measurement method. It could refer to a single query, multiple queries aggregated together, or a differently defined database section. Only by documenting the instrumentation can one understand what work is actually included in the value.
To ensure meaningful comparisons, you should therefore record the start and end points for each metric and describe whether it includes additional sub-operations. For example, if the name remains the same but the application later includes additional queries in the time frame, old and new values are not readily comparable. The syntax alone does not indicate such a change.
Distinguish Between Backend Duration and Browser Wait Time
The wait time visible in the browser and a reported backend duration do not necessarily describe the same time period. A metric may capture only a deliberately selected portion of the processing, while the browser view depicts other parts of the request-response path. Similar or different numbers therefore do not automatically mean that the two measurements confirm or contradict each other.
Network paths and proxies, for example, may lie between the browser and the application. Queues or processing steps within the backend may also fall outside the defined measurement points. If the browser waits longer than the reported duration of a database operation, the difference cannot therefore be attributed to a specific cause based on this single metric alone.
Conversely, server timing metrics can overlap or be nested within one another. If an overall metric measures the processing of a request, including the database operation, the duration of that operation is already included in the total value. If you add both numbers together, you’re counting this section twice; for operations executed in parallel, the sum of their individual durations may also be greater than the elapsed time.
The header therefore does not automatically form a complete Waterfall processing. It provides specific metrics, but the names and durations alone do not establish either a chronological order or relationships between the sections. To interpret the data, you need to know whether the instrumentation captures separate, nested, or concurrent tasks.
Before drawing conclusions about an optimization, document the measurement limits and conditions of the query in question. Then repeat similar queries and check whether the pattern reappears under the same conditions. This will help you better distinguish between a single outlier and a recurring trend, without attributing a cause to the metric alone.
Check the HTML response in DevTools
For a dynamic HTML page, the application can break down the process into two separate steps: a database operation and the subsequent generation of the HTML. The measurement must be set up in the application or another component that returns a response. DevTools displays the returned values but does not calculate the internal execution times itself.
Define for db the start, immediately before a specific database operation is called, and the end, as soon as its result is available in the application. For render This time period begins immediately before the HTML is generated and ends as soon as the finished HTML is ready for the response. Document whether, for example, the loading of templates is included in this time period.
Assuming both steps are completed before the response headers are sent, then the response could Server-Timing: db;dur=42.5, render;dur=18.0 included. The numbers are arbitrary and do not represent actual measurements. Only the documented starting and ending points make them meaningfully comparable for later analysis.
In Chrome, open the Developer Tools and go to the Network tab. Reload the page, select the document request from the request list, and check the raw header under "Headers." Under "Timing," you can then view the reported server timing values; the exact display may vary depending on the browser.
A striking Individual value This is a starting point, not proof of a general cause. Repeat similar requests and note details such as the page used, cache status, and changes to the application. This will help you determine whether a pattern is recurring or whether a single response is an outlier.
Read API times without double-counting
With an API, the application can handle not only the entire processing but also the wait time for an external service. The key factor here is the Measurement Limit: If the total time begins when the API handler is entered and ends when its response is ready to be output, the external call can be entirely contained within it.
In the following example, which was chosen arbitrarily, the external duration begins immediately before the request is sent to the service and ends as soon as the service's response is received by the application. The values are for illustrative purposes only and do not represent actual measurements. The table explicitly describes nested time periods, not two independent work packages.
| Metrics | Measurement Limits in the Example | Duration |
|---|---|---|
| Overall Processing | Enter the handler until a response is available | 120 ms |
| External Call | From the time the request is submitted until a response is received from the service | 80 ms |
Although 120 ms plus 80 ms equals 200 ms, in this case it would be a Double counting: The 80 ms are already within the 120 ms. Mathematically, 40 ms of the total duration remain outside the external call. However, the header alone does not explain what work or wait time this remaining duration encompasses.
Even parallel dependencies cannot simply be added together to yield a total elapsed time. For example, if two calls run simultaneously and each lasts 80 ms, their individual durations add up to 160 ms, even though their time intervals may overlap significantly. Without information about the start and end times, the actual degree of overlap cannot be determined from the durations alone.
To determine which service triggered which subsequent call, distributed tracing supplements the header values. Server timing can associate selected durations with the browser response, but does not, on its own, describe the complete causal relationships between services. When comparing, make sure that the trace and the header refer to the same operations and boundaries.
Reading Server Timing via JavaScript
The Performance API makes existing server timing data accessible programmatically as well. A navigation entry describes the loading of the current document; its property serverTiming contains the reported metrics available for that purpose. This is a different set than an entry for a loaded resource or an API call.
Run the following JavaScript in the browser console on the page you want to examine. It selects the first available navigation entry and displays its server timing list in a table. The code only reads values that are already available: it does not change any server configuration and does not perform a load test.
If no navigation entry exists or if it does not provide any accessible metrics, the example displays an empty list. This does not necessarily mean that the page is fast or slow, nor does it necessarily mean that the server lacks instrumentation. First, check the response header and verify that the selected entry actually corresponds to the desired request.
For a reloaded resource, you need the corresponding Resource Entry. Among the entries of the type resource you can identify the request you're looking for based on its name and its serverTiming-Consider this property. When repeatedly accessing the same address, you must pay attention to which specific entry you are comparing.
For cross-origin resources, whether the Performance API makes the timing information available also depends on the appropriate permission granted via `Timing-Allow-Origin`. Browser support and the specific environment can also affect the output. Therefore, compare an empty list with the raw header before making any changes to the application.
Origin Shares and Sensitive Information
When accessing a resource via the Performance API, the origin of the requesting page is critical. If a resource comes from a different origin, its response must be Timing-Allow-Origin Grant the appropriate permissions to the originating site so that JavaScript can read the relevant timing information, including server timing. A CORS permission alone does not replace this additional permission.
A specific origin restricts access to the specified source. The placeholder * In contrast, it generally allows all origins to view the relevant timing information via the Performance API. Therefore, choose the more restrictive permission if only one known application needs the values, and verify them against the actual resource response returned.
The "Origin" header does not make a response header confidential. Anyone who receives the HTTP response can, in principle, examine its contents. Therefore, do not include login credentials, personal information, or internal hostnames in metric names or descriptions. Even fine-grained execution times can reveal details about internal processes; only publish values whose benefits and risks you have carefully weighed.
Also test the evaluation in the browsers that your application is intended to support: Support for specific details and requirements for secure contexts may vary. For general validation of responses, you should also Appropriate security headers for web servers relevant; however, they do not replace either the review of the timing approval or the decision regarding which measurement values may be made public.
Check for Missing Values and Cache Effects
If the list of server timing values is empty, start by examining the specific request in the Network panel of DevTools. Under "Headers," check whether the response actually contains a Server-Timing-Check which names are listed in the header. If it is missing, examine the instrumentation and any possible changes caused by intermediate components, rather than inferring the speed from the empty list.
If the raw header is present, next check the Performance Entry: The navigation entry describes the loading of the document, while an API call or other resource requires a corresponding resource entry. For cross-origin resources, you also check for authorization by Timing-Allow-Origin as well as support in the browser being used. An empty list does not in itself indicate a lack of instrumentation or a fast or slow response.
Even an existing value needs context. A CDN or proxy may contribute its own metrics; at the same time, a response—including its headers—may come from a cache. In that case, a previously generated origin metric does not necessarily reflect the origin server’s performance for the current request. Therefore, document Cache Status and Origin separate from the duration.
Examine the specific setup to determine which component sets, passes along, or modifies the header, and how it handles cached responses. Next, compare requests with known cache states, if your infrastructure allows it. Differences between these responses provide useful clues, but without knowledge of the respective measurement limits, they do not yet prove a specific cause.
Logs, Trailers, and Tool Selection
Server Timing complements other diagnostic methods rather than replacing them. The right choice depends on whether you want to understand a single browser request, programmatically capture existing values, or investigate relationships across multiple services. The following overview distinguishes the insights gained from each method from its prerequisites and limitations.
| Tool | Insight | Prerequisite | Border |
|---|---|---|---|
| DevTools | Check individual requests and reported times | Browser request with relevant metrics | No automatic root cause analysis |
| Performance API | Read Existing Timing Values Using JavaScript | Appropriate entry and, if applicable, Origin approval | No complete cross-departmental process |
| Server logs | Analyze server-side logged times | Appropriate Log Format and Access to Logs | Measurement limits and units must be verified |
| Distributed Tracing | Examine the relationships between the services involved | Instrumentation and Assignment of Traces | Additional operational and instrumentation costs |
For a metric that is not determined until the response is complete, a log entry may be more appropriate than a regular response header. For example, NGINX logs request_time and upstream_response_time in seconds with millisecond resolution. Server timing, on the other hand, uses milliseconds: A value in seconds must be multiplied by 1,000. Before making a comparison, you should also check when each measurement begins and ends.
At Streaming The total length of the response body may not yet be known when regular headers are sent. The specification also allows server timing to be included as an HTTP trailer. However, this is not a universal solution: The Fetch API does not provide access to trailers, and their display in developer tools must be checked separately for each browser.
To make more reliable comparisons, repeat similar queries under documented conditions: For example, record the endpoint, cache state, and relevant changes to the system. Consider multiple values rather than a single request, and investigate any notable differences further using logs or traces. This makes it clear which observation is actually covered by which measurement.
A browser-based test environment can help you experiment with application settings, but it does not automatically replicate the network paths and server services that will be used in production. This also applies to WordPress Playground in the Browser. You should also test statements regarding a specific hosting and backend configuration in an environment that is as close to production as possible.
Sources and Current State of Knowledge
Status of the research:
Research status: November 13, 2026. Browser display and support for individual features may vary; examples do not include our own measurements.
https://www.w3.org/TR/server-timing/
https://developer.mozilla.org/en-US/docs/Web/API/PerformanceResourceTiming/serverTiming
https://developer.chrome.com/docs/devtools/network?hl=en
https://developer.chrome.com/docs/devtools/performance/reference/
https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Timing-Allow-Origin
https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Server-Timing
https://docs.nginx.com/nginx/admin-guide/monitoring/logging/




