---
title: "Runtime Sync (Optional)"
description: "Opt-in runtime page indexing for sites with dynamic content."
canonical_url: "https://nuxtseo.com/docs/ai-ready/guides/runtime-indexing"
last_updated: "2026-09-05T23:10:43.760Z"
---

**Most sites don't need this.** Prerendering handles page indexing automatically. Use runtime sync only for sites with frequently changing content that you can't prerender.

## When You Need Runtime Sync

Enable runtime sync if your site has:

- **Dynamic pages** generated at runtime (e.g., user-generated content)
- **Frequently updated content** that changes between deploys
- **API-driven pages** where content comes from external sources

If your content only changes on deploy, stick with prerendering - it's faster and simpler.

## How It Works

```text
┌─────────────────────────────────────────────────────────────┐
│ Default: Prerendering (source of truth)                     │
│   Build time → crawl sitemap → create SQLite → compress    │
│   Cold start → restore dump → llms.txt works immediately!  │
├─────────────────────────────────────────────────────────────┤
│ Opt-in: Runtime Sync (for dynamic content)                  │
│   Cold start → restore dump → sitemap seeder → poll        │
│   Cron (optional) → background re-indexing of stale pages  │
└─────────────────────────────────────────────────────────────┘
```

## Enabling Runtime Sync

```ts [nuxt.config.ts]
export default defineNuxtConfig({
  aiReady: {
    runtimeSync: {
      ttl: 3600, // Re-index pages & refresh sitemap older than 1 hour
      batchSize: 20, // Pages per batch
      pruneTtl: 0 // Prune routes not in sitemap (0 = never)
    },
    cron: true // Optional: scheduled background indexing (every minute)
  }
})
```

::note
The module auto-generates a `runtimeSyncSecret` when you enable `runtimeSync` or `cron`. Set `NUXT_AI_READY_RUNTIME_SYNC_SECRET` env var to use your own.
::

## Control Endpoints

When you enable `runtimeSync`, these endpoints become available:

```bash
# Check indexing progress
GET /__ai-ready/status
# Returns: { total: 50, indexed: 45, pending: 5 }

# Trigger batch indexing (requires Authorization: Bearer <token> header if secret configured)
POST /__ai-ready/poll
# Returns: { indexed: 20, remaining: 25, errors: [], duration: 1234, complete: false }

# Process all pending pages (with timeout)
POST /__ai-ready/poll?all=true&timeout=30000
# Returns: { indexed: 45, remaining: 0, errors: [], duration: 28500, complete: true }

# Prune stale routes (dry run - preview what would be pruned)
POST /__ai-ready/prune?dry=true&ttl=604800
# Returns: { routes: ["/old-page"], count: 1, ttl: 604800, dry: true }

# Prune stale routes (execute, requires Authorization: Bearer <token> header)
POST /__ai-ready/prune?ttl=604800
# Returns: { pruned: 1, ttl: 604800, dry: false }
```

You must provide the `Authorization: Bearer <token>`{lang="html"} header for POST endpoints if you configure `runtimeSyncSecret`.

### Poll Endpoint Options

| Param     | Type      | Default | Description                   |
| --------- | --------- | ------- | ----------------------------- |
| `limit`   | `number`  | `10`    | Max pages per batch (max: 50) |
| `all`     | `boolean` | `false` | Process until complete        |
| `timeout` | `number`  | `30000` | Max ms for `all` mode         |

### Prune Endpoint Options

| Param    | Type      | Default           | Description                            |
| -------- | --------- | ----------------- | -------------------------------------- |
| `dry`    | `boolean` | `false`           | Preview stale routes without deleting  |
| `ttl`    | `number`  | `pruneTtl` config | Prune routes older than this (seconds) |
| `secret` | `string`  | -                 | Auth token (required unless dry run)   |

## Scheduled Indexing

When you set `cron: true`, Nitro scheduled tasks enable automatic background indexing (runs every minute):

```ts [nuxt.config.ts]
export default defineNuxtConfig({
  aiReady: {
    cron: true // Runs every minute, auto-enables runtimeSync
  }
})
```

The module auto-enables `nitro.experimental.tasks` when you configure cron.

::warning
**Cloudflare Workers**: Cron triggers are auto-configured in wrangler.toml.

**Cloudflare Pages**: Does not support cron triggers. Use an external scheduler to call `GET /__ai-ready/cron` with `Authorization: Bearer <token>`{lang="html"} header. See the [Cloudflare guide](/docs/ai-ready/guides/cloudflare#cloudflare-pages) for details.
::

## TTL Configuration

| Option     | Default | Description                                                |
| ---------- | ------- | ---------------------------------------------------------- |
| `ttl`      | `3600`  | Re-index pages & refresh sitemap older than this (seconds) |
| `pruneTtl` | `0`     | Delete routes not in sitemap for this long (0 = never)     |

Force re-index regardless of TTL:

```ts
await indexPage('/about', html, { force: true })
```

## Database Configuration

The module uses [SQLite](https://sqlite.org) via [Drizzle ORM](https://orm.drizzle.team/) for page storage. It auto-detects the best driver for your platform:

| Platform                                           | Driver           | Extra dependency |
| -------------------------------------------------- | ---------------- | ---------------- |
| [Node.js](https://nodejs.org) 22.13+               | `node:sqlite`    | None             |
| Earlier [Node.js](https://nodejs.org)              | `better-sqlite3` | `better-sqlite3` |
| [Bun](https://bun.sh)                              | `bun:sqlite`     | None             |
| [Cloudflare](https://cloudflare.com)               | D1               | None             |
| [Vercel](https://vercel.com) (with `POSTGRES_URL`) | Neon Postgres    | None             |

On Node.js before 22.13, install the optional [`better-sqlite3`](https://github.com/WiseLibs/better-sqlite3) peer dependency yourself:

```bash
pnpm add better-sqlite3
```

For edge deployments, configure D1 or LibSQL:

::code-group
```ts [Cloudflare D1]
export default defineNuxtConfig({
  aiReady: {
    database: {
      type: 'd1',
      bindingName: 'AI_READY_DB'
    }
  }
})
```

```ts [Turso/LibSQL]
export default defineNuxtConfig({
  aiReady: {
    database: {
      type: 'libsql',
      url: process.env.TURSO_URL,
      authToken: process.env.TURSO_AUTH_TOKEN
    }
  }
})
```
::

## Serverless Cold Starts

For serverless platforms (Vercel, [Netlify](https://netlify.com), Lambda), the database is ephemeral. The module handles this by:

1. **Build time**: Creates SQLite database and compresses it to `__ai-ready/pages.dump`
2. **Cold start**: `db-restore` plugin decompresses dump and imports into fresh database
3. **Runtime** (if enabled): New pages indexed via sitemap seeder

Prerendered pages are always available, even on cold starts.

## Sync with External Systems

Use the `ai-ready:page:indexed` hook to sync with vector databases, search indexes, or analytics:

```ts [server/plugins/embeddings.ts]
export default defineNitroPlugin((nitro) => {
  nitro.hooks.hook('ai-ready:page:indexed', async (ctx) => {
    // Generate embeddings for vector search
    const embedding = await openai.embeddings.create({
      model: 'text-embedding-3-small',
      input: ctx.markdown
    })

    await vectorDb.upsert({
      id: ctx.route,
      vector: embedding.data[0].embedding,
      metadata: {
        title: ctx.title,
        description: ctx.description,
        route: ctx.route
      }
    })

    console.log(`Indexed ${ctx.route} (update: ${ctx.isUpdate})`)
  })
})
```

## Manual Indexing

Trigger indexing from API routes or plugins:

```ts [server/api/reindex.post.ts]
import { indexPageByRoute } from '#ai-ready'

export default defineEventHandler(async (event) => {
  const { paths } = await readBody(event)

  const results = await Promise.all(
    paths.map((path: string) =>
      indexPageByRoute(path, event, { force: true })
    )
  )

  return {
    indexed: results.filter(r => r.success && !r.skipped).length,
    skipped: results.filter(r => r.skipped).length,
    failed: results.filter(r => !r.success).length
  }
})
```

## Direct Database Access

For advanced use cases, access the database directly:

```ts [server/api/search.ts]
import { searchPages, useDatabase } from '#ai-ready'

export default defineEventHandler(async (event) => {
  const { q } = getQuery(event)

  // FTS5 full-text search
  const results = await searchPages(event, q as string, { limit: 10 })

  return results
})
```

Available query functions:

| Function                                     | Description                         |
| -------------------------------------------- | ----------------------------------- |
| `queryPages(event, opts)`{lang="ts"}         | Query pages with filters/pagination |
| `searchPages(event, query, opts)`{lang="ts"} | FTS5 full-text search               |
| `countPages(event, opts)`{lang="ts"}         | Count pages matching criteria       |
| `streamPages(event, opts)`{lang="ts"}        | Stream pages for large datasets     |
| `upsertPage(event, page)`{lang="ts"}         | Insert or update a page             |

## CLI

Use the `nuxt-ai-ready` CLI to interact with control endpoints:

```bash
# Check indexing status
npx nuxt-ai-ready status

# Trigger batch indexing
npx nuxt-ai-ready poll

# Process all pending pages
npx nuxt-ai-ready poll --all

# Preview stale routes (dry run)
npx nuxt-ai-ready prune --dry

# Prune stale routes
npx nuxt-ai-ready prune --ttl 604800
```

The CLI auto-authenticates using the generated secret. See the [CLI guide](/docs/ai-ready/guides/cli) for all commands and options.