react-code-dataset / next.js /docs /01-app /02-guides /incremental-static-regeneration.mdx

Upload folder using huggingface_hub

1e92f2d verified about 1 year ago

19.4 kB

---
title: How to implement Incremental Static Regeneration (ISR)
nav_title: ISR
description: Learn how to create or update static pages at runtime with Incremental Static Regeneration.
---
<details>
  <summary>Examples</summary>
- [Next.js Commerce](https://vercel.com/templates/next.js/nextjs-commerce)
- [On-Demand ISR](https://on-demand-isr.vercel.app)
- [Next.js Forms](https://github.com/vercel/next.js/tree/canary/examples/next-forms)
</details>
Incremental Static Regeneration (ISR) enables you to:
- Update static content without rebuilding the entire site
- Reduce server load by serving prerendered, static pages for most requests
- Ensure proper `cache-control` headers are automatically added to pages
- Handle large amounts of content pages without long `next build` times
Here's a minimal example:
<AppOnly>
```tsx filename="app/blog/[id]/page.tsx" switcher
interface Post {
  id: string
  title: string
  content: string
}

// Next.js will invalidate the cache when a
// request comes in, at most once every 60 seconds.
export const revalidate = 60

// We'll prerender only the params from `generateStaticParams` at build time.
// If a request comes in for a path that hasn't been generated,
// Next.js will server-render the page on-demand.
export const dynamicParams = true // or false, to 404 on unknown paths

export async function generateStaticParams() {
  const posts: Post[] = await fetch('https://api.vercel.app/blog').then((res) =>
    res.json()
  )
  return posts.map((post) => ({
    id: String(post.id),
  }))
}

export default async function Page({
  params,
}: {
  params: Promise<{ id: string }>
}) {
  const { id } = await params
  const post: Post = await fetch(`https://api.vercel.app/blog/${id}`).then(
    (res) => res.json()
  )
  return (
    <main>
      <h1>{post.title}</h1>
      <p>{post.content}</p>
    </main>
  )
}
```

```jsx filename="app/blog/[id]/page.js" switcher
// Next.js will invalidate the cache when a
// request comes in, at most once every 60 seconds.
export const revalidate = 60

// We'll prerender only the params from `generateStaticParams` at build time.
// If a request comes in for a path that hasn't been generated,
// Next.js will server-render the page on-demand.
export const dynamicParams = true // or false, to 404 on unknown paths

export async function generateStaticParams() {
  const posts = await fetch('https://api.vercel.app/blog').then((res) =>
    res.json()
  )
  return posts.map((post) => ({
    id: String(post.id),
  }))
}

export default async function Page({ params }) {
  const { id } = await params
  const post = await fetch(`https://api.vercel.app/blog/${id}`).then((res) =>
    res.json()
  )
  return (
    <main>
      <h1>{post.title}</h1>
      <p>{post.content}</p>
    </main>
  )
}
```

</AppOnly>

<PagesOnly>

```tsx filename="pages/blog/[id].tsx" switcher
import type { GetStaticPaths, GetStaticProps } from 'next'

interface Post {
  id: string
  title: string
  content: string
}

interface Props {
  post: Post
}

export const getStaticPaths: GetStaticPaths = async () => {
  const posts = await fetch('https://api.vercel.app/blog').then((res) =>
    res.json()
  )
  const paths = posts.map((post: Post) => ({
    params: { id: String(post.id) },
  }))

  // We'll prerender only these paths at build time.
  // { fallback: 'blocking' } will server-render pages
  // on-demand if the path doesn't exist.
  return { paths, fallback: false }
}

export const getStaticProps: GetStaticProps<Props> = async ({
  params,
}: {
  params: { id: string }
}) => {
  const post = await fetch(`https://api.vercel.app/blog/${params.id}`).then(
    (res) => res.json()
  )

  return {
    props: { post },
    // Next.js will invalidate the cache when a
    // request comes in, at most once every 60 seconds.
    revalidate: 60,
  }
}

export default function Page({ post }: Props) {
  return (
    <main>
      <h1>{post.title}</h1>
      <p>{post.content}</p>
    </main>
  )
}
```

```jsx filename="pages/blog/[id].jsx" switcher
export async function getStaticPaths() {
  const posts = await fetch('https://api.vercel.app/blog').then((res) =>
    res.json()
  )
  const paths = posts.map((post) => ({
    params: { id: post.id },
  }))

  // We'll prerender only these paths at build time.
  // { fallback: false } means other routes should 404.
  return { paths, fallback: false }
}

export async function getStaticProps({ params }) {
  const post = await fetch(`https://api.vercel.app/blog/${params.id}`).then(
    (res) => res.json()
  )

  return {
    props: { post },
    // Next.js will invalidate the cache when a
    // request comes in, at most once every 60 seconds.
    revalidate: 60,
  }
}

export default function Page({ post }) {
  return (
    <main>
      <h1>{post.title}</h1>
      <p>{post.content}</p>
    </main>
  )
}
```

</PagesOnly>

Here's how this example works:
1. During `next build`, all known blog posts are generated (there are 25 in this example)
2. All requests made to these pages (e.g. `/blog/1`) are cached and instantaneous
3. After 60 seconds has passed, the next request will still show the cached (stale) page
4. The cache is invalidated and a new version of the page begins generating in the background
5. Once generated successfully, Next.js will display and cache the updated page
6. If `/blog/26` is requested, Next.js will generate and cache this page on-demand
## Reference
<AppOnly>
### Route segment config
- [`revalidate`](/docs/app/api-reference/file-conventions/route-segment-config#revalidate)
- [`dynamicParams`](/docs/app/api-reference/file-conventions/route-segment-config#dynamicparams)
### Functions
- [`revalidatePath`](/docs/app/api-reference/functions/revalidatePath)
- [`revalidateTag`](/docs/app/api-reference/functions/revalidateTag)
</AppOnly>
<PagesOnly>
### Functions
- [`getStaticProps`](/docs/pages/building-your-application/data-fetching/get-static-props)
- [`res.revalidate`](/docs/pages/building-your-application/routing/api-routes#response-helpers)
</PagesOnly>
## Examples
<AppOnly>
### Time-based revalidation
This fetches and displays a list of blog posts on `/blog`. After an hour, the cache for this page is invalidated on the next visit to the page. Then, in the background, a new version of the page is generated with the latest blog posts.
```tsx filename="app/blog/page.tsx" switcher
interface Post {
  id: string
  title: string
  content: string
}
export const revalidate = 3600 // invalidate every hour
export default async function Page() {
  const data = await fetch('https://api.vercel.app/blog')
  const posts: Post[] = await data.json()
  return (
    <main>
      <h1>Blog Posts</h1>
      <ul>
        {posts.map((post) => (
          <li key={post.id}>{post.title}</li>
        ))}
      </ul>
    </main>
  )
}
```

```jsx filename="app/blog/page.js" switcher
export const revalidate = 3600 // invalidate every hour

export default async function Page() {
  const data = await fetch('https://api.vercel.app/blog')
  const posts = await data.json()
  return (
    <main>
      <h1>Blog Posts</h1>
      <ul>
        {posts.map((post) => (
          <li key={post.id}>{post.title}</li>
        ))}
      </ul>
    </main>
  )
}
```

We recommend setting a high revalidation time. For instance, 1 hour instead of 1 second. If you need more precision, consider using on-demand revalidation. If you need real-time data, consider switching to [dynamic rendering](/docs/app/getting-started/partial-prerendering#dynamic-rendering).

### On-demand revalidation with `revalidatePath`

For a more precise method of revalidation, invalidate pages on-demand with the `revalidatePath` function.

For example, this Server Action would get called after adding a new post. Regardless of how you retrieve your data in your Server Component, either using `fetch` or connecting to a database, this will clear the cache for the entire route and allow the Server Component to fetch fresh data.

```ts filename="app/actions.ts" switcher
'use server'

import { revalidatePath } from 'next/cache'

export async function createPost() {
  // Invalidate the /posts route in the cache
  revalidatePath('/posts')
}
```

```js filename="app/actions.js" switcher
'use server'

import { revalidatePath } from 'next/cache'

export async function createPost() {
  // Invalidate the /posts route in the cache
  revalidatePath('/posts')
}
```

[View a demo](https://on-demand-isr.vercel.app) and [explore the source code](https://github.com/vercel/on-demand-isr).

### On-demand revalidation with `revalidateTag`

For most use cases, prefer revalidating entire paths. If you need more granular control, you can use the `revalidateTag` function. For example, you can tag individual `fetch` calls:

```tsx filename="app/blog/page.tsx" switcher
export default async function Page() {
  const data = await fetch('https://api.vercel.app/blog', {
    next: { tags: ['posts'] },
  })
  const posts = await data.json()
  // ...
}
```

```jsx filename="app/blog/page.js" switcher
export default async function Page() {
  const data = await fetch('https://api.vercel.app/blog', {
    next: { tags: ['posts'] },
  })
  const posts = await data.json()
  // ...
}
```

If you are using an ORM or connecting to a database, you can use `unstable_cache`:

```tsx filename="app/blog/page.tsx" switcher
import { unstable_cache } from 'next/cache'
import { db, posts } from '@/lib/db'

const getCachedPosts = unstable_cache(
  async () => {
    return await db.select().from(posts)
  },
  ['posts'],
  { revalidate: 3600, tags: ['posts'] }
)

export default async function Page() {
  const posts = getCachedPosts()
  // ...
}
```

```jsx filename="app/blog/page.js" switcher
import { unstable_cache } from 'next/cache'
import { db, posts } from '@/lib/db'

const getCachedPosts = unstable_cache(
  async () => {
    return await db.select().from(posts)
  },
  ['posts'],
  { revalidate: 3600, tags: ['posts'] }
)

export default async function Page() {
  const posts = getCachedPosts()
  // ...
}
```

You can then use `revalidateTag` in a [Server Actions](/docs/app/getting-started/updating-data) or [Route Handler](/docs/app/api-reference/file-conventions/route):

```ts filename="app/actions.ts" switcher
'use server'

import { revalidateTag } from 'next/cache'

export async function createPost() {
  // Invalidate all data tagged with 'posts' in the cache
  revalidateTag('posts')
}
```

```js filename="app/actions.js" switcher
'use server'

import { revalidateTag } from 'next/cache'

export async function createPost() {
  // Invalidate all data tagged with 'posts' in the cache
  revalidateTag('posts')
}
```

</AppOnly>

<PagesOnly>

### On-demand validation with `res.revalidate()`

For a more precise method of revalidation, use `res.revalidate` to generate a new page on-demand from an API Router.

For example, this API Route can be called at `/api/revalidate?secret=<token>` to revalidate a given blog post. Create a secret token only known by your Next.js app. This secret will be used to prevent unauthorized access to the revalidation API Route.

```ts filename="pages/api/revalidate.ts" switcher
import type { NextApiRequest, NextApiResponse } from 'next'

export default async function handler(
  req: NextApiRequest,
  res: NextApiResponse
) {
  // Check for secret to confirm this is a valid request
  if (req.query.secret !== process.env.MY_SECRET_TOKEN) {
    return res.status(401).json({ message: 'Invalid token' })
  }

  try {
    // This should be the actual path not a rewritten path
    // e.g. for "/posts/[id]" this should be "/posts/1"
    await res.revalidate('/posts/1')
    return res.json({ revalidated: true })
  } catch (err) {
    // If there was an error, Next.js will continue
    // to show the last successfully generated page
    return res.status(500).send('Error revalidating')
  }
}
```

```js filename="pages/api/revalidate.js" switcher
export default async function handler(req, res) {
  // Check for secret to confirm this is a valid request
  if (req.query.secret !== process.env.MY_SECRET_TOKEN) {
    return res.status(401).json({ message: 'Invalid token' })
  }

  try {
    // This should be the actual path not a rewritten path
    // e.g. for "/posts/[id]" this should be "/posts/1"
    await res.revalidate('/posts/1')
    return res.json({ revalidated: true })
  } catch (err) {
    // If there was an error, Next.js will continue
    // to show the last successfully generated page
    return res.status(500).send('Error revalidating')
  }
}
```

If you are using on-demand revalidation, you do not need to specify a `revalidate` time inside of `getStaticProps`. Next.js will use the default value of `false` (no revalidation) and only revalidate the page on-demand when `res.revalidate()` is called.

</PagesOnly>

### Handling uncaught exceptions

<AppOnly>

If an error is thrown while attempting to revalidate data, the last successfully generated data will continue to be served from the cache. On the next subsequent request, Next.js will retry revalidating the data. [Learn more about error handling](/docs/app/getting-started/error-handling).

</AppOnly>

<PagesOnly>

If there is an error inside `getStaticProps` when handling background regeneration, or you manually throw an error, the last successfully generated page will continue to show. On the next subsequent request, Next.js will retry calling `getStaticProps`.

```tsx filename="pages/blog/[id].tsx" switcher
import type { GetStaticProps } from 'next'

interface Post {
  id: string
  title: string
  content: string
}

interface Props {
  post: Post
}

export const getStaticProps: GetStaticProps<Props> = async ({
  params,
}: {
  params: { id: string }
}) => {
  // If this request throws an uncaught error, Next.js will
  // not invalidate the currently shown page and
  // retry getStaticProps on the next request.
  const res = await fetch(`https://api.vercel.app/blog/${params.id}`)
  const post: Post = await res.json()

  if (!res.ok) {
    // If there is a server error, you might want to
    // throw an error instead of returning so that the cache is not updated
    // until the next successful request.
    throw new Error(`Failed to fetch posts, received status ${res.status}`)
  }

  return {
    props: { post },
    // Next.js will invalidate the cache when a
    // request comes in, at most once every 60 seconds.
    revalidate: 60,
  }
}
```

```jsx filename="pages/blog/[id].jsx" switcher
export async function getStaticProps({ params }) {
  // If this request throws an uncaught error, Next.js will
  // not invalidate the currently shown page and
  // retry getStaticProps on the next request.
  const res = await fetch(`https://api.vercel.app/blog/${params.id}`)
  const post = await res.json()

  if (!res.ok) {
    // If there is a server error, you might want to
    // throw an error instead of returning so that the cache is not updated
    // until the next successful request.
    throw new Error(`Failed to fetch posts, received status ${res.status}`)
  }

  return {
    props: { post },
    // Next.js will invalidate the cache when a
    // request comes in, at most once every 60 seconds.
    revalidate: 60,
  }
}
```

</PagesOnly>

### Customizing the cache location

You can configure the Next.js cache location if you want to persist cached pages and data to durable storage, or share the cache across multiple containers or instances of your Next.js application. [Learn more](/docs/app/guides/self-hosting#caching-and-isr).

## Troubleshooting

### Debugging cached data in local development

If you are using the `fetch` API, you can add additional logging to understand which requests are cached or uncached. [Learn more about the `logging` option](/docs/app/api-reference/config/next-config-js/logging).

```jsx filename="next.config.js"
module.exports = {
  logging: {
    fetches: {
      fullUrl: true,
    },
  },
}
```

### Verifying correct production behavior

To verify your pages are cached and revalidated correctly in production, you can test locally by running `next build` and then `next start` to run the production Next.js server.

This will allow you to test ISR behavior as it would work in a production environment. For further debugging, add the following environment variable to your `.env` file:

```bash filename=".env"
NEXT_PRIVATE_DEBUG_CACHE=1
```

This will make the Next.js server console log ISR cache hits and misses. You can inspect the output to see which pages are generated during `next build`, as well as how pages are updated as paths are accessed on-demand.

## Caveats

<AppOnly>

- ISR is only supported when using the Node.js runtime (default).
- ISR is not supported when creating a [Static Export](/docs/app/guides/static-exports).
- If you have multiple `fetch` requests in a statically rendered route, and each has a different `revalidate` frequency, the lowest time will be used for ISR. However, those revalidate frequencies will still be respected by the [Data Cache](/docs/app/guides/caching#data-cache).
- If any of the `fetch` requests used on a route have a `revalidate` time of `0`, or an explicit `no-store`, the route will be [dynamically rendered](/docs/app/getting-started/partial-prerendering#dynamic-rendering).
- Middleware won't be executed for on-demand ISR requests, meaning any path rewrites or logic in Middleware will not be applied. Ensure you are revalidating the exact path. For example, `/post/1` instead of a rewritten `/post-1`.
</AppOnly>
<PagesOnly>
- ISR is only supported when using the Node.js runtime (default).
- ISR is not supported when creating a [Static Export](/docs/app/guides/static-exports).
- Middleware won't be executed for on-demand ISR requests, meaning any path rewrites or logic in Middleware will not be applied. Ensure you are revalidating the exact path. For example, `/post/1` instead of a rewritten `/post-1`.
</PagesOnly>
## Platform Support
| Deployment Option                                                   | Supported         |
| ------------------------------------------------------------------- | ----------------- |
| [Node.js server](/docs/app/getting-started/deploying#nodejs-server) | Yes               |
| [Docker container](/docs/app/getting-started/deploying#docker)      | Yes               |
| [Static export](/docs/app/getting-started/deploying#static-export)  | No                |
| [Adapters](/docs/app/getting-started/deploying#adapters)            | Platform-specific |
Learn how to [configure ISR](/docs/app/guides/self-hosting#caching-and-isr) when self-hosting Next.js.
## Version history
| Version   | Changes                                                                             |
| --------- | ----------------------------------------------------------------------------------- |
| `v14.1.0` | Custom `cacheHandler` is stable.                                                    |
| `v13.0.0` | App Router is introduced.                                                           |
| `v12.2.0` | Pages Router: On-Demand ISR is stable                                               |
| `v12.0.0` | Pages Router: [Bot-aware ISR fallback](/blog/next-12#bot-aware-isr-fallback) added. |
| `v9.5.0`  | Pages Router: [Stable ISR introduced](/blog/next-9-5).                              |

	---
	title: How to implement Incremental Static Regeneration (ISR)
	nav_title: ISR
	description: Learn how to create or update static pages at runtime with Incremental Static Regeneration.
	---

	<details>
	<summary>Examples</summary>

	- [Next.js Commerce](https://vercel.com/templates/next.js/nextjs-commerce)
	- [On-Demand ISR](https://on-demand-isr.vercel.app)
	- [Next.js Forms](https://github.com/vercel/next.js/tree/canary/examples/next-forms)

	</details>

	Incremental Static Regeneration (ISR) enables you to:

	- Update static content without rebuilding the entire site
	- Reduce server load by serving prerendered, static pages for most requests
	- Ensure proper `cache-control` headers are automatically added to pages
	- Handle large amounts of content pages without long `next build` times

	Here's a minimal example:

	<AppOnly>

	```tsx filename="app/blog/[id]/page.tsx" switcher
	interface Post {
	id: string
	title: string
	content: string
	}

	// Next.js will invalidate the cache when a
	// request comes in, at most once every 60 seconds.
	export const revalidate = 60

	// We'll prerender only the params from `generateStaticParams` at build time.
	// If a request comes in for a path that hasn't been generated,
	// Next.js will server-render the page on-demand.
	export const dynamicParams = true // or false, to 404 on unknown paths

	export async function generateStaticParams() {
	const posts: Post[] = await fetch('https://api.vercel.app/blog').then((res) =>
	res.json()
	)
	return posts.map((post) => ({
	id: String(post.id),
	}))
	}

	export default async function Page({
	params,
	}: {
	params: Promise<{ id: string }>
	}) {
	const { id } = await params
	const post: Post = await fetch(`https://api.vercel.app/blog/${id}`).then(
	(res) => res.json()
	)
	return (
	<main>
	<h1>{post.title}</h1>
	<p>{post.content}</p>
	</main>
	)
	}
	```

	```jsx filename="app/blog/[id]/page.js" switcher
	// Next.js will invalidate the cache when a
	// request comes in, at most once every 60 seconds.
	export const revalidate = 60

	// We'll prerender only the params from `generateStaticParams` at build time.
	// If a request comes in for a path that hasn't been generated,
	// Next.js will server-render the page on-demand.
	export const dynamicParams = true // or false, to 404 on unknown paths

	export async function generateStaticParams() {
	const posts = await fetch('https://api.vercel.app/blog').then((res) =>
	res.json()
	)
	return posts.map((post) => ({
	id: String(post.id),
	}))
	}

	export default async function Page({ params }) {
	const { id } = await params
	const post = await fetch(`https://api.vercel.app/blog/${id}`).then((res) =>
	res.json()
	)
	return (
	<main>
	<h1>{post.title}</h1>
	<p>{post.content}</p>
	</main>
	)
	}
	```

	</AppOnly>

	<PagesOnly>

	```tsx filename="pages/blog/[id].tsx" switcher
	import type { GetStaticPaths, GetStaticProps } from 'next'

	interface Post {
	id: string
	title: string
	content: string
	}

	interface Props {
	post: Post
	}

	export const getStaticPaths: GetStaticPaths = async () => {
	const posts = await fetch('https://api.vercel.app/blog').then((res) =>
	res.json()
	)
	const paths = posts.map((post: Post) => ({
	params: { id: String(post.id) },
	}))

	// We'll prerender only these paths at build time.
	// { fallback: 'blocking' } will server-render pages
	// on-demand if the path doesn't exist.
	return { paths, fallback: false }
	}

	export const getStaticProps: GetStaticProps<Props> = async ({
	params,
	}: {
	params: { id: string }
	}) => {
	const post = await fetch(`https://api.vercel.app/blog/${params.id}`).then(
	(res) => res.json()
	)

	return {
	props: { post },
	// Next.js will invalidate the cache when a
	// request comes in, at most once every 60 seconds.
	revalidate: 60,
	}
	}

	export default function Page({ post }: Props) {
	return (
	<main>
	<h1>{post.title}</h1>
	<p>{post.content}</p>
	</main>
	)
	}
	```

	```jsx filename="pages/blog/[id].jsx" switcher
	export async function getStaticPaths() {
	const posts = await fetch('https://api.vercel.app/blog').then((res) =>
	res.json()
	)
	const paths = posts.map((post) => ({
	params: { id: post.id },
	}))

	// We'll prerender only these paths at build time.
	// { fallback: false } means other routes should 404.
	return { paths, fallback: false }
	}

	export async function getStaticProps({ params }) {
	const post = await fetch(`https://api.vercel.app/blog/${params.id}`).then(
	(res) => res.json()
	)

	return {
	props: { post },
	// Next.js will invalidate the cache when a
	// request comes in, at most once every 60 seconds.
	revalidate: 60,
	}
	}

	export default function Page({ post }) {
	return (
	<main>
	<h1>{post.title}</h1>
	<p>{post.content}</p>
	</main>
	)
	}
	```

	</PagesOnly>

	Here's how this example works:

	1. During `next build`, all known blog posts are generated (there are 25 in this example)
	2. All requests made to these pages (e.g. `/blog/1`) are cached and instantaneous
	3. After 60 seconds has passed, the next request will still show the cached (stale) page
	4. The cache is invalidated and a new version of the page begins generating in the background
	5. Once generated successfully, Next.js will display and cache the updated page
	6. If `/blog/26` is requested, Next.js will generate and cache this page on-demand

	## Reference

	<AppOnly>

	### Route segment config

	- [`revalidate`](/docs/app/api-reference/file-conventions/route-segment-config#revalidate)
	- [`dynamicParams`](/docs/app/api-reference/file-conventions/route-segment-config#dynamicparams)

	### Functions

	- [`revalidatePath`](/docs/app/api-reference/functions/revalidatePath)
	- [`revalidateTag`](/docs/app/api-reference/functions/revalidateTag)

	</AppOnly>

	<PagesOnly>

	### Functions

	- [`getStaticProps`](/docs/pages/building-your-application/data-fetching/get-static-props)
	- [`res.revalidate`](/docs/pages/building-your-application/routing/api-routes#response-helpers)

	</PagesOnly>

	## Examples

	<AppOnly>

	### Time-based revalidation

	This fetches and displays a list of blog posts on `/blog`. After an hour, the cache for this page is invalidated on the next visit to the page. Then, in the background, a new version of the page is generated with the latest blog posts.

	```tsx filename="app/blog/page.tsx" switcher
	interface Post {
	id: string
	title: string
	content: string
	}

	export const revalidate = 3600 // invalidate every hour

	export default async function Page() {
	const data = await fetch('https://api.vercel.app/blog')
	const posts: Post[] = await data.json()
	return (
	<main>
	<h1>Blog Posts</h1>
	<ul>
	{posts.map((post) => (
	<li key={post.id}>{post.title}</li>
	))}
	</ul>
	</main>
	)
	}
	```

	```jsx filename="app/blog/page.js" switcher
	export const revalidate = 3600 // invalidate every hour

	export default async function Page() {
	const data = await fetch('https://api.vercel.app/blog')
	const posts = await data.json()
	return (
	<main>
	<h1>Blog Posts</h1>
	<ul>
	{posts.map((post) => (
	<li key={post.id}>{post.title}</li>
	))}
	</ul>
	</main>
	)
	}
	```

	We recommend setting a high revalidation time. For instance, 1 hour instead of 1 second. If you need more precision, consider using on-demand revalidation. If you need real-time data, consider switching to [dynamic rendering](/docs/app/getting-started/partial-prerendering#dynamic-rendering).

	### On-demand revalidation with `revalidatePath`

	For a more precise method of revalidation, invalidate pages on-demand with the `revalidatePath` function.

	For example, this Server Action would get called after adding a new post. Regardless of how you retrieve your data in your Server Component, either using `fetch` or connecting to a database, this will clear the cache for the entire route and allow the Server Component to fetch fresh data.

	```ts filename="app/actions.ts" switcher
	'use server'

	import { revalidatePath } from 'next/cache'

	export async function createPost() {
	// Invalidate the /posts route in the cache
	revalidatePath('/posts')
	}
	```

	```js filename="app/actions.js" switcher
	'use server'

	import { revalidatePath } from 'next/cache'

	export async function createPost() {
	// Invalidate the /posts route in the cache
	revalidatePath('/posts')
	}
	```

	[View a demo](https://on-demand-isr.vercel.app) and [explore the source code](https://github.com/vercel/on-demand-isr).

	### On-demand revalidation with `revalidateTag`

	For most use cases, prefer revalidating entire paths. If you need more granular control, you can use the `revalidateTag` function. For example, you can tag individual `fetch` calls:

	```tsx filename="app/blog/page.tsx" switcher
	export default async function Page() {
	const data = await fetch('https://api.vercel.app/blog', {
	next: { tags: ['posts'] },
	})
	const posts = await data.json()
	// ...
	}
	```

	```jsx filename="app/blog/page.js" switcher
	export default async function Page() {
	const data = await fetch('https://api.vercel.app/blog', {
	next: { tags: ['posts'] },
	})
	const posts = await data.json()
	// ...
	}
	```

	If you are using an ORM or connecting to a database, you can use `unstable_cache`:

	```tsx filename="app/blog/page.tsx" switcher
	import { unstable_cache } from 'next/cache'
	import { db, posts } from '@/lib/db'

	const getCachedPosts = unstable_cache(
	async () => {
	return await db.select().from(posts)
	},
	['posts'],
	{ revalidate: 3600, tags: ['posts'] }
	)

	export default async function Page() {
	const posts = getCachedPosts()
	// ...
	}
	```

	```jsx filename="app/blog/page.js" switcher
	import { unstable_cache } from 'next/cache'
	import { db, posts } from '@/lib/db'

	const getCachedPosts = unstable_cache(
	async () => {
	return await db.select().from(posts)
	},
	['posts'],
	{ revalidate: 3600, tags: ['posts'] }
	)

	export default async function Page() {
	const posts = getCachedPosts()
	// ...
	}
	```

	You can then use `revalidateTag` in a [Server Actions](/docs/app/getting-started/updating-data) or [Route Handler](/docs/app/api-reference/file-conventions/route):

	```ts filename="app/actions.ts" switcher
	'use server'

	import { revalidateTag } from 'next/cache'

	export async function createPost() {
	// Invalidate all data tagged with 'posts' in the cache
	revalidateTag('posts')
	}
	```

	```js filename="app/actions.js" switcher
	'use server'

	import { revalidateTag } from 'next/cache'

	export async function createPost() {
	// Invalidate all data tagged with 'posts' in the cache
	revalidateTag('posts')
	}
	```

	</AppOnly>

	<PagesOnly>

	### On-demand validation with `res.revalidate()`

	For a more precise method of revalidation, use `res.revalidate` to generate a new page on-demand from an API Router.

	For example, this API Route can be called at `/api/revalidate?secret=<token>` to revalidate a given blog post. Create a secret token only known by your Next.js app. This secret will be used to prevent unauthorized access to the revalidation API Route.

	```ts filename="pages/api/revalidate.ts" switcher
	import type { NextApiRequest, NextApiResponse } from 'next'

	export default async function handler(
	req: NextApiRequest,
	res: NextApiResponse
	) {
	// Check for secret to confirm this is a valid request
	if (req.query.secret !== process.env.MY_SECRET_TOKEN) {
	return res.status(401).json({ message: 'Invalid token' })
	}

	try {
	// This should be the actual path not a rewritten path
	// e.g. for "/posts/[id]" this should be "/posts/1"
	await res.revalidate('/posts/1')
	return res.json({ revalidated: true })
	} catch (err) {
	// If there was an error, Next.js will continue
	// to show the last successfully generated page
	return res.status(500).send('Error revalidating')
	}
	}
	```

	```js filename="pages/api/revalidate.js" switcher
	export default async function handler(req, res) {
	// Check for secret to confirm this is a valid request
	if (req.query.secret !== process.env.MY_SECRET_TOKEN) {
	return res.status(401).json({ message: 'Invalid token' })
	}

	try {
	// This should be the actual path not a rewritten path
	// e.g. for "/posts/[id]" this should be "/posts/1"
	await res.revalidate('/posts/1')
	return res.json({ revalidated: true })
	} catch (err) {
	// If there was an error, Next.js will continue
	// to show the last successfully generated page
	return res.status(500).send('Error revalidating')
	}
	}
	```

	If you are using on-demand revalidation, you do not need to specify a `revalidate` time inside of `getStaticProps`. Next.js will use the default value of `false` (no revalidation) and only revalidate the page on-demand when `res.revalidate()` is called.

	</PagesOnly>

	### Handling uncaught exceptions

	<AppOnly>

	If an error is thrown while attempting to revalidate data, the last successfully generated data will continue to be served from the cache. On the next subsequent request, Next.js will retry revalidating the data. [Learn more about error handling](/docs/app/getting-started/error-handling).

	</AppOnly>

	<PagesOnly>

	If there is an error inside `getStaticProps` when handling background regeneration, or you manually throw an error, the last successfully generated page will continue to show. On the next subsequent request, Next.js will retry calling `getStaticProps`.

	```tsx filename="pages/blog/[id].tsx" switcher
	import type { GetStaticProps } from 'next'

	interface Post {
	id: string
	title: string
	content: string
	}

	interface Props {
	post: Post
	}

	export const getStaticProps: GetStaticProps<Props> = async ({
	params,
	}: {
	params: { id: string }
	}) => {
	// If this request throws an uncaught error, Next.js will
	// not invalidate the currently shown page and
	// retry getStaticProps on the next request.
	const res = await fetch(`https://api.vercel.app/blog/${params.id}`)
	const post: Post = await res.json()

	if (!res.ok) {
	// If there is a server error, you might want to
	// throw an error instead of returning so that the cache is not updated
	// until the next successful request.
	throw new Error(`Failed to fetch posts, received status ${res.status}`)
	}

	return {
	props: { post },
	// Next.js will invalidate the cache when a
	// request comes in, at most once every 60 seconds.
	revalidate: 60,
	}
	}
	```

	```jsx filename="pages/blog/[id].jsx" switcher
	export async function getStaticProps({ params }) {
	// If this request throws an uncaught error, Next.js will
	// not invalidate the currently shown page and
	// retry getStaticProps on the next request.
	const res = await fetch(`https://api.vercel.app/blog/${params.id}`)
	const post = await res.json()

	if (!res.ok) {
	// If there is a server error, you might want to
	// throw an error instead of returning so that the cache is not updated
	// until the next successful request.
	throw new Error(`Failed to fetch posts, received status ${res.status}`)
	}

	return {
	props: { post },
	// Next.js will invalidate the cache when a
	// request comes in, at most once every 60 seconds.
	revalidate: 60,
	}
	}
	```

	</PagesOnly>

	### Customizing the cache location

	You can configure the Next.js cache location if you want to persist cached pages and data to durable storage, or share the cache across multiple containers or instances of your Next.js application. [Learn more](/docs/app/guides/self-hosting#caching-and-isr).

	## Troubleshooting

	### Debugging cached data in local development

	If you are using the `fetch` API, you can add additional logging to understand which requests are cached or uncached. [Learn more about the `logging` option](/docs/app/api-reference/config/next-config-js/logging).

	```jsx filename="next.config.js"
	module.exports = {
	logging: {
	fetches: {
	fullUrl: true,
	},
	},
	}
	```

	### Verifying correct production behavior

	To verify your pages are cached and revalidated correctly in production, you can test locally by running `next build` and then `next start` to run the production Next.js server.

	This will allow you to test ISR behavior as it would work in a production environment. For further debugging, add the following environment variable to your `.env` file:

	```bash filename=".env"
	NEXT_PRIVATE_DEBUG_CACHE=1
	```

	This will make the Next.js server console log ISR cache hits and misses. You can inspect the output to see which pages are generated during `next build`, as well as how pages are updated as paths are accessed on-demand.

	## Caveats

	<AppOnly>

	- ISR is only supported when using the Node.js runtime (default).
	- ISR is not supported when creating a [Static Export](/docs/app/guides/static-exports).
	- If you have multiple `fetch` requests in a statically rendered route, and each has a different `revalidate` frequency, the lowest time will be used for ISR. However, those revalidate frequencies will still be respected by the [Data Cache](/docs/app/guides/caching#data-cache).
	- If any of the `fetch` requests used on a route have a `revalidate` time of `0`, or an explicit `no-store`, the route will be [dynamically rendered](/docs/app/getting-started/partial-prerendering#dynamic-rendering).
	- Middleware won't be executed for on-demand ISR requests, meaning any path rewrites or logic in Middleware will not be applied. Ensure you are revalidating the exact path. For example, `/post/1` instead of a rewritten `/post-1`.

	</AppOnly>

	<PagesOnly>

	- ISR is only supported when using the Node.js runtime (default).
	- ISR is not supported when creating a [Static Export](/docs/app/guides/static-exports).
	- Middleware won't be executed for on-demand ISR requests, meaning any path rewrites or logic in Middleware will not be applied. Ensure you are revalidating the exact path. For example, `/post/1` instead of a rewritten `/post-1`.

	</PagesOnly>

	## Platform Support

	\| Deployment Option \| Supported \|
	\| ------------------------------------------------------------------- \| ----------------- \|
	\| [Node.js server](/docs/app/getting-started/deploying#nodejs-server) \| Yes \|
	\| [Docker container](/docs/app/getting-started/deploying#docker) \| Yes \|
	\| [Static export](/docs/app/getting-started/deploying#static-export) \| No \|
	\| [Adapters](/docs/app/getting-started/deploying#adapters) \| Platform-specific \|

	Learn how to [configure ISR](/docs/app/guides/self-hosting#caching-and-isr) when self-hosting Next.js.

	## Version history

	\| Version \| Changes \|
	\| --------- \| ----------------------------------------------------------------------------------- \|
	\| `v14.1.0` \| Custom `cacheHandler` is stable. \|
	\| `v13.0.0` \| App Router is introduced. \|
	\| `v12.2.0` \| Pages Router: On-Demand ISR is stable \|
	\| `v12.0.0` \| Pages Router: [Bot-aware ISR fallback](/blog/next-12#bot-aware-isr-fallback) added. \|
	\| `v9.5.0` \| Pages Router: [Stable ISR introduced](/blog/next-9-5). \|