# Scripts de terceiros: 108 ms de handshake por domínio novo

Um critério numérico para decidir o que sai, o que vira arquivo local e o que só carrega depois do primeiro toque, com o processo para repetir isso em toda a carteira.

> cada conexão HTTPS nova custou cerca de 108 ms só de handshake TLS na nossa medição (108,7 ms no TLS 1.2 e 107,6 ms no TLS 1.3, amostra 100, servidor LiteSpeed no Brasil). É um piso de referência: meça cada terceiro, corte o que ninguém consulta e adie o resto.

João Rizzon · 2026-09-19 · WordPress

---

Um cliente abre um ticket dizendo que a home está lenta e aponta a foto do topo. Você abre o DevTools e a foto é o menor dos problemas: a página chama fonte do Google, pixel do Meta, tag do Analytics, widget de chat, mapa incorporado, player de vídeo e um selo de reputação. Sete domínios diferentes. Cada um deles cobra um pedágio que não aparece em nenhuma auditoria de "otimize suas imagens".

O pedágio é a conexão nova. E ele tem preço medido.

## O custo fixo que nenhum protocolo elimina

Antes de baixar um único byte de um domínio novo, o navegador precisa resolver o DNS, abrir o TCP e negociar o TLS. Só a parte do TLS, medida como a diferença entre `time_appconnect` e `time_connect` do curl, ficou em **108,7 ms no TLS 1.2 e 107,6 ms no TLS 1.3** (mediana, amostra de 100 conexões, setembro de 2026) contra um servidor LiteSpeed no Brasil, a partir de um ponto de medição também no Brasil.

Os dois números importam menos pela diferença do que pelo empate. A conversa de "habilita TLS 1.3 que fica mais rápido" não sobrevive a essa comparação: o custo não está na versão do protocolo, está no fato de existir uma conexão nova. E cada domínio de terceiro na sua página é, por definição, uma conexão nova.

Três consequências práticas:

- HTTP/2 e HTTP/3 multiplexam requisições **por origem**. Dez arquivos do seu próprio domínio dividem uma conexão. Um arquivo de cada um de dez domínios abre dez conexões.
- `preconnect` não remove o handshake, apenas o antecipa. Serve para duas ou três origens que você sabe que serão usadas logo. Usado em dez origens, vira disputa de banda no pior momento do carregamento.
- HTTP/3 reduz as idas e voltas do aperto de mão, mas continua exigindo resolução de DNS e negociação de certificado com um host que o navegador nunca viu.

Um aviso sobre o alcance desse número: 108 ms é o que medimos em uma rota curta e favorável, do Brasil para um servidor no Brasil. Serve como piso de referência, não como o custo de qualquer terceiro. Um domínio externo pode custar bem mais (edge distante, cadeia de certificado longa, DNS lento) ou um pouco menos se o navegador já tiver a origem aquecida. Não meça o terceiro pelo nosso número: meça o terceiro. O nosso número serve para você saber a ordem de grandeza do que está em jogo antes de abrir o curl.

**108 ms** custo mediano do handshake TLS por conexão HTTPS nova até um servidor LiteSpeed no Brasil: 108,7 ms no TLS 1.2 e 107,6 ms no TLS 1.3, um empate na prática que mostra que o custo real é a conexão nova existir, não a versão do protocolo (n=100, setembro de 2026)

## Como listar os domínios de terceiros que a página chama

A decisão começa por uma lista, não por uma opinião. Duas fontes, porque nenhuma das duas é completa sozinha.

### O que aparece no HTML servido

Pega o que vem no documento inicial, que é justamente o que bloqueia mais:

```bash
curl -sL https://site-do-cliente.com.br/ \
  | grep -Eo 'https://[a-zA-Z0-9.-]+' \
  | sed 's|https://||' \
  | sort | uniq -c | sort -rn
```

Saída típica: contagem de referências por host. O host do próprio site aparece no topo e você ignora. O resto é a sua lista de trabalho.

Limitação honesta: isso só vê o HTML. Tag manager que injeta quatro scripts em tempo de execução aparece como um domínio e esconde os outros quatro.

### O que o navegador realmente conectou

No DevTools, aba Network, com cache desativado e o filtro em `Doc, JS, CSS, XHR`. Agrupe pela coluna Domain. O que você quer contar é **hosts distintos**, não requisições. Trinta arquivos do seu domínio custam uma conexão. Três arquivos de três domínios custam três handshakes.

No WebPageTest, a visão Connection View mostra cada conexão com a faixa do TLS separada. É o print que você anexa no relatório para o cliente.

### Medir o handshake de cada host com curl

Com a lista em mão, o custo de cada origem sai em um comando:

```bash
curl -o /dev/null -s -w \
  "dns:%{time_namelookup} tcp:%{time_connect} tls:%{time_appconnect} ttfb:%{time_starttransfer}\n" \
  https://widget-de-chat.exemplo.com/
```

O handshake TLS é `time_appconnect - time_connect`. Rode três ou quatro vezes e use a mediana, porque a primeira execução carrega o custo de DNS frio.

Se quiser confirmar que a versão do protocolo não é a variável, force cada uma:

```bash
# TLS 1.2
curl --tlsv1.2 --tls-max 1.2 -o /dev/null -s -w "tls12:%{time_appconnect}\n" https://exemplo.com/
# TLS 1.3
curl --tlsv1.3 -o /dev/null -s -w "tls13:%{time_appconnect}\n" https://exemplo.com/
```

## Classificar cada domínio em corta, local ou pós-interação

Com a lista de hosts e o custo aproximado de cada um, a decisão deixa de ser estética. Três destinos possíveis, e só três:

| Destino | Quando se aplica | O que acontece com o handshake |
|---|---|---||
| **Corta** | Ninguém consulta o dado, o widget não tem meta, o selo é decorativo, a tag é de campanha encerrada | Desaparece |
| **Hospeda local** | Arquivo estático versionado: fonte, CSS de biblioteca, ícone, logo de parceiro | Vira requisição na conexão que já existe |
| **Carrega depois da interação** | Chat, mapa, player de vídeo, remarketing, review widget | Sai do caminho crítico e só é pago por quem interage |

O critério de corte que funciona na conversa com o cliente é uma pergunta única: **quem olha esse dado, e com que frequência?** Pixel de uma campanha que acabou em março, heatmap instalado numa consultoria de 2022, selo de "site seguro" que ninguém clica. Cada um desses custa uma conexão nova em toda visita, todo dia, para sempre.

Cuidado com duas armadilhas de classificação:

- **Consentimento e privacidade.** Pixel de publicidade e ferramenta de gravação de sessão precisam de base legal e, em muitos casos, de consentimento. Se o script já é carregado só depois do aceite no banner, ele já está fora do caminho crítico e não é onde está o seu ganho.
- **Tag manager.** Não é um domínio, é uma porta. Corte dentro dele, no container, antes de mexer no tema. É mais rápido e o cliente consegue reverter sozinho.

## Executar os três destinos no WordPress

### O que cortar inteiro e como achar a chamada

Plugin que injeta script de terceiro sem entregar função visível sai inteiro. Antes de desativar, procure a chamada:

```bash
# dentro de wp-content, achar quem chama o domínio
grep -rIl "dominio-do-terceiro.com" wp-content/plugins wp-content/themes
```

Se a chamada estiver no tema, o lugar é um child theme ou um plugin de site específico, nunca o `functions.php` do tema pai.

Dois cortes de higiene que valem em quase toda instalação e custam um minuto cada. Seja preciso sobre o ganho, porque nenhum dos dois é um handshake de terceiro garantido:

- **Detector de emoji.** Em navegador moderno o detector confirma o suporte nativo e o arquivo do twemoji quase nunca é baixado, então o que você remove é o script inline no `head` e uma requisição eventual. Só vira conexão nova em navegador sem suporte nativo.
- **`wp-embed.min.js`.** É servido do seu próprio domínio, então o ganho é uma requisição e alguns kilobytes, zero handshake. Só remova se o site não incorpora posts de outro WordPress, que é o único caso em que o script faz algo. O iframe de YouTube ou de rede social continua ali e é tratado com fachada, na seção seguinte.

```php
// 1. detector de emoji: script inline no head e folha de estilo associada
// (a chamada ao CDN de twemoji só ocorreria em navegador sem emoji nativo)
remove_action( 'wp_head', 'print_emoji_detection_script', 7 );
remove_action( 'wp_print_styles', 'print_emoji_styles' );

// 2. wp-embed: só faz o redimensionamento de embeds de outro WordPress
add_action( 'wp_footer', function () {
    wp_dequeue_script( 'wp-embed' );
}, 1 );
```

Valide os dois no HTML servido, não no navegador com cache:

```bash
curl -sL https://site-do-cliente.com.br/ | grep -c -E 'wp-emoji|wp-embed.min.js'
```

Zero é o resultado esperado. Se voltar 1 ou mais, algum plugin está reenfileirando depois de você e a correção é ajustar a prioridade.

### O que hospedar no próprio domínio

Fonte web é o caso mais fácil e o de melhor retorno. Baixe os arquivos `woff2`, coloque em `wp-content/themes/seu-child/fonts/`, escreva o `@font-face` com `font-display: swap` e remova o enfileiramento remoto:

```php
add_action( 'wp_enqueue_scripts', function () {
    wp_dequeue_style( 'handle-da-fonte-remota' );
    wp_enqueue_style(
        'fontes-locais',
        get_stylesheet_directory_uri() . '/css/fontes.css',
        [],
        '1.0'
    );
}, 100 );
```

O handle certo você descobre na lista de estilos enfileirados: quase todo tema comercial registra a fonte com um nome previsível, e o `grep` da seção anterior mostra qual arquivo faz o `wp_enqueue_style`.

Depois de hospedar local, confira o cabeçalho de cache do arquivo, porque fonte servida sem `Cache-Control` longo troca um handshake por um revalidate:

```bash
curl -sI https://site-do-cliente.com.br/wp-content/themes/child/fonts/inter.woff2 \
  | grep -i -E 'cache-control|expires|content-type'
```

### O que carregar só depois da primeira interação

Para chat, mapa e player, a técnica é a mesma: uma fachada leve que ocupa o espaço no layout e o script real só entra no primeiro sinal de interação.

```html
<script>
(function () {
  var carregado = false;
  function carregar() {
    if (carregado) return;
    carregado = true;
    var s = document.createElement('script');
    s.src = 'https://widget.exemplo.com/chat.js';
    s.async = true;
    document.body.appendChild(s);
  }
  ['scroll', 'mousemove', 'touchstart', 'keydown'].forEach(function (ev) {
    window.addEventListener(ev, carregar, { once: true, passive: true });
  });
})();
</script>
```

Para o botão de chat, prefira disparar no clique de um botão seu, desenhado igual ao do widget. O usuário espera o carregamento porque ele mesmo pediu, e a home não paga nada.

Para vídeo, uma imagem de capa com play que substitui o `iframe` no clique resolve, e os principais plugins de performance já têm essa opção pronta com o nome de lazy load de iframe ou de placeholder de vídeo. Quando o plugin faz, não escreva código.

Uma ressalva contra o próprio hábito: mapa incorporado na página de contato costuma ser o conteúdo principal daquela URL. Ali, fachada com clique é ótimo; remover é prejuízo.

## Provar o ganho por hosts distintos e handshake somado

Medir só o Lighthouse não serve, porque a nota oscila e o cliente não confia. Meça o que você mudou, que é **quantidade de origens** e **tempo de handshake somado**.

| Métrica | Como obter | O que significa |
|---|---|---||
| Hosts distintos | DevTools, Network, coluna Domain, contagem de valores únicos | Número de handshakes na primeira visita |
| Handshake por host | `time_appconnect - time_connect` no curl | Custo unitário da origem |
| Conexões no caminho crítico | Connection View do WebPageTest, faixas antes do LCP | O que realmente atrasa a pintura |
| LCP de campo | Search Console, relatório de Core Web Vitals | Se o ganho existiu para usuário real |

Registre a contagem de hosts antes e depois no mesmo documento. Sair de sete origens para três é uma frase que o cliente entende, e é verificável por ele em qualquer teste público.

Uma advertência: laboratório com conexão boa esconde o ganho. O handshake dói em rede móvel e em RTT alto, onde cada ida e volta se multiplica. Se você só testar do seu link de fibra, vai concluir que não valeu a pena. Rode uma vez com throttling de 4G no DevTools para ver o tamanho real do que você removeu.

## Padronizar na carteira de clientes

O ganho de fazer isso uma vez é pequeno. O ganho de fazer isso em quarenta sites, sempre igual, paga o mês. Só não misture as etapas: o diagnóstico cabe em uma janela curta e depende só de você, a execução depende de aprovação e de janela de manutenção.

### Diagnóstico de 15 minutos por site

- Rodar o `curl | grep` do inventário e salvar a saída datada.
- Contar hosts distintos no DevTools com cache desativado.
- Medir o handshake dos três hosts mais caros, com mediana de três execuções.
- Classificar cada host em corta, hospeda local ou pós-interação, em uma coluna de proposta.

No fim desses 15 minutos você tem um documento pronto para enviar, não uma mudança feita.

### Aceite do cliente por escrito antes de qualquer corte

Mande a lista classificada com uma pergunta por linha: quem consulta essa ferramenta e com que frequência. A resposta vem por escrito, no prazo do cliente, e é ela que autoriza o corte. Sem esse registro, você desativa o pixel que a agência de mídia instalou na véspera e a conversa vira outra.

### Execução em janela própria, um item por vez

Um item por vez, com teste de página entre cada mudança, e a contagem de hosts registrada antes e depois. Reserve de 30 a 60 minutos por site conforme a quantidade de itens aprovados. Cortes dentro do tag manager costumam sair primeiro porque são reversíveis pelo próprio cliente.

### A planilha da carteira

Uma linha por site, colunas fixas: domínio, data da última checagem, hosts distintos, host mais caro, handshake do host mais caro, pendências, quem aprovou o corte. Ordene por número de hosts e ataque de cima para baixo. É o mesmo princípio de uma lista de plugins desatualizados: o valor está em ser periódica, não em ser profunda.

Cadência que funciona sem virar peso: checagem no onboarding, depois a cada trimestre, e obrigatoriamente depois de qualquer campanha de mídia, que é quando aparecem pixels novos sem aviso.

### A regra de contrato que impede o retorno das tags

Coloque no escopo de manutenção que toda tag de terceiro nova passa por você, com nome do responsável e data de expiração. Sem isso, você limpa em janeiro e em março estão de volta seis domínios que ninguém sabe explicar.

## A frase pronta para o cliente

O cliente comparou errado, não por má fé, mas porque a metáfora do "peso" é a única que ele tem. Troque a metáfora:

> **** A foto da home é um download: entra na fila junto com o resto do site, vem do mesmo servidor e depois fica guardada no navegador de quem já visitou. O widget de chat é um endereço novo. Antes de baixar qualquer coisa, o navegador precisa descobrir onde fica esse endereço, abrir uma conexão e negociar o certificado de segurança. Num teste nosso, com servidor perto, só essa negociação custou por volta de 108 ms por endereço, e com o servidor longe custa mais. Sua página chama sete endereços diferentes. É mais que a foto, e é pago outra vez em toda visita nova.

Se precisar de uma versão de uma linha para mensagem: "não é o tamanho do arquivo, é a quantidade de servidores diferentes que a sua página precisa apresentar ao navegador antes de aparecer".

E quando o cliente insistir em manter o widget, a resposta não é não. É: "mantemos, mas ele passa a carregar quando a pessoa rola ou toca na tela, porque aí ela já está lendo o site e não percebe". Você entrega a função e não paga o handshake na hora errada.

## O que esse corte não resolve

Cortar terceiros não conserta servidor lento. Se o TTFB do próprio HTML está alto, a página demora a começar e nenhuma conexão economizada aparece no resultado. A ordem certa é: primeiro o tempo até o primeiro byte do seu domínio (cache de página, consulta lenta no banco, plugin que faz chamada externa no `init`), depois o orçamento de conexões de terceiro, depois imagem e CSS.

Também não resolve script de terceiro **pesado**. Tirar o domínio do caminho crítico evita o handshake, mas se o arquivo tem centenas de kilobytes de JavaScript que executa na thread principal, ele continua travando a interação quando for carregado. Fachada com interação empurra o custo para depois; não faz o custo sumir.

E não existe ganho garantido. Já vi caso em que remover quatro origens decorativas mudou muito pouco no LCP, porque o gargalo era uma imagem de herói sem dimensão declarada e sem `fetchpriority`. Meça antes de prometer. O número que você tem em mãos, cerca de 108 ms de handshake por conexão nova em uma rota curta dentro do Brasil, é um argumento sólido para o inventário e para o corte, não uma garantia de nota 90 no PageSpeed nem uma constante que valha para qualquer terceiro.

---

## Como medimos

100 conexões HTTPS novas de um VPS externo a um servidor LiteSpeed da Napoleon: 50 negociando TLS 1.2 e 50 negociando TLS 1.3. Em cada conexão o curl registrou time_connect (fim do TCP) e time_appconnect (fim do TLS); o custo do handshake é a diferença entre os dois, isolando o TLS do TCP. Medianas: 108,7 ms no TLS 1.2 e 107,6 ms no TLS 1.3.
