Processing time do INP: acelere event handlers lentos
Mude primeiro o que o visitante vê, faça yield com scheduler.yield() e corra o tracking e o resto do clique após o frame.
- Bom ≤ 200 ms
- Precisa de melhorias ≤ 500 ms
- Mau > 500 ms
Partilhar
O processing time em resumo
A processing duration, também chamada processing time, é a segunda fase da Interaction to Next Paint (INP): o tempo que os event handlers de um toque ou premir de tecla demoram a correr, do primeiro ao último listener. Nada no ecrã pode mudar antes de terminarem; por isso, a solução é atualizar o ecrã primeiro e correr o resto após o frame seguinte.
O que conta como processing time?
Todos os event listeners dos eventos da interação contam para a processing duration: pointerdown, pointerup e click num toque; keydown e keyup ao premir uma tecla. Isto inclui o handler do próprio botão, o do tema e o trigger de clique de um tag manager que escuta todo o documento, além das promises resolvidas por esses listeners e do layout que forçam.

Um toque desde o input até ao frame, e o trabalho que um yield move para depois do frame.
- As promises que um listener resolve. Correm antes de o browser avançar, pelo que um
awaitsobre algo já resolvido mantém o resto do código dentro do clique. - O layout que um listener força ao ler uma dimensão depois de alterar a página (forced reflow).
- O render de uma framework quando renderiza a atualização dentro do evento, como o React faz com uma atualização de estado num clique.
O trabalho que um listener agenda para mais tarde corre fora da processing duration: um setTimeout, uma continuação de scheduler.yield() e a resposta de um fetch correm cada um numa tarefa posterior. No Chrome 158, um timeout ou um yield iniciado no clique correu após o frame em cada toque numa página de teste de bilheteira; as especificações deixam essa ordem ao critério do browser. Os callbacks de requestAnimationFrame correm no próprio frame e contam como presentation delay.
O Chrome DevTools chama a esta parte "Processing duration" no detalhe do INP, e a documentação do Chrome chama "High processing duration" a uma duração longa. A biblioteca web-vitals chama-lhe processingDuration, o CoreDash "Processing" e os artigos mais antigos "processing time". A espera antes de o primeiro listener começar é o input delay, e o tempo desde o último listener até ao frame no ecrã é o presentation delay; o guia de INP reúne as três partes.
Quanto dura a processing duration em sites reais?
Nos sites que medem com o CoreDash, a processing duration em telemóveis foi de 60 ms no percentil 75 nos 28 dias até 7 de novembro de 2026: tão longa como o presentation delay e cerca do dobro do input delay (31 ms). Em toques lentos no telemóvel, com um INP de 500 ms ou mais, a mediana foi de cerca de 120 ms, contra cerca de 210 ms de input delay e 140 ms de presentation delay.
Cada parte tem o seu próprio percentil, pelo que as três não somam o INP.
Um bom INP é de 200 ms ou menos no percentil 75. É a sua interação mais lenta que decide por onde começar: o detalhe do INP no Chrome DevTools recomenda corrigir primeiro a parte mais longa.
O que causa uma processing duration elevada?
Uma processing duration elevada resulta de um click handler que faz tudo antes de o ecrã mudar: tracking, gravar dados, recalcular e renderizar. Num trace do toque no Chrome DevTools, o aspeto é este:
- Tags e tracking no clique. Um trigger de clique do Google Tag Manager, um
dataLayer.push()ou um evento do pixel da Meta corre dentro do toque, pelo que aparecem funções do gtm.js ou do fbevents.js sob Event: click. - Tudo num único handler. Adicionar ao carrinho também sincroniza o cesto, atualiza as recomendações e regista o clique, o que surge como uma única Function call longa.
- Um recálculo no clique. Um seletor de datas que constrói meses de preços, ou um formulário de reserva que recalcula tudo a cada escolha de viajantes ou quartos.
- O render de uma framework. Uma atualização de estado no React dentro de um clique renderiza os componentes alterados antes de o evento terminar, com funções do próprio React sob Event: click.
- Layout forçado. O handler altera a página e a seguir lê uma dimensão, pelo que surgem blocos de Layout com um triângulo vermelho dentro do evento.
- Muitos listeners num só toque. O tema, os plugins, as aplicações e as tags adicionam cada um um listener ao mesmo toque, no botão ou no document: várias chamadas Function sob um único evento, ou também sob pointerdown e pointerup.

Um clique num site React no painel Performance do Chrome DevTools.
Os callbacks de clique do Tag Manager e do Facebook correm frequentemente antes do código que atualiza o ecrã, como neste trace. Movidos para depois do frame, continuam a correr e o visitante vê o resultado primeiro. No site de um cliente, mover o dataLayer.push() para depois do paint reduziu o INP em 100 ms.
O clique lento que vejo com mais frequência é num filtro de produtos: o handler atualiza a lista, lê a nova altura, altera algo com base nessa altura e volta a ler a altura. Cada leitura após uma alteração obriga o browser a recalcular o layout dentro do clique; por isso, o handler deve ler todas as dimensões primeiro e alterar a página depois.
Como encontrar o event handler lento?
Um trace do toque lento no painel Performance do Chrome DevTools, gravado com um CPU mais lento, mostra o event handler lento: o detalhe do INP indica a processing duration, e as chamadas Function sob Event: click (ou pointerdown e pointerup) identificam o script e quanto tempo este correu.
- Grave um trace do toque lento na largura de telemóvel com o CPU 4x mais lento.
- Abra o INP breakdown na barra lateral Insights: amplia a interação e divide-a nas suas três partes.
- Sob Event: click, as chamadas Function mostram o ficheiro e a função. O separador Bottom-up, configurado para Group by domain ou Group by URL, soma o tempo gasto por cada ficheiro.
- No painel Elements, selecione o botão e abra o separador Event Listeners. Com a opção Ancestors selecionada, como vem por predefinição, lista quem escuta no botão e no document, com o trigger de clique de um tag manager incluído.
Para visitantes reais no Chrome e no Edge, a build de atribuição da biblioteca web-vitals reporta o script mais longo da interação lenta e a parte em que correu:
import { onINP } from 'web-vitals/attribution';
onINP(({ value, attribution }) => {
const script = attribution.longestScript;
if (script?.subpart === 'processing-duration') {
console.log('INP', value, script.entry.invoker, script.entry.sourceURL);
}
}, { reportAllChanges: true });
Para o botão Add na página de teste de bilhetes mais abaixo, invoker indicava BUTTON#add3.onclick: o elemento e o evento que executaram o script.
No CoreDash, abra INP, Breakdown, filtre por telemóvel e agrupe por LOAF (os scripts em long animation frames): cada linha é um script, e o roxo é a processing duration.

CoreDash, INP agrupado por LOAF em telemóveis para acme-pagespeed.com.
A Long Animation Frames API indica de quem é o script, e o guia passo a passo de INP vai desde o relatório do Search Console até ao toque lento.
Como reduzir a processing duration?
A processing duration encurta quando o clique corre apenas o código de que o visitante precisa para ver o resultado e agenda tudo o resto para depois do frame seguinte. Numa página de teste de bilheteira, isso reduziu o INP do clique de 200 ms para um único frame. Remova código que não tenha razão para correr no clique, como uma tag que ninguém lê. Comece pelo script identificado no trace ou no CoreDash. Muitas vezes pode desativar ou substituir um plugin, uma aplicação ou uma tag sem código (veja WordPress e Shopify abaixo); o seu próprio código vai para um programador com o padrão de yield.
WordPress
O WordPress dá pouco controlo sobre os scripts que os plugins adicionam, e muitos deles introduzem listeners que não fazem nada no clique a não ser atrasar a Interaction to Next Paint. Sem código:
- Desative opções do tema de que não precisa, como o scroll suave ou menus animados (abandone o scroll por JavaScript).
- Encontre o plugin no trace pelo respetivo caminho,
/wp-content/plugins/mais o seu nome. Substitua-o por outro que faça o mesmo com menos JavaScript, ou descarregue-o nas páginas que não o utilizam com o Script Manager do Perfmatters ou o Asset CleanUp (unused JavaScript). - No Google Tag Manager, remova as tags que disparam em cada clique e que ninguém utiliza.
- Escolha um tema leve em vez de um tema que faz tudo ou de um page builder: estes trazem mais scripts e click handlers mais pesados.
Para os seus próprios scripts, envie a um programador o trace do toque lento e peça que a alteração visível seja feita antes do tracking, com o padrão de yield abaixo.
Shopify
Cada aplicação da Shopify adiciona peso a cada clique, e é o código do tema que decide o que corre no Add to cart, não as definições da aplicação. No editor de temas, em App embeds, desative as aplicações uma a uma e grave um trace do toque lento após cada alteração. A parte do tema é trabalho para um programador: o handler de adicionar ao carrinho atualiza primeiro o botão e o contador do carrinho, e deixa o resto para depois do frame, enquanto o cart drawer renderiza apenas o que mudou.
Mude o ecrã primeiro, depois faça yield
Divida um event handler longo com um yield: faça a alteração visível, devolva a main thread e corra o resto após o frame. O helper yieldToMain() faz yield com scheduler.yield() onde o browser for compatível e com setTimeout onde não for:
function yieldToMain() {
if (globalThis.scheduler?.yield) {
return scheduler.yield();
}
return new Promise((resolve) => setTimeout(resolve, 0));
}
button.addEventListener('click', async () => {
showAdded(button); // what the visitor sees
await yieldToMain(); // the browser can paint now
sendTags(); // the rest runs after the frame
await yieldToMain(); // room for the next tap
syncBasket();
await yieldToMain();
updateRecommendations();
});
A página de teste é uma bilheteira de festivais onde o botão Add num bilhete também executa três tags de tracking, a sincronização do cesto e novas recomendações: cerca de 190 ms de trabalho. Medido no Chrome 158 em largura de telemóvel com um CPU 4x mais lento, medianas de cinco toques:
- Tudo no click handler: INP de 200 ms, dos quais 192 ms de processing duration, e "Added" apareceu apenas após todo o trabalho.
- A alteração visível e depois um único
scheduler.yield(): INP de 16 ms ou menos, ou seja, um frame, com "Added" no ecrã em 13 ms. O resto continuou a correr, logo após o frame. - O mesmo com
setTimeoutem vez descheduler.yield(): também um frame.

Antes: um toque em Add gravado num trace, o que acrescenta alguns milissegundos face às medianas acima: 195 ms de processing duration.

Depois: o mesmo toque com scheduler.yield(): 7 ms.
scheduler.yield() funciona no Chrome e no Edge a partir da versão 129 e no Firefox a partir da versão 142. O Safari não o tem, pelo que os iPhones recorrem ao setTimeout como fallback. O guia de INP e a página sobre o presentation delay usam um setTimeout dentro de requestAnimationFrame em alternativa: na página de teste o resultado foi idêntico, ideal para trabalho que deve arrancar assim que o frame é pintado.
Quando o resto tem mais de cerca de 50 ms, faça yield também entre as suas partes, como faz o código acima. Um único bloco longo após o frame faz o toque seguinte esperar por ele, tal como medido no input delay. O artigo Yield para a main thread aborda o scheduler.yield() em detalhe, e agendar eventos do dataLayer apresenta o padrão para o Google Tag Manager.
Armadilhas que mantêm o toque lento
As três primeiras foram medidas na mesma página de bilhetes:
- O resto no
requestAnimationFrame. Corre imediatamente antes do frame, pelo que o INP se manteve nos 200 ms, agora como presentation delay, e "Added" surgiu apenas depois do trabalho. Coloque umsetTimeoutlá dentro, ou faça yield. - Um
awaitque não faz yield.await Promise.resolve()ouqueueMicrotask()corre o resto como uma microtarefa dentro do clique: INP de 192 ms, 184 ms dos quais de processing duration. Apenas umawaitsobre algo que se resolva numa tarefa posterior devolve a main thread. - Um yield antes da alteração visível. O INP termina no frame seguinte, independentemente do que esse frame mostrar. Um handler que faça primeiro yield e só depois altere o botão obtém um INP de um único frame, enquanto "Added" surge apenas após todo o trabalho, cerca de 210 ms após o toque. A alteração visível deve vir antes do primeiro yield.
requestIdleCallback()sem fallback. O Safari não o tem, pelo que a chamada lança um erro no clique em qualquer iPhone e o trabalho associado nunca corre; o mesmo se aplica ascheduler.postTask().yieldToMain()inclui o fallback de raiz.
React e outras frameworks
No React, uma atualização de estado num clique renderiza os componentes alterados antes de o evento terminar, pelo que um re-render pesado conta como processing duration. Envolva a atualização pesada em startTransition, ou passe o seu valor através de useDeferredValue: o React renderiza então essa parte após o frame e pode interrompê-la se o visitante voltar a tocar no ecrã. Numa loja React em que trabalhei, um clique no filtro de produtos voltava a renderizar toda a lista de produtos; a solução foi memoizar a lista e colocar a atualização do filtro em startTransition. Mantenha fora de uma transição o valor de um campo onde o visitante escreve; essa atualização tem de continuar urgente. useOptimistic (React 19) mostra o resultado de uma ação de imediato enquanto o request corre.
"Highlight updates when components render" nas React DevTools mostra o que um único clique renderiza. Em outras frameworks a ideia é a mesma: a alteração visível primeiro, a atualização pesada após o frame.
O toque fica mais rápido após a alteração?
Grave novamente o mesmo toque com a mesma configuração de CPU: o detalhe do INP mostra uma processing duration curta, e o trabalho que moveu corre na sua própria tarefa após o frame. Para visitantes reais, a parcela de processamento do elemento que alterou cai no CoreDash poucos dias após a mudança, enquanto o Search Console demora até 28 dias.
O tempo também pode passar para outra parte: o trabalho movido para requestAnimationFrame surge como presentation delay, e um único bloco longo após o frame surge como o input delay do toque seguinte.
Por vezes, o listener lento está num plugin, numa aplicação ou numa tag que não pode alterar, ou o trace mostra o render de uma framework que não consegue associar a um componente específico. Numa Core Web Vitals power hour gravamos juntos esse toque na sua página, e fica a saber exatamente que código retirar do clique e quem o pode alterar.

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
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 URLSem programador para fazer o fix? Faço eu o trabalho, numa cópia do seu site.