Links e navegação
No Next.js, as rotas são renderizadas no servidor por padrão. Isso costuma significar que o cliente precisa esperar a resposta do servidor antes que uma nova rota possa ser exibida. O Next.js vem com prefetching, streaming e transições no lado do cliente integrados, garantindo que a navegação continue rápida e responsiva.
Este guia explica como a navegação funciona no Next.js e como você pode otimizá-la para rotas dinâmicas e redes lentas.
Como a navegação funciona
Para entender como a navegação funciona no Next.js, é útil conhecer os seguintes conceitos:
Server Rendering
No Next.js, Layouts e Pages são React Server Components por padrão. Na navegação inicial e nas subsequentes, o Server Component Payload é gerado no servidor antes de ser enviado ao cliente.
Existem dois tipos de renderização no servidor, de acordo com quando ela acontece:
- Prerendering acontece durante o build ou durante a revalidação, e o resultado fica em cache.
- Dynamic Rendering acontece no momento da requisição, em resposta a uma solicitação do cliente.
A desvantagem da renderização no servidor é que o cliente precisa esperar a resposta do servidor antes que a nova rota possa ser exibida. O Next.js reduz esse atraso fazendo prefetching das rotas que o usuário provavelmente vai visitar e executando transições no lado do cliente.
Bom saber: o HTML também é gerado na primeira visita.
Prefetching
Prefetching é o processo de carregar uma rota em segundo plano, antes de o usuário navegar até ela. Isso faz a navegação entre as rotas do seu app parecer instantânea, porque, quando o usuário clica em um link, os dados para renderizar a próxima rota já estão disponíveis no cliente.
O Next.js faz prefetch automaticamente das rotas ligadas pelo componente <Link> quando elas entram na área visível da tela do usuário.
import Link from 'next/link'
export default function Layout({ children }: { children: React.ReactNode }) {
return (
<html>
<body>
<nav>
{/* Prefetched when the link is hovered or enters the viewport */}
<Link href="/blog">Blog</Link>
{/* No prefetching */}
<a href="/contact">Contact</a>
</nav>
{children}
</body>
</html>
)
}import Link from 'next/link'
export default function Layout({ children }) {
return (
<html>
<body>
<nav>
{/* Prefetched when the link is hovered or enters the viewport */}
<Link href="/blog">Blog</Link>
{/* No prefetching */}
<a href="/contact">Contact</a>
</nav>
{children}
</body>
</html>
)
}Quanto da rota passa por prefetch depende de ela ser estática ou dinâmica:
- Rota estática: a rota inteira recebe prefetching.
- Rota dinâmica: o prefetching é ignorado, ou a rota recebe prefetching parcial se o
loading.tsxexistir.
Ao pular o prefetching das rotas dinâmicas, ou fazê-lo parcialmente, o Next.js evita trabalho desnecessário no servidor para rotas que o usuário pode nunca visitar. No entanto, esperar a resposta do servidor antes da navegação pode dar a impressão de que o app não está respondendo.

Bom saber: veja o guia de prefetching para o comportamento completo, incluindo como controlar o prefetching por link e como ele muda ao adotar o Partial Prefetching. Para incluir conteúdo que depende da URL no prefetch de um link, veja otimizando o prefetching.
Para melhorar a experiência de navegação até rotas dinâmicas, você pode usar streaming.
Streaming
O streaming permite que o servidor envie partes de uma rota dinâmica ao cliente assim que estiverem prontas, em vez de esperar a rota inteira ser renderizada. Assim, o usuário vê algo mais cedo, mesmo que partes da página ainda estejam carregando. Veja o guia de streaming para entender em detalhes como o streaming funciona no Next.js.
Para rotas dinâmicas, isso significa que elas podem receber prefetching parcial. Ou seja, layouts compartilhados e esqueletos de carregamento podem ser requisitados com antecedência.

Para usar streaming, crie um loading.tsx na pasta da sua rota:

export default function Loading() {
// Add fallback UI that will be shown while the route is loading.
return <LoadingSkeleton />
}export default function Loading() {
// Add fallback UI that will be shown while the route is loading.
return <LoadingSkeleton />
}Nos bastidores, o Next.js envolve automaticamente o conteúdo de page.tsx em um limite de <Suspense>. A interface de fallback que passou por prefetch aparece enquanto a rota carrega e dá lugar ao conteúdo real assim que estiver pronto.
Bom saber: você também pode usar
<Suspense>para criar interfaces de carregamento para componentes aninhados.
Benefícios do loading.tsx:
- Navegação imediata e retorno visual para o usuário.
- Layouts compartilhados continuam interativos e a navegação pode ser interrompida.
- Melhores Core Web Vitals: TTFB, FCP e TTI.
Para melhorar ainda mais a experiência de navegação, o Next.js faz uma transição no lado do cliente com o componente <Link>.
Transições no lado do cliente
Tradicionalmente, navegar até uma página renderizada no servidor dispara um carregamento completo da página. Isso limpa o estado, reinicia a posição de rolagem e bloqueia a interatividade.
O Next.js evita isso com transições no lado do cliente usando o componente <Link>. Em vez de recarregar a página, ele atualiza o conteúdo dinamicamente:
- Mantendo os layouts e a interface compartilhados.
- Substituindo a página atual pela interface de carregamento que passou por prefetch, ou por uma nova página, se ela estiver disponível.
As transições no lado do cliente fazem apps renderizados no servidor parecerem apps renderizados no cliente. E, combinadas com prefetching e streaming, elas permitem transições rápidas, mesmo para rotas dinâmicas.
O Next.js também cuida de rolar até o topo da página durante as transições no lado do cliente. Se o conteúdo rolar por trás de um cabeçalho fixo ou sticky após a navegação, você pode corrigir isso com o CSS scroll-padding-top.
O que pode deixar as transições lentas?
Essas otimizações do Next.js tornam a navegação rápida e responsiva. Porém, em certas condições, as transições ainda podem parecer lentas. Aqui estão algumas causas comuns e como melhorar a experiência do usuário:
Rotas dinâmicas sem loading.tsx
Ao navegar até uma rota dinâmica, o cliente precisa esperar a resposta do servidor antes de mostrar o resultado. Isso pode dar a impressão de que o app não está respondendo.
Recomendamos adicionar loading.tsx às rotas dinâmicas para habilitar o prefetching parcial, disparar a navegação imediata e exibir uma interface de carregamento enquanto a rota é renderizada.
export default function Loading() {
return <LoadingSkeleton />
}export default function Loading() {
return <LoadingSkeleton />
}Bom saber: no modo de desenvolvimento, você pode usar as Devtools do Next.js para identificar se a rota é estática ou dinâmica. Veja
devIndicatorspara mais informações.
Segmentos dinâmicos sem generateStaticParams
Se um segmento dinâmico poderia ser prerendered, mas não é, porque não tem generateStaticParams, a rota volta para o Dynamic Rendering no momento da requisição.
Garanta que a rota seja gerada estaticamente no build adicionando generateStaticParams:
export async function generateStaticParams() {
const posts = await fetch('https://.../posts').then((res) => res.json())
return posts.map((post) => ({
slug: post.slug,
}))
}
export default async function Page({
params,
}: {
params: Promise<{ slug: string }>
}) {
const { slug } = await params
// ...
}export async function generateStaticParams() {
const posts = await fetch('https://.../posts').then((res) => res.json())
return posts.map((post) => ({
slug: post.slug,
}))
}
export default async function Page({ params }) {
const { slug } = await params
// ...
}Redes lentas
Em redes lentas ou instáveis, o prefetching pode não terminar antes de o usuário clicar em um link. Isso pode afetar tanto rotas estáticas quanto dinâmicas. Nesses casos, o fallback loading.js pode não aparecer imediatamente, porque ainda não passou por prefetch.
Para melhorar a percepção de desempenho, você pode usar o hook useLinkStatus para mostrar um retorno imediato enquanto a transição está em andamento.
'use client'
import { useLinkStatus } from 'next/link'
export default function LoadingIndicator() {
const { pending } = useLinkStatus()
return (
<span aria-hidden className={`link-hint ${pending ? 'is-pending' : ''}`} />
)
}'use client'
import { useLinkStatus } from 'next/link'
export default function LoadingIndicator() {
const { pending } = useLinkStatus()
return (
<span aria-hidden className={`link-hint ${pending ? 'is-pending' : ''}`} />
)
}Você pode "atrasar" a dica adicionando uma animação com atraso inicial (por exemplo, 100ms) e começando invisível (por exemplo, opacity: 0). Assim, o indicador de carregamento só aparece se a navegação demorar mais que o atraso definido. Veja a referência de useLinkStatus para um exemplo em CSS.
Bom saber: um hook experimental chamado
useOfflinepode manter navegáveis as rotas que passaram por prefetch durante quedas de conexão. Veja o guia de suporte offline.
Bom saber: você pode usar outros padrões de feedback visual, como uma barra de progresso. Veja um exemplo aqui.
Desativando o prefetching
Você pode desativar o prefetching definindo a prop prefetch como false no componente <Link>. Isso é útil para evitar o uso desnecessário de recursos ao renderizar listas grandes de links (por exemplo, uma tabela com rolagem infinita).
<Link prefetch={false} href="/blog">
Blog
</Link>No entanto, desativar o prefetching tem custos:
- Rotas estáticas só serão buscadas quando o usuário clicar no link.
- Rotas dinâmicas precisarão ser renderizadas no servidor antes que o cliente possa navegar até elas.
Para reduzir o uso de recursos sem desativar totalmente o prefetching, você pode fazer prefetch apenas ao passar o mouse. Isso limita o prefetching às rotas que o usuário tem mais probabilidade de visitar, em vez de todos os links visíveis na tela.
'use client'
import Link from 'next/link'
import { useState } from 'react'
function HoverPrefetchLink({
href,
children,
}: {
href: string
children: React.ReactNode
}) {
const [active, setActive] = useState(false)
return (
<Link
href={href}
prefetch={active ? null : false}
onMouseEnter={() => setActive(true)}
>
{children}
</Link>
)
}'use client'
import Link from 'next/link'
import { useState } from 'react'
function HoverPrefetchLink({ href, children }) {
const [active, setActive] = useState(false)
return (
<Link
href={href}
prefetch={active ? null : false}
onMouseEnter={() => setActive(true)}
>
{children}
</Link>
)
}Hydration não concluída
<Link> é um Client Component e precisa passar por hydration antes de poder fazer prefetch de rotas. Na primeira visita, bundles grandes de JavaScript podem atrasar a hydration, impedindo que o prefetching comece logo.
O React mitiga isso com Selective Hydration, e dá para melhorar ainda mais:
- Usando o plugin
@next/bundle-analyzerpara identificar e reduzir o tamanho do bundle, removendo dependências grandes. - Movendo a lógica do cliente para o servidor sempre que possível. Veja a documentação de Server e Client Components para orientações.
Exemplos
API nativa de History
O Next.js permite usar os métodos nativos window.history.pushState e window.history.replaceState para atualizar o histórico do navegador sem recarregar a página.
O Next.js integra as chamadas de pushState e replaceState ao roteador, então os componentes que renderizam com usePathname ou useSearchParams são atualizados quando a URL muda. Quando um manipulador de evento é o único lugar em que um componente precisa da URL, leia window.location dentro do manipulador em vez de chamar usePathname ou useSearchParams. Os dois hooks afetam o prerendering.
Bom saber:
pushStateereplaceStateatualizam owindow.locationde forma síncrona, enquanto o Next.js agenda as atualizações deusePathnameeuseSearchParamsem uma Transition do React. Atualizações de estado local no mesmo manipulador de evento podem aparecer na tela antes de esses hooks refletirem a nova URL.
window.history.pushState
Use-o para adicionar uma nova entrada na pilha de histórico do navegador. O usuário pode voltar ao estado anterior. Por exemplo, para ordenar uma lista de produtos:
'use client'
export default function SortProducts() {
function updateSorting(sortOrder: string) {
const params = new URLSearchParams(window.location.search)
params.set('sort', sortOrder)
window.history.pushState(null, '', `?${params.toString()}`)
}
return (
<>
<button onClick={() => updateSorting('asc')}>Sort Ascending</button>
<button onClick={() => updateSorting('desc')}>Sort Descending</button>
</>
)
}'use client'
export default function SortProducts() {
function updateSorting(sortOrder) {
const params = new URLSearchParams(window.location.search)
params.set('sort', sortOrder)
window.history.pushState(null, '', `?${params.toString()}`)
}
return (
<>
<button onClick={() => updateSorting('asc')}>Sort Ascending</button>
<button onClick={() => updateSorting('desc')}>Sort Descending</button>
</>
)
}window.history.replaceState
Use-o para substituir a entrada atual na pilha de histórico do navegador. O usuário não consegue voltar ao estado anterior. Por exemplo, para trocar o idioma do app:
'use client'
export function LocaleSwitcher() {
function switchLocale(locale: string) {
// e.g. '/en/about' or '/fr/contact'
const newPath = `/${locale}${window.location.pathname}`
window.history.replaceState(null, '', newPath)
}
return (
<>
<button onClick={() => switchLocale('en')}>English</button>
<button onClick={() => switchLocale('fr')}>French</button>
</>
)
}'use client'
export function LocaleSwitcher() {
function switchLocale(locale) {
// e.g. '/en/about' or '/fr/contact'
const newPath = `/${locale}${window.location.pathname}`
window.history.replaceState(null, '', newPath)
}
return (
<>
<button onClick={() => switchLocale('en')}>English</button>
<button onClick={() => switchLocale('fr')}>French</button>
</>
)
}Próximos passos
next/link component.loading.jsAPI reference for the loading.js file.Optimizing prefetchingResolve per-link URL data, include session data in the App Shell, or defer expensive work to a later navigation stage.PrefetchingLearn how to configure prefetching in Next.js