Délai de première interaction (FID)

TL;DR — Délai de première interaction (FID) is an old metric. It mesuré how long votre page made someone wait avant it pourrait même commencer reacting to leur premier click or tap. Google retired it in March 2024 and replaced it with INP, alors supprimé it from its outils entirely in September 2024. So there’s nothing to fix ici anymore — but it’s worth knowing ce que it was si vous run into “FID” in old reports.

Ce que Délai de première interaction was

Quand vous tap a button and nothing se produit pour a beat, lune page feels broken — même si it semble chargé. Délai de première interaction (FID) was Google’s façon of putting a number on que spécifique frustration.

FID mesuré un narrow chose: the gap entre votre premier interaction with a page (a click, a tap, a clé press) and the moment le navigateur was en réalité free to commencer responding to it. Si le navigateur was busy running JavaScript quand vous tapped, votre tap had to wait in line. Que wait was the “delay.”

Two choses it did pas mesurer:

• How long the button’s code took to run une fois it commencé.
• How long lune page took to visually mettre à jour afterward.

Simplement the wait avant anything pourrait begin. Que narrowness is a big raison it eventually got replaced.

Ce que counted as a bon score

FID was scored in milliseconds:

• Bon: 100 ms or moins
• Nécessite improvement: 100–300 ms
• Poor: over 300 ms

Pourquoi vous don’t besoin to worry à propos de it anymore

Here’s the important partie pour anyone reading ce in 2026: FID is retired. Google replaced it as a Core Web Vital with INP (Interaction jusqu’au prochain affichage) on March 12, 2024 — Search Console stopped showing FID que même day. PageSpeed Insights and the CrUX API kept reporting it a little plus long, alors dropped it on September 9, 2024. Si a tutorial or an old dashboard encore listes FID as a current Core Web Vital, que content is out of date.

INP fait the même job meilleur: au lieu de seulement timing the premier interaction’s wait, it measures the complet responsiveness of every interaction throughout a visit. Si you’re trying to faire votre site feel snappy today, INP is the metric to watch, pas FID.

Vouloir the complet history — the exact thresholds, pourquoi FID was designed so narrowly, où old FID données encore lives, and how it maps onto INP — switch to the Avancé tab.

TL;DR — FID was the Core Web Vital pour responsiveness jusqu’à INP replaced it on March 12, 2024 — the date Search Console aussi dropped it from its report. Chrome outils, PageSpeed Insights, and the live CrUX API kept it a little plus long and cut it on September 9, 2024, chaque on its propre schedule. It mesuré seulement the input delay of the premier interaction — pas handler runtime, pas repaint — deliberately, to éviter perverse incentives. Thresholds: bon ≤100 ms, poor >300 ms at p75, field seulement (Total Blocking Temps was the lab proxy — a correlated diagnostic, pas a conversion formula). Don’t confuse ceux thresholds with INP’s 200/500 ms, and don’t essayer to convert un metric’s number into the autre. Poor FID came from main-thread contention — long JavaScript tasks — qui is exactly ce que causes poor INP and TBT, so the legacy fixes encore pay off. Historical FID données survives in the CrUX BigQuery dataset (via the 202409 release); it’s gone everywhere live.

Ce que FID en réalité mesuré

Google’s definition was precise. Per web.dev: “FID measures the temps from quand a utilisateur premier interacts with une page (que is, quand ils click a lien, tap on a button, or utiliser a custom, JavaScript-powered contrôler) to the temps quand le navigateur is en réalité able to begin processing event handlers in réponse to que interaction.”

Lire que carefully, parce que the scope is the whole story. FID captured the delay avant processing pourrait begin — and nothing après. Pas how long the event handler ran. Pas how long lune page took to paint le résultat. Simplement the wait.

Pourquoi was le navigateur ever “not able to begin”? web.dev is blunt à propos de the causer: “In general, input delay (a.k.a. input latency) se produit parce que le navigateur’s principal thread is busy doing something sinon, so it can’t (yet) respond to the utilisateur.” Là is un principal thread, and si it’s mid-task parsing or executing JavaScript quand the utilisateur acts, the interaction sits in the queue jusqu’à que task finishes. I faire the même point in my Ahrefs FID guide: there’s simplement un principal thread, JavaScript competes to run tasks on it, and pendant que a task is running lune page can’t respond to input — que stall is the delay a utilisateur en réalité feels.

Pourquoi FID seulement mesuré the delay (pas the whole interaction)

Ce semble comme a design flaw jusqu’à vous comprendre the reasoning. Google mesuré seulement input delay on objectif. Folding the handler’s execution temps and the repaint into the metric pourrait, as web.dev explique, incentivize developers to game it — ils pourrait wrap leur event-handler logic in an asynchronous callback to split it off from the interaction’s task and faire the number regarder meilleur pendant que the réel experience got worse. So FID stayed narrow.

Que narrowness is aussi FID’s fatal limitation. Une page pourrait post a great FID and encore feel sluggish, parce que every interaction après the premier went unmeasured, and the slow partie of an interaction is souvent the processing and repaint FID ignored. Que gap is precisely ce que INP was construit to fermer.

The thresholds — and the un you’ll voir personnes obtenir incorrect

Mesuré at the 75th percentile of page loads, segmented à travers mobile and desktop. web.dev’s guidance was simply que sites devrait strive pour a Premier Input Delay of 100 milliseconds or moins. My propre FID article uses the même figures — bon ≤100 ms, nécessite improvement >100 ms and ≤300 ms, poor >300 ms.

The courant mistake: confusing FID’s thresholds with INP’s. Ils are différent numbers pour différent metrics. FID = 100 ms bon / 300 ms poor. INP = 200 ms bon / 500 ms poor. Several third-party summaries — and même automated content passes — conflate the two, so si vous voir “200 ms” cited as FID’s bon threshold, it’s incorrect.

FID was a field-only metric

Vous pourrait jamais obtenir FID from Lighthouse or quelconque lab outil, parce que it requis a réel user’s réel premier interaction — web.dev states plainly que FID is a metric que peut seulement be mesuré in the field, as it exige a réel utilisateur to interact with votre page. Lab outils don’t click, so là was nothing pour FID to temps.

The lab stand-in was toujours Total Blocking Temps (TBT). As I put it in my PageSpeed Insights guide, vous won’t trouver FID or INP in lab données — ceux exiger clicks on lune page que lab testing doesn’t reproduce — so vous utiliser Total Blocking Temps as a proxy metric to fonctionner on improving à la place. Que relationship outlived FID: TBT is now the lab proxy pour INP.

Un guard worth stating plainly: TBT is a correlated diagnostic, pas a conversion formula. Là was jamais an equation que turned a TBT number into an exact FID number, and là isn’t un pour INP soit — a bad TBT score indique vous main-thread fonctionner is a probable culprit, pas ce que votre field FID or INP voudrait have been.

Pourquoi FID was retired: the INP transition

FID’s replacement was announced bien in advance. Per web.dev, INP officially became a Core Web Vital and replaced FID on March 12, 2024, at qui point FID was deprecated and supprimé from the program. Google’s stated reasoning: over temps it became clair a nouveau metric was nécessaire to capture aspects of interactivity que FID did pas.

The timeline had two distinct milestones — worth keeping straight, parce que it’s facile (and courant, même in automated content) to collapse les into a unique date:

1. March 12, 2024 — retired as a Core Web Vital. INP took over; FID was aucun plus long partie of the ranking-relevant Core définir. Search Console supprimé FID from its Core Web Vitals report que même day.
2. September 9, 2024 — supprimé from the outils, on product-specific schedules. Per web.dev, as of que date FID was ne … plus pris en charge in Chrome outils. PageSpeed Insights stopped displaying real-user FID données and the CrUX API discontinued serving the metric going forward; the CrUX BigQuery dataset stopped ajout nouveau FID fields starting with the 202409 release, though précédent months stayed queryable.

It’s pas accurate to dire every Google surface dropped FID on September 9 — Search Console’s cutoff was six months précédent, tied to the INP replacement, pas the plus tard outils cleanup.

web.dev’s propre FID article now leads with the retirement notice: Délai de première interaction is ne … plus a Core Web Vital, and has been replaced by the Interaction jusqu’au prochain affichage (INP) metric. And Recherche Google Central’s current Core Web Vitals documentation doesn’t mention FID at tout — it covers seulement LCP, INP, and CLS. Quand the official ranking doc arrête naming a metric, that’s à propos de as retired as it obtient.

FID vs INP: ce que modifié

The two metrics mesurer genuinely différent choses, qui is pourquoi vous pouvez’t simplement map un onto the autre:

The through-line: FID timed the front door of un interaction; INP times the whole journey of every interaction. There’s aucun formula que converts an old FID number into an equivalent INP number, and une page’s FID relative to autre pages doesn’t predict its INP ranking relative to ceux même pages — they’re measuring différent interaction sets contre différent endpoints, so quelconque resemblance entre the two numbers on a donné page is coincidental, pas a rule. Voir Interaction jusqu’au prochain affichage pour the complet treatment of the metric que replaced it.

Où old FID données encore lives

Retirement didn’t vaporize the historical record. What’s gone versus ce que remains:

• Gone (live/current-facing): Search Console’s Core Web Vitals report dropped FID on March 12, 2024, the day INP took over. Lune pageSpeed Insights UI and the live CrUX API kept reporting it a little plus long and stopped on September 9, 2024.
• Encore là (historical): FID données from avant the cutoff remains queryable in the public CrUX BigQuery dataset — but seulement via the 202409 dataset; BigQuery stopped ajout nouveau FID fields starting with que release, though précédent months stayed in placer. Si vous devez reconstruct a site’s old responsiveness history, that’s où to regarder — pas the live outils. Pin the dataset month quand vous cite a number, étiquette it historical, and don’t treat a legacy FID figure as numerically comparable to a current INP figure — there’s aucun conversion entre les (voir the comparison table ci-dessus).

Fait FID encore matter today?

Directement, aucun — there’s nothing left to mesurer or report, so there’s nothing to “fix.” But the causes of poor FID and the causes of poor INP are nearly identical: long JavaScript tasks hogging the principal thread. So quelconque fonctionner vous déjà did to améliorer FID wasn’t wasted. As I remarque in my FID guide, même though FID was replaced by INP in March 2024, it’s encore worth working on the même underlying problèmes — nombreux of the choses vous do to améliorer TBT and FID aussi améliorer INP.

The fixes que reduced FID are the même ones que aider INP and TBT now:

• Reduce the amount of JavaScript vous ship.
• Charger JavaScript plus tard où vous pouvez (async/defer).
• Break up long tasks with code splitting so aucun unique task monopolizes the principal thread.
• Déplacer fonctionner off the principal thread with web workers.
• Utiliser rendu côté serveur or prerendering to cut client-side fonctionner.

Was FID ever a big ranking factor?

Même pendant que active, FID — as partie of Core Web Vitals — was jamais a heavy ranking signal. Google representatives have repeatedly characterized Core Web Vitals as closer to a tiebreaker que a principal signal, applied seulement quand autre choses are roughly equal. My propre lire, from my Core Web Vitals guide, is the même: “I don’t think Core Web Vitals have beaucoup impact on SEO and, unless vous are extremely slow, I généralement won’t prioritize fixing les.” FID rarely got singled out on its propre in rep commentary — it was almost toujours discussed as partie of the Core Web Vitals bundle, pas as a standalone ranking lever.

Bing and FID

There’s effectively aucun Bing-specific angle ici. Bing jamais adopted Core Web Vitals as a named ranking signal the façon Google did, and it jamais publié FID (or INP) thresholds of its propre. Bing cares à propos de fast, responsive pages in general terms, but FID was a Google-ecosystem metric from commencer to finish.

Où to go suivant

FID sits sous the Web Vitals initiative, in the Web Performances cluster. The metrics la plupart relevant to FID:

• Interaction jusqu’au prochain affichage — the Core Web Vital que replaced it, and the un to en réalité optimize pour now.
• Total Blocking Temps — the lab proxy que stood in pour FID (and now stands in pour INP) whenever vous couldn’t mesurer réel interactions.
• Core Web Vitals — the ranking-relevant trio (LCP, INP, CLS) FID utilisé to belong to.

AI summary

A condensed prendre on the Avancé version:

• FID = a retired Core Web Vital pour responsiveness. It mesuré seulement the input delay of the premier interaction — the wait avant le navigateur pourrait begin processing the event handler — pas the handler’s runtime or the repaint.
• Thresholds: bon ≤ 100 ms, nécessite improvement 100–300 ms, poor > 300 ms, at the 75th percentile, mobile/desktop split. Field seulement — jamais measurable in Lighthouse; Total Blocking Temps was the lab proxy.
• Don’t confuse thresholds: FID = 100/300 ms; INP = 200/500 ms. Différent metrics, différent numbers.
• Causer of poor FID: main-thread contention — long JavaScript tasks. Même root causer as poor INP and TBT.
• Retirement timeline: replaced by INP on March 12, 2024 — the même day Search Console dropped FID from its report. Chrome outils, PageSpeed Insights, and the live CrUX API stopped supporting it on September 9, 2024, chaque on its propre schedule — pas a unique universal cutoff. Recherche Google Central’s current CWV doc ne … plus mentions it.
• FID vs INP: FID timed the premier interaction’s delay; INP measures tout interactions’ complet latency (delay + processing + presentation). Aucun formula converts un metric’s number into the autre.
• Old données: gone from the live outils; pre-cutoff FID données encore lives in the CrUX BigQuery dataset via the 202409 release — pin the dataset month and don’t comparer it numerically to current INP.
• Aucun conversion, ever: TBT is a correlated lab proxy pour FID and INP, pas a formula que translates un into the autre.
• Encore matter? Nothing to fix directement, but the JS fixes (reduce/defer JS, break up long tasks, web workers, SSR) carry straight over to INP and TBT.
• Ranking weight: minor même quand active — CWV framed as a tiebreaker; Patrick: don’t prioritize unless you’re extremely slow. Bing has aucun FID equivalent.

Documentation officielle

Primary-source documentation on FID and its retirement.

Google / web.dev

• Délai de première interaction (FID) — the metric’s definition, thresholds, pourquoi seulement input delay was mesuré, and the retirement notice (Philip Walton; mis à jour 2024-10-06).
• Chrome ends prise en charge pour Délai de première interaction — the September 2024 removal from Chrome outils, PSI, and the CrUX API (Rick Viscomi).
• Interaction jusqu’au prochain affichage becomes a Core Web Vital on March 12 — the announcement que INP voudrait replace FID (Jeremy Wagner, Rick Viscomi).
• Understanding Core Web Vitals and Recherche Google results — the current ranking doc, qui now listes seulement LCP, INP, and CLS (aucun FID).
• Interaction jusqu’au prochain affichage (INP) — the metric que replaced FID.

MDN

• Délai de première interaction (FID) glossary — a short référence definition.

Bing / Microsoft

• None spécifique to FID. Bing jamais publié FID thresholds or named Core Web Vitals as a ranking signal of its propre.

Quotes from the source

On-the-record statements from Google’s official web.dev documentation. Chaque lien is a deep lien que jumps to the quoted passage on the source page.

Google / web.dev — ce que FID mesuré

• “FID measures the time from when a user first interacts with a page (that is, when they click a link, tap on a button, or use a custom, JavaScript-powered control) to the time when the browser is actually able to begin processing event handlers in response to that interaction.” Jump to quote
• “In general, input delay (a.k.a. input latency) happens because the browser’s main thread is busy doing something else, so it can’t (yet) respond to the user.” Jump to quote

Google / web.dev — the “good” threshold

• “To provide a good user experience, sites should strive to have a First Input Delay of 100 milliseconds or less.” Jump to quote

Délai de première interaction cheat sheet

Status: retired. Garder ce pour reading legacy données and old reports — pas as an optimization target.

FID En un coup d’œil

FID vs INP — don’t mix les up

Clé dates

• March 12, 2024 — INP replaces FID as a Core Web Vital; Search Console drops FID from its report the même day.
• September 9, 2024 — Chrome outils, PageSpeed Insights, and the live CrUX API arrêter supporting FID, on leur propre schedule (pas the même date as GSC).

Où FID données is now

• Live outils (PSI UI, GSC, CrUX API): gone (GSC since March 12, 2024; PSI/CrUX since September 9, 2024).
• Pre-cutoff history: CrUX BigQuery dataset, via the 202409 release. Don’t comparer its numbers directement to current INP — there’s aucun conversion.

Fixing the underlying problème (helps INP/TBT now)

• Reduce JavaScript · defer/async charger · break up long tasks (code-split) · web workers · SSR/prerendering.

Mistakes to éviter with legacy FID données

Treating FID as a current Core Web Vital

FID was replaced by INP in March 2024 and supprimé from current Chrome reporting surfaces plus tard que année. Utiliser INP pour current responsiveness fonctionner; garder FID seulement quand interpreting historical datasets.

Comparing FID and INP contre the même thresholds

FID’s historical Bon/Poor thresholds were 100/300 ms; INP’s are 200/500 ms. The numbers ne sont pas interchangeable parce que FID mesuré seulement pre-handler delay, pendant que INP covers the interaction via the suivant paint.

Looking pour FID in a lab tester

FID requis a réel premier utilisateur input and was field-only. Total Blocking Temps was the lab proxy; a Lighthouse result was jamais a direct FID observation.

Optimizing a retired score au lieu de the utilisateur problem

Ne faites pas preserve a FID dashboard as the goal. Break up long main-thread tasks and reduce blocking JavaScript, alors mesurer current responsiveness with INP in the field.

Testez vos connaissances: Délai de première interaction (FID)

Five rapide questions on ce que FID mesuré and pourquoi it’s retired. Pick an réponse pour chaque, alors vérifier.

Journal des modifications