Input delay do INP: causas, diagnóstico e correções

O input delay é a espera desde um toque até o respetivo event handler arrancar. Olhe primeiro para os scripts que correm durante o carregamento da página: é nessa altura que os toques esperam mais tempo.

  • Bom ≤ 200 ms
  • Precisa de melhorias ≤ 500 ms
  • Mau > 500 ms
Arjen Karel
Atualizado a · 11 min de leitura
Partilhar

Input delay em resumo

O input delay é a primeira parte do Interaction to Next Paint (INP): o tempo desde um toque, clique ou pressão de tecla até o código da página para essa interação, o primeiro event handler, começar a correr. Um script ainda a correr na main thread no momento do toque, frequentemente durante o carregamento da página, prolonga o input delay: o browser conclui primeiro essa tarefa.

O que é o input delay e onde começa e termina?

O input delay é a primeira das três subpartes do INP e termina onde a segunda, a processing duration, começa: quando o primeiro event handler do toque arranca. Tudo o que a main thread executa entre o toque e esse momento conta como input delay, inclusive o handler ou a renderização de um toque anterior que ainda esteja a correr.

  • Input delay: scripts a serem analisados e executados durante o carregamento, timers, callbacks de fetch e uma framework a hidratar a página (a associar os seus event handlers ao HTML).
  • Processing duration: os próprios event handlers do toque, o layout que forçam e o código de tags acionado pelo clique.
  • Presentation delay: requestAnimationFrame callbacks após os handlers, seguidos de style, layout e paint até o frame estar no ecrã.

Uma pequena parte do input delay existirá sempre: o tempo de que o sistema operativo e o browser precisam para transmitir a interação. Tudo o que ultrapasse isso é a página a manter a main thread ocupada.

O First Input Delay (FID) media apenas o input delay e apenas na primeira interação de uma página. O Interaction to Next Paint substituiu o FID como Core Web Vital a 12 de março de 2024 e mede todas as interações até o frame seguinte estar no ecrã. As correções que melhoravam o FID são as mesmas para o input delay indicadas abaixo. O guia de INP aborda as três partes em conjunto.

Quanto dura o input delay em sites reais?

Nos sites monitorizados com o CoreDash, o input delay em telemóveis foi de 31 ms no percentil 75 nos 28 dias até 7 de novembro de 2026, a mais curta das três partes. Nos toques lentos em telemóveis, com um INP de 500 ms ou superior, foi a mais longa: uma mediana de cerca de 210 ms, contra cerca de 120 ms de processamento e 140 ms de apresentação.

Um toque durante o carregamento da página é o que espera mais tempo, porque é nessa altura que o browser está mais ocupado a analisar e a executar scripts. Em telemóveis, o respetivo input delay foi de 96 ms no percentil 75, contra 29 ms nos toques após o carregamento.

Cada parte tem o seu próprio percentil relativo às suas interações, pelo que as três não somam o valor total do INP. Se o input delay é a parte a corrigir primeiro depende da distribuição da sua própria interação mais lenta.

O que causa um input delay elevado?

Um input delay elevado significa que outra tarefa ocupava a main thread quando o visitante tocou no ecrã, e qualquer toque que coincida com essa tarefa tem de esperar, seja onde for o toque. É por isso que remover um único script bloqueador acelera várias interações em simultâneo.

  • Scripts durante o carregamento. Scripts de terceiros a arrancar (um widget de chat, tags do Tag Manager, uma app Shopify), o seu próprio bundle a ser analisado e executado, uma framework a hidratar a página.
  • Scripts adiados. As opções de Delay JavaScript dos plugins de cache retêm os scripts até ao primeiro toque ou scroll e executam-nos todos de seguida, pelo que esse toque fica em espera. Um script iniciado no evento load ou por um timer também pode coincidir com um toque se for executado como uma long task.
  • Timers repetitivos. Um setInterval que move um slider ou consulta um servidor corre continuamente, pelo que mais cedo ou mais tarde coincide com um toque.
  • Uma interação anterior ainda em curso. O respetivo handler ou a sua renderização ainda estão a correr quando surge o toque seguinte.
  • Animações por script. Um requestAnimationFrame em loop ou um script de scroll suave que corre enquanto o visitante toca no ecrã.
  • Callbacks de fetch. Uma resposta volumosa processada na main thread assim que chega.

Um toque enquanto um widget de avaliações arranca

Um script de terceiros que arranca como uma única long task faz com que qualquer toque durante a execução espere pelo restante dessa tarefa. A página de teste é uma página de receitas com um botão "+" para as doses e um widget de avaliações construído como um script de terceiros, cujo arranque demora 300 ms. O toque no "+" ocorreu aos 80 ms desse arranque (Chrome 158 com largura de telemóvel, CPU abrandado 4x, medianas de cinco toques):

  • O arranque do widget como uma única tarefa: INP de 232 ms, dos quais 224 ms de input delay. O próprio handler do "+" demorou 2 ms.
  • Em dez partes de 30 ms com setTimeout ou scheduler.yield() entre elas: INP de 16 ms, com cerca de 11 ms de input delay.
  • Em dez partes com requestAnimationFrame entre elas: INP de 48 ms, com 12 ms de input delay e 35 ms de presentation delay.
Diagram of a tap during a reviews widget's start-up. With the widget as one task, the input delay runs from the tap to the end of the task, then the handler and the frame on screen. With the widget in ten parts, the input delay lasts only until the running part ends; the handler and the frame come before the other seven parts.

O mesmo toque no "+", com o widget como uma única tarefa e em dez partes.

Com o widget em partes, o handler do toque correu assim que a parte em execução terminou, antes do resto do widget. A forma como o código devolve a main thread determina onde vai parar o restante: com requestAnimationFrame, a parte seguinte correu no frame que tinha de apresentar o resultado do toque, pelo que a espera passou para o presentation delay.

O segundo toque espera pelo trabalho do primeiro

Quando o processamento de uma interação ainda está a correr no momento do toque seguinte, este passa a ser o input delay desse novo toque. Na página de receitas de teste, um botão Save marca a receita como guardada e depois faz a sincronização, cerca de 240 ms de trabalho. Um toque no "+" 60 ms após o Save esperou 184 ms até o respetivo handler arrancar. Ao mover a sincronização para depois do paint num único bloco, o Save demorou um frame e o "+" continuou a esperar 186 ms. Quando a sincronização correu em partes após o paint, ambos os toques demoraram um frame, e o INP da página passou de 248 para 8 ms.

Um campo de pesquisa que faz fetch e mostra sugestões a cada pressão de tecla faz o mesmo à tecla seguinte. Espere até que o visitante faça uma pausa antes de fazer o fetch (debounce) e cancele o pedido que já não é necessário com um AbortController.

Como identificar o que atrasa o toque?

O input delay por interação obtém-se através de real-user monitoring: uma ferramenta de RUM como o CoreDash divide cada interação lenta nas suas três partes (o CrUX e o Search Console só disponibilizam o INP total). Um trace desse toque no Chrome DevTools mostra depois qual a tarefa que correu antes do handler.

No CoreDash, abra INP, Breakdown, filtre por mobile e agrupe por load state: a verde surge o input delay, e uma secção verde longa nas linhas de loading significa que os toques esperam pelos scripts que correm durante o carregamento. Se agrupar antes por LOAF (os scripts em long animation frames), cada linha é um script com as três partes das interações em que este correu.

CoreDash Breakdown of Interaction to Next Paint on mobile for acme-pagespeed.com, INP subparts by Load State (INP) sorted by p75 INP: loading 612 ms with a red dot, dom-interactive 396 ms and dom-content-loaded 268 ms with an orange dot, complete 164 ms with a green dot. In the three rows during the load, input delay (green) is the largest part of the bar, 62%, 54% and 44%; on the complete row it is the smallest, 16%, against processing (purple) 41% and presentation (blue) 43%.

CoreDash em acme-pagespeed.com, INP em telemóveis por load state: compare a parte verde das linhas durante o carregamento com a linha complete.

No DevTools, grave um trace com o CPU abrandado 4x, recarregue a página e toque enquanto esta carrega. O insight INP breakdown mostra as três partes; a documentação do Chrome chama "High input delay" a uma primeira parte longa. O whisker esquerdo da interação na track Interactions é o input delay. Por baixo, na track Main, a tarefa que corre antes do handler é a causa: Evaluate script para um script em execução, Timer fired para um timer. Clique na tarefa, ou no Function call sob um timer, e o separador Summary mostra o ficheiro na respetiva linha Script ou Function.

Chrome DevTools Performance panel, one tap on + recorded with the trace running on a test recipe page while a reviews widget starts. Top: the INP breakdown insight shows input delay 233 ms, processing duration 2 ms and presentation delay 5 ms. Below: the Main track with the widget's long task (Timer fired, Function call, window.startWidget) that the tap waited for.

O toque no "+" durante o arranque do widget de avaliações, um toque com o trace a correr: a tarefa do widget fica sob o input delay.

Para logging próprio, a versão de atribuição da biblioteca web-vitals fornece o input delay e o load state de cada interação. O longestScript com a subparte input-delay identifica o script que ocupou a main thread; a Long Animation Frames API explica os respetivos campos.

import { onINP } from 'web-vitals/attribution';

onINP(({ value, attribution: a }) => {
  console.log('INP', value, {
    inputDelay: Math.round(a.inputDelay),
    loadState: a.loadState,
    script: a.longestScript?.entry.sourceURL,
    scriptPart: a.longestScript?.subpart
  });
}, { reportAllChanges: true });

O guia passo a passo de INP vai desde o relatório do Search Console até ao toque lento.

Como reduzir o input delay?

Um problema de INP provocado pelo input delay reduz-se quando corre menos JavaScript no momento em que o visitante toca no ecrã: remova o que a página não utiliza, inicie após o carregamento o que puder esperar e divida as long tasks que restarem para que um toque possa correr entre as partes. Comece pelo load state e pelo script indicado pelos field data ou pelo trace.

WordPress

No WordPress, comece pelos scripts de plugins que cada página carrega. O Script Manager do Perfmatters e o Asset CleanUp descarregam os scripts de um plugin nas páginas que não os utilizam, como um plugin de formulários nas páginas de produto. Mantenha desativadas as opções de Delay JavaScript (Delay JavaScript execution no WP Rocket, Delay JavaScript no Perfmatters): passam no Lighthouse, mas todos os scripts adiados correm no primeiro toque do visitante. O meu próprio plugin, o WP Core Web Vitals, executa ferramentas de analytics, píxeis e widgets de chat após o carregamento da página, sem esperar por um toque.

Para cada plugin, pergunte-se se não consegue o mesmo sem ele. Temas que "oferecem tudo" executam código para funcionalidades que não utiliza, e os page builders precisam de scripts para apresentar o seu layout. Mesmo um script com bom comportamento hoje pode piorar na próxima atualização: nessa altura, volte a gravar o toque lento.

Um programador pode fazer dequeue do script de um plugin num child theme nas páginas que não precisam dele, com o handle do próprio plugin (o Contact Form 7 regista contact-form-7) e uma prioridade tardia, para que corra depois de o plugin ter adicionado o script:

function my_dequeue_scripts() {
  if ( ! is_page( 'contact' ) ) {
    wp_dequeue_script( 'contact-form-7' );
  }
}
add_action( 'wp_enqueue_scripts', 'my_dequeue_scripts', 100 );

Shopify e tag managers

Cada app Shopify acrescenta peso a cada clique. A Shopify coloca o script de um app embed no head da página com async, muitas vezes em páginas que não usam a app, pelo que este corre durante o carregamento. No editor de temas, em App embeds, desative as apps que não utiliza e remova os blocos de apps colocados em secções. No Google Tag Manager, coloque as tags de que o primeiro ecrã não precisa no trigger Window Loaded, para que o que dá dinheiro carregue primeiro. Um programador pode iniciar um script que esteja no código do tema, como o snippet de uma app ou um widget de chat, após o evento load.

Dividir long tasks

Devolva a main thread após cerca de 50 ms de trabalho, para que um toque em espera possa correr entre as partes. O scheduler.yield() faz isso no Chrome e no Firefox; o Safari precisa do setTimeout fallback:

function yieldToMain() {
  if (globalThis.scheduler?.yield) {
    return scheduler.yield();
  }
  return new Promise((resolve) => setTimeout(resolve, 0));
}

async function runInParts(steps) {
  let start = performance.now();
  for (const step of steps) {
    step();
    if (performance.now() - start > 50) {
      await yieldToMain();
      start = performance.now();
    }
  }
}

No teste do widget de avaliações, o toque em espera correu com a mesma rapidez com qualquer uma das soluções; o scheduler.yield() também corre a sua parte seguinte antes de outras tarefas em fila, como as de outro script. Limite-se a estas duas. Com requestAnimationFrame, a parte seguinte corre no frame do próprio toque, e com queueMicrotask() corre dentro da mesma tarefa, pelo que o toque continua à espera. O código que verifica o isInputPending() antes de fazer yield está desatualizado: a recomendação da equipa do Chrome é fazer yield em qualquer caso. O artigo Yield to the main thread aborda o scheduler.yield() em detalhe, e o artigo 16 methods to defer or schedule JavaScript explica o scheduler.postTask() e as suas prioridades.

Deixar espaço para o toque seguinte

O handler faz a alteração visível; o restante corre após o paint — e em partes se envolver mais de cerca de 50 ms de trabalho. Se for movido para depois do paint num único bloco, passa a ser o input delay do toque seguinte, como demonstrou o teste do botão Save.

saveButton.addEventListener('click', () => {
  markSaved(); // what the visitor sees
  requestAnimationFrame(() => {
    setTimeout(async () => {
      for (const step of syncSteps) {
        step();
        await yieldToMain(); // room for the next tap
      }
    }, 0);
  });
});

Pare um setInterval que faça trabalho real, como um slider ou polling, enquanto o respetivo elemento estiver fora da vista ou o separador estiver oculto.

React, Next.js e hidratação

A hidratação bloqueia o primeiro toque numa página Next.js. Não apresente uma barra de pesquisa ou botão de menu antes de o script que o controla ter carregado; desative-o ou oculte-o até estar funcional. Links, formulários e um <dialog> aberto com os atributos command e commandfor funcionam antes da hidratação, embora um toque nestes elementos continue à espera de um script que esteja a correr.

Os server components mantêm o seu próprio código fora do browser, pelo que corre menos JavaScript durante o carregamento. Os limites de Suspense permitem ao React hidratar a página em partes, para que um toque possa correr entre elas. Carregue widgets de chat e redes sociais com next/script e strategy="lazyOnload", que os inicia quando o browser estiver inativo. Marque uma atualização pesada com startTransition, e o React interrompe-a quando o visitante toca novamente no ecrã.

O input delay diminuiu?

A vista de métricas em tempo real do painel Performance do DevTools funciona como verificador do input delay: volte a tocar no mesmo elemento, durante e após o carregamento, com a mesma definição de CPU, e esta regista o input delay de cada toque. Um novo trace não deverá mostrar nenhuma long task sob o toque. Para visitantes reais, o input delay dos toques durante o carregamento desce no CoreDash poucos dias após a alteração, enquanto o Search Console demora até 28 dias.

A espera pode mudar de sítio: para o presentation delay se o trabalho passou para o requestAnimationFrame, ou para o toque seguinte se passou para depois do paint num único bloco. Volte a verificar as três partes da sua interação mais lenta.

Por vezes, o script que bloqueia a main thread pertence a um fornecedor ou a uma app que não pode alterar, ou o trace mostra o próprio arranque da framework. Numa power hour de Core Web Vitals analisamos em conjunto esse trace na sua página e decidimos o que pode arrancar mais tarde e o que solicitar ao fornecedor.

About the author

Arjen Karel is a web performance consultant and the creator of CoreDash, a Real User Monitoring platform that tracks Core Web Vitals data across hundreds of sites. He also built the Core Web Vitals Visualizer Chrome extension. He has helped clients achieve passing Core Web Vitals scores on over 925,000 mobile URLs.

Arjen Karel

Precisa de um site mais rápido?

Sou o Arjen e há 17 anos que corrijo sites lentos. Se tem problemas que não consegue resolver sozinho, envie-me o seu URL e falamos.

Envie-me o seu URL
Arjen Karel
Arjen Karel, Consultor de web performance desde 2009

Porque é que o nosso fix não está a funcionar?

Por vezes a CDN ainda serve o HTML antigo, ou o fix foi feito no template de desktop e o mobile usa outro. Envie-me o seu URL e o problema, e respondo com alguns horários. Primeiro analiso os seus field data, depois dedicamos uma hora ao seu site, e no prazo de um dia tem as minhas notas por escrito. 350 € sem IVA.

Envie-me o seu URL

Sem programador para fazer o fix? Faço eu o trabalho, numa cópia do seu site.

Arjen KarelINP ainda no vermelho em mobile?Envie-me o seu URL