Free tools Windows power users keep installed
One-click scans. No signup required.
For new Next.js App Router code using Cache Components, enable cacheComponents, then put 'use cache' around the route, component, or function whose output is safe to reuse. Set freshness with cacheLife, choose tags or paths for invalidation, and keep request-specific values such as cookies outside the cached scope unless you deliberately pass them in. These patterns apply to the Cache Components model documented by Next.js in February and March 2026; projects using the previous caching model need its separate guidance. Check your installed Next.js version before adopting these APIs.
What changes with Cache Components?
Cache Components make caching an explicit boundary in your application: a 'use cache' directive marks a route, component, or function result as reusable. Enable the model in your Next.js configuration first:
As an Amazon Associate I earn from qualifying purchases.
const nextConfig = {
cacheComponents: true,
};
export default nextConfig;Use the directive only where reusing the output is correct. A public product list may be suitable; output that depends on a user’s identity or permissions needs a deliberate cache key and isolation strategy. Caching is a reuse policy, not a guarantee that every request will be faster.
Cache a function with an appropriate profile
Keep the cached function small and give it an explicit lifetime when the built-in profile does not fit the product’s freshness requirements:
#1 Best Overall
import { cacheLife, cacheTag } from 'next/cache';
export async function getProducts() {
'use cache';
cacheLife('hours');
cacheTag('products');
return db.product.findMany();
}The documented default Cache Components profile allows five minutes of client-router stale time, revalidates on the server after fifteen minutes, and has no time-based expiration. Those are three separate behaviors, not a single fifteen-minute TTL.
How should freshness be configured?
cacheLife controls three different clocks. For a custom profile, give each value an intentional meaning rather than treating the object as one cache duration.
| Setting | What it controls | Question to ask |
|---|---|---|
stale |
How long the client router may use its cached data without contacting the server. | How long can a navigated client continue showing its current result without checking in? |
revalidate |
How frequently the server should refresh the cached result. | How often should the server seek newer data? |
expire |
The maximum time stale content can remain before a request must wait for fresh content. | How long may an old result be served before freshness becomes mandatory? |
For example, a custom profile can make those distinctions visible in code:
Rank #2
cacheLife({
stale: 60,
revalidate: 300,
expire: 3600,
});These values are seconds: the client stale window is one minute, server revalidation is five minutes, and the maximum stale period is one hour. Choose values based on the consequences of stale data—such as whether a delayed inventory update is merely inconvenient or could lead to an invalid purchase—not on a presumed performance gain.
How do you invalidate cached data after a mutation?
Choose the invalidation API based on the update experience and scope you need. Tags identify cached data by relationship; a path identifies a route. Invalidate after the mutation succeeds, not before it has committed.
| API | Use it when | Result to plan for |
|---|---|---|
updateTag(tag) |
A Server Action must make the updated data available immediately. | Use for the immediate-update flow after a successful action. |
revalidateTag(tag, 'max') |
Briefly serving stale data while a refresh happens is acceptable. | The documented 'max' profile uses stale-while-revalidate behavior. |
revalidatePath(path) |
The route itself is the invalidation target. | Targets the specified route path rather than a data relationship shared across routes. |
Use tags for shared data relationships
Attach a tag inside the cached function, as in cacheTag('products') above, or use next.tags on a server-side fetch where appropriate. After a successful mutation, invalidate the tag associated with the affected data:
'use server';
import { updateTag } from 'next/cache';
export async function updateProduct(input) {
await saveProduct(input);
updateTag('products');
}If a short delay is acceptable, use revalidateTag('products', 'max') instead. The single-argument revalidateTag(tag) form is deprecated; use the current API signature supported by your Next.js version.
Use paths when the route is the unit of change
When a mutation changes the content of a specific route and route-level invalidation is the clearest fit, call revalidatePath('/products') after saving. A tag is usually the better boundary when the same data appears in multiple places and those cached results should be invalidated together.
How should request-specific data cross a cache boundary?
Read APIs such as cookies() and headers() outside the cached scope, then pass only the values the cached function needs as arguments. Arguments contribute to distinct cached results, so a locale or tenant identifier can distinguish outputs when it is part of the function call.
import { cookies } from 'next/headers';
async function getLocalizedCatalog(locale) {
'use cache';
return loadCatalog(locale);
}
export default async function Page() {
const cookieStore = await cookies();
const locale = cookieStore.get('locale')?.value ?? 'en';
const catalog = await getLocalizedCatalog(locale);
return <Catalog items={catalog} />;
}Do not assume that passing a user identifier makes every personalized result safe to cache. Check that all values affecting output or access control are represented in the cache boundary, and that the resulting entry cannot expose one user’s data to another. For sensitive or highly individualized output, avoid shared caching unless the isolation behavior is clear.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.How do you cache work in a Route Handler?
Do not put 'use cache' directly in the Route Handler body. Move reusable work into a helper and call that helper from the handler; the helper’s cache lifetime is applied when a new request arrives.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Clear out junk files and repair common Windows errors3Fix the driver behind crashes, sound loss and screen glitchesimport { cacheLife } from 'next/cache';
async function getPublicSummary() {
'use cache';
cacheLife('hours');
return loadPublicSummary();
}
export async function GET() {
const summary = await getPublicSummary();
return Response.json(summary);
}This boundary caches the helper’s result, not the response logic indiscriminately. Keep request-dependent decisions in the handler or pass the required values explicitly to an appropriately isolated helper.
When does a remote cache make sense?
The 'use cache: remote' directive can use a platform-provided cache handler when runtime-local caching is insufficient—for example, when deployment topology calls for a shared cache across instances. A remote cache adds network round trips and may carry platform fees, so evaluate it against the workload and hosting setup rather than assuming it is faster or cheaper.
- Consider whether the cache must be shared across separate runtime instances.
- Account for remote lookup latency and the cost model of the hosting platform.
- Measure the application under its real request mix and deployment configuration before making performance claims.
Next.js documentation describes the option but does not establish which provider is fastest, cheapest, or most reliable.
How is this different from the previous caching model?
Next.js keeps separate guidance for applications that do not use Cache Components. Do not combine those examples with Cache Components defaults as if they were one system.
Recommended Free Tools
- In the previous model, the extended server
fetchAPI has persistent Data Cache semantics:cache: 'force-cache'consults the Data Cache, andnext.revalidatesets a maximum cache lifetime. - Conflicting fetch options, such as
cache: 'no-store'together with a positivenext.revalidatevalue, are not allowed. - That model’s guide also covers
unstable_cachefor caching non-fetch functions. - Cache Components require the Node.js runtime; do not use Edge Runtime with this model.
Choose the documentation for the model your application actually uses, and confirm the configuration and API signatures against the installed release. Cache duration settings define behavior; they do not prove a speedup for a particular application.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
