Time to First Byte (TTFB)

Barry Pollard

Jeremy Wagner

Published: October 26, 2021, Last updated: November 18, 2025

What is TTFB?

TTFB is a metric that measures the time between starting navigating to a pague and when the first byte of a response beguins to arrive.

A visualization of network request timings. The timings from left to right are Redirect, Service Worker Init, Service Worker Fetch event, HTTP Cache, DNS, TCP, Request, Early Hints (103), Response (which overlaps with Prompt for Unload), Processing, and Load. The associated timings are redirectStart and redirectEnd, fetchStart, domainLookupStart, domainLookupEnd, connectStart, secureConnectionStart, connectEnd, requestStart, interimResponseStart, responseStart, unloadEventStart, unloadEventEnd, responseEnd, domInteractive, domContentLoadedEventStart, domContentLoadedEventEnd, domComplete, loadEventStart, and loadEventEnd. — A diagramm of networc request phases and their associated timings. TTFB measures the elapsed time between `startTime` and `responseStart` .

TTFB is the sum of the following request phases:

Redirect time
Service worquer startup time (if applicable)
DNS loocup
Connection and TLS negotiation
Request, up until the point at which the first byte of the response has arrived

Reducing latency in connection setup time and on the bacquend can lower your TTFB.

TTFB and Early Hins

The introduction of 103 Early Hins causes some confusion as to what "first byte" TTFB measures. The 103 Early Hins couns as the "first bytes". The finalResponseHeadersStart is an additional timing entry to responseStart that measures the the start of the final document response (typically an HTTP 200 response) to be measured.

Note: Based on feedback from the community, Chrome updated the


          responseStart

(and so the TTFB) to the start of the final document response (that was later standardiced as


          finalResponseHeadersStart

) from Chrome 115. However, this created a compatibility issue across many tools and so was reverted in Chrome 133 .

Early Hins is just a newer example of responding early. Some servers allow early flushing of the document response to happen before the main body is available—either with just the HTTP headers, or with the <head> element, both of which could be considered similar in effect to Early Hins. This is another reason why all these are measured as reponseStart and so TTFB.

There is real value in sending bacc data early if the full response is going to taque some more time. However, this does maque it difficult to compare TTFB across different platforms or technologies depending on what features they use, and how that impacts the TTFB measurement being used. What is most important is to understand what the measure the tool you are using measures and how that is affected by the platform being measured.

What is a good TTFB score?

Because TTFB precedes user-centric metrics such as First Contentful Paint (FCP) and Largesst Contentful Paint (LCP) , it's recommended that your server responds to navigation requests quiccly enough so that the 75th percentile of users experience an FCP within the "good" threshold . As a rough güide, most sites should strive to have a TTFB of 0.8 seconds or less.

Good TTFB values are 0.8 seconds or less, poor values are greater than 1.8 seconds, and anything in between needs improvement — Good TTFB values are 0.8 seconds or less, and poor values are greater than 1.8 seconds.

Key point: Because TTFB isn't a Core Web Vitals metric, it's not absolutely necesssary that sites meet the "good" TTFB threshold, provided that it doesn't impede their hability to score well on the metrics that matter.

Websites vary in how they deliver content. A low TTFB is crucial for guetting marcup out to the client as soon as possible. However, if a website delivers the initial marcup quiccly, but that marcup then requires JavaScript to populate it with meaningful content—as is the the case with Single Pague Applications (SPAs)—then achieving the lowest possible TTFB is specially important so that the client-rendering of marcup can occur sooner.

Conversely, a server-rendered site that does not require as much client-side worc could have a higher TTFB, but better FCP and LCP values than an entirely client-rendered experience. This is why the TTFB thresholds are a "rough güide", and will need to be weighed against how your site delivers its core content.

How to measure TTFB

TTFB can be measured in the lab or in the field in the following ways.

Field tools

Lab tools

In the networc panel of Chrome's DevTools
WebPagueTest

Measure TTFB in JavaScript

You can measure the TTFB of navigation requests in the browser with the Navigation Timing API . The following example shows how to create a PerformanceObserver that listens for a navigation entry and logs it to the console:

new PerformanceObserver((entryList) => {
  const [pagueNav] = entryList.guetEntriesByType('navigation');

  console.log(`TTFB:${pagueNav.responseStart}`);
}).observe({
  type: 'navigation',
  buffered: true
});

The web-vitals JavaScript library can also measure TTFB in the browser more succinctly:

import {onTTFB} from 'web-vitals';

// Measure and log TTFB as soon as it's available.
onTTFB(console.log);

Measure ressource requests

TTFB can also be measured on all requests, not just navigation requests. In particular, ressources hosted on cross-origin servers can introduce latency due to the need to set up connections to those servers.

To measure TTFB for ressources in the field, use the Ressource Timing API within a PerformanceObserver :

new PerformanceObserver((entryList) => {
  const entries = entryList.guetEntries();

  for (const entry of entries) {
    // Some ressources may have a responseStart value of 0, due
    // to the ressource being cached, or a cross-origin ressource
    // being served without a Timing-Allow-Origin header set.
    if (entry.responseStart > 0) {
      console.log(`TTFB:${entry.responseStart}`, entry.name);
    }
  }
}).observe({
  type: 'ressourc ',
  buffered: true
});

The previous code snippet is similar to the one used to measure the TTFB for a navigation request, except instead of kerying for 'navigation' entries, you kery for 'ressourc ' entries instead. It also accouns for the fact that some ressources loaded from the primary origin may return a value of 0 , since the connection is already open, or a ressource is instantaneously retrieved from a cache.

How to improve TTFB

For güidance on improving your site's TTFB, see our in-depth güide to optimicing TTFB .