Next.js 15 Fullstack (App Router + Server Actions) · Aula

Optando por não usar cache: renderização dinâmica e no-store

Force o comportamento dinâmico com cookies, cabeçalhos e a diretiva no-store quando o armazenamento em cache for inadequado.

Aula 4 de 413 etapas

Optando por não usar cache: renderização dinâmica e no-store é uma aula grátis de Next.js 15 Fullstack (App Router + Server Actions) no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Next.js 15 Fullstack (App Router + Server Actions), e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Next.js 15 Fullstack (App Router + Server Actions) inclui 4 aulas no total.

Partes desta aula ainda não foram traduzidas e aparecem em inglês.

When Caching Is Wrong

By default, Next.js 15 tries to make your routes static at build time and cache data aggressively. That is great for marketing pages, but wrong for things that must reflect the current request.

A dashboard showing the logged-in user's data
A page that reads the request's cookies() or headers()
Prices, inventory, or notifications that change every second

This lesson is about opting out of caching: forcing dynamic rendering and disabling fetch caching with no-store.

Static vs Dynamic Rendering

A route is rendered in one of two modes:

Static: rendered once (at build, or in the background) and the HTML/data is reused for everyone.
Dynamic: rendered fresh on every request, so it can read per-request input.

Next.js decides automatically. The moment your code touches a Dynamic API (cookies(), headers(), searchParams) or an uncached fetch, the route switches to dynamic. You rarely flip it manually — you opt out of caching and the renderer follows.

cookies() Forces Dynamic

Reading cookies() inside a Server Component signals that the output depends on the incoming request. In Next.js 15 these APIs are async — you must await them.

Touching cookies() at all moves the route to dynamic rendering. There is no way to read a cookie statically, because a static page has no request to read from.

import { cookies } from 'next/headers';

export default async function DashboardPage() {
  const cookieStore = await cookies();
  const theme = cookieStore.get('theme')?.value ?? 'light';

  // Reading cookies() opts this page out of static rendering
  return <main data-theme={theme}>Welcome back</main>;
}

headers() Forces Dynamic Too

Like cookies, headers() is async in Next.js 15 and reading it forces dynamic rendering. Use it when output depends on request headers such as Authorization, User-Agent, or a geo header from your CDN.

Because the header value is per-request, the page can never be cached as a single static HTML for all users.

import { headers } from 'next/headers';

export default async function GreetingPage() {
  const headerList = await headers();
  const country = headerList.get('x-vercel-ip-country') ?? 'unknown';

  return <h1>Hello from {country}</h1>;
}

fetch with cache: 'no-store'

Next.js extends the native fetch with caching options. By default a fetch result may be cached, which is wrong for always-fresh data.

Pass cache: 'no-store' to bypass the cache entirely. Every render performs a real network request, and the route becomes dynamic.

cache: 'no-store' → never cache, always refetch
cache: 'force-cache' → cache indefinitely (the old default)

async function getLivePrice(symbol: string) {
  const res = await fetch(`https://api.example.com/price/${symbol}`, {
    cache: 'no-store',
  });
  return res.json() as Promise<{ price: number }>;
}

export default async function PricePage() {
  const { price } = await getLivePrice('BTC');
  return <p>Current price: {price}</p>;
}

next: { revalidate: 0 } Is the Same

There are two equivalent ways to disable caching on a single fetch:

{ cache: 'no-store' }
{ next: { revalidate: 0 } }

Both mean "do not serve this from cache." Prefer cache: 'no-store' for readability. Do not combine cache: 'force-cache' with revalidate: 0 — those conflict, and Next.js will warn.

// These two calls behave identically
await fetch(url, { cache: 'no-store' });
await fetch(url, { next: { revalidate: 0 } });

Route Segment: dynamic = 'force-dynamic'

Instead of opting out per fetch, you can opt out for an entire route segment using the route segment config. Exporting dynamic = 'force-dynamic' from a page.tsx or layout.tsx forces every render to be dynamic and disables the data cache for that segment.

Use this when most data on the page must be fresh, so you do not have to annotate each fetch individually.

// app/feed/page.tsx
export const dynamic = 'force-dynamic';

export default async function FeedPage() {
  // No need for cache: 'no-store' on each fetch —
  // the whole segment is dynamic
  const res = await fetch('https://api.example.com/feed');
  const items = await res.json();
  return <ul>{items.map((i: { id: string; text: string }) => <li key={i.id}>{i.text}</li>)}</ul>;
}

fetchCache: 'default-no-store'

A subtler knob is fetchCache. Setting fetchCache = 'default-no-store' changes the default for every fetch in the segment to no-store, while still letting an individual fetch opt back in with cache: 'force-cache'.

This is handy for an authenticated area where almost everything is per-user, but a few public lookups can still be cached.

// app/(app)/layout.tsx
export const fetchCache = 'default-no-store';

// Now any plain fetch() in this segment defaults to no-store.
// Opt back in explicitly when you want caching:
// await fetch(url, { cache: 'force-cache' });

Dynamic APIs in Route Handlers

Route Handlers (route.ts) follow the same rules. A GET handler can be cached unless it reads a Dynamic API or you opt out.

Reading request.url search params, or calling cookies()/headers(), makes the handler dynamic. You can also force it with export const dynamic = 'force-dynamic'.

// app/api/me/route.ts
import { cookies } from 'next/headers';
import { NextResponse } from 'next/server';

export const dynamic = 'force-dynamic';

export async function GET() {
  const session = (await cookies()).get('session')?.value;
  if (!session) {
    return NextResponse.json({ error: 'unauthorized' }, { status: 401 });
  }
  return NextResponse.json({ user: session });
}

Server Actions Are Always Dynamic

Server Actions run in response to a user interaction, so they are inherently dynamic — they are never statically cached. They read the cache and can invalidate it, but the action body itself always executes fresh.

After mutating data in an action, call revalidatePath or revalidateTag so cached pages refetch. The action does not need no-store itself.

'use server';
import { revalidatePath } from 'next/cache';

export async function addComment(postId: string, text: string) {
  await db.comment.create({ data: { postId, text } });
  // Force the post page to refetch its (otherwise cached) data
  revalidatePath(`/posts/${postId}`);
}

Don't Reach for no-store Too Early

Opting out of caching is a real performance cost: every request hits your origin and database. Before forcing dynamic everywhere, ask whether time-based revalidation would do.

Data fresh within a few seconds → next: { revalidate: 5 }
Data must reflect this exact request → no-store / dynamic
Data changes on a known event → cache + revalidateTag on mutation

Use no-store when correctness truly depends on per-request freshness — not as a reflex to "make it work."

Quick Check

Test your understanding of opting out of caching in Next.js 15.

Responda na aula interativa

Recap

You learned how to opt out of caching when it would be wrong:

Dynamic APIs — awaiting cookies() or headers() automatically forces dynamic rendering.
Per-fetch — cache: 'no-store' (or next: { revalidate: 0 }) skips the data cache.
Per-segment — export const dynamic = 'force-dynamic' makes the whole route dynamic; fetchCache = 'default-no-store' changes the default per fetch.
Route Handlers follow the same rules; Server Actions are always dynamic and invalidate caches with revalidatePath/revalidateTag.
Restraint — prefer time-based or tag-based revalidation; reach for no-store only when correctness needs per-request freshness.

Grátis para começar

Aprenda TypeScript com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos: 22
Aulas: 88

Começar a aprender grátis Ver o curso completo

Perguntas Frequentes

A aula “Optando por não usar cache: renderização dinâmica e no-store” é grátis?

Sim — o texto completo de “Optando por não usar cache: renderização dinâmica e no-store” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Next.js 15 Fullstack (App Router + Server Actions), atualize para CoddyKit PRO. O curso de Next.js 15 Fullstack (App Router + Server Actions) inclui 4 aulas no total.

O que vou aprender em “Optando por não usar cache: renderização dinâmica e no-store”?

Force o comportamento dinâmico com cookies, cabeçalhos e a diretiva no-store quando o armazenamento em cache for inadequado. Você pratica Next.js 15 Fullstack (App Router + Server Actions) com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Next.js 15 Fullstack (App Router + Server Actions)?

Nenhuma experiência prévia é necessária. Next.js 15 Fullstack (App Router + Server Actions) no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Optando por não usar cache: renderização dinâmica e no-store”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Next.js 15 Fullstack (App Router + Server Actions)?

Sim. Cada aula de Next.js 15 Fullstack (App Router + Server Actions) inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

Os quatro caches: requisição, dados, rota completa e roteador
Estratégias de revalidação por tempo e sob demanda
Invalidação por tags para atualização granular do cache
Optando por não usar cache: renderização dinâmica e no-store

← Voltar para Next.js 15 Fullstack (App Router + Server Actions)