---
title: "How to Fix Indexing Issues in Nuxt"
description: "Diagnose \"crawled - not indexed\" and other GSC statuses, then fix them with useFetch, routeRules caching, and canonical tags in Nuxt."
canonical_url: "https://nuxtseo.com/learn-seo/nuxt/launch-and-listen/indexing-issues"
last_updated: "2026-07-16"
---

<key-takeaways>

- "Crawled - currently not indexed" means Google saw your page but chose not to index it, which also keeps it out of AI Overviews since those cite from the same index
- Verify SSR by checking View Source for your content, not just DevTools; `onMounted()` fetches never reach the HTML Google crawls
- Use `useFetch()` or `useAsyncData()` so data resolves during server rendering instead of after hydration
- Requesting indexing through URL Inspection doesn't guarantee a result; Google still evaluates the page and prioritizes fast inclusion of useful content

</key-takeaways>

Google crawled your page but hasn't indexed it. The Page Indexing report in Search Console explains why, and most causes are fixable from Nuxt config or a component.

## Understanding Page Indexing Status

Search Console's Page Indexing report groups around 19 status reasons into four categories: Indexed, Not indexed, Duplicate/Alternate, and Warnings. See the [full list](https://support.google.com/webmasters/answer/7440203) for every reason. This guide covers the statuses that generate the most confusion: crawled-not-indexed, discovered-not-indexed, and the excluded statuses worth ruling out first.

![Page Indexing Status Flowchart](/images/learn-seo/vue/indexing-status-flowchart.svg)

**Indexed**: your page is in Google's index. This is a prerequisite for appearing in AI Overviews, which [cite from the same index Google Search uses](https://developers.google.com/search/docs/appearance/ai-features) rather than a separate crawl.

**Discovered - currently not indexed**: Google found your page, often via your sitemap, but hasn't crawled it yet.

**Crawled - currently not indexed**: Google crawled your page and chose not to index it.

**Excluded by robots.txt**: your robots.txt file blocks Google from accessing the page. AI Overviews draw on the same crawled index as regular search, so blocking Googlebot here excludes the page from both.

**Blocked by noindex tag**: the page has a `noindex` meta tag, so Google won't index it or use it as an AI Overviews source.

**Duplicate without user-selected canonical**: Google found multiple versions of the page and none is marked as the canonical.

**Soft 404**: the page returns a `200 OK` status but reads like a "not found" page to Google. Return a real 404 for missing content instead.

## Fixing "Crawled - Currently Not Indexed"

Google doesn't publish the specific reason for any single page. Algorithmic updates, like the June 2025 and March 2026 core updates, can shift which pages clear the bar, but the causes below are the ones you can act on directly.

### Thin or Low-Quality Content

Google skips pages with little unique value. If a page isn't good enough for a normal search result, it won't be an AI Overviews source either, since [AI features require the page to be indexed and eligible to show a snippet](https://developers.google.com/search/docs/appearance/ai-features).

Fix: add substantial, original content. Use [Schema.org](/learn-seo/nuxt/mastering-meta/schema-org) to describe the page's purpose to both crawlers and LLMs.

### Duplicate Content

Multiple pages with identical content waste Google's crawl budget. See the [Duplicate Content guide](/learn-seo/nuxt/controlling-crawlers/duplicate-content) for a full detection and resolution workflow.

Fix: implement [canonical tags](/learn-seo/nuxt/controlling-crawlers/canonical-urls) pointing to the primary version:

```vue
<script setup lang="ts">
useHead({
  link: [
    { rel: 'canonical', href: 'https://yoursite.com/primary-page' }
  ]
})
</script>
```

### Too Many Similar Pages

Sites with thousands of near-identical pages, like faceted search or filter combinations, trigger the same quality filters. Google picks a representative page and excludes the rest.

Fix: noindex filtered and parameter-based URLs, or block them in robots.txt:

```vue
<script setup lang="ts">
const route = useRoute()

// Noindex pages with filter parameters
const shouldNoIndex = computed(() =>
  route.query.color || route.query.size || route.query.sort
)

useSeoMeta({
  robots: shouldNoIndex.value ? 'noindex, follow' : 'index, follow'
})
</script>
```

### Poor Internal Linking

Pages with few or no internal links pointing to them signal low importance to Google. Orphan pages, reachable only via [sitemap](/learn-seo/nuxt/controlling-crawlers/sitemaps) and not through any `<a href>` on your site, rarely get indexed.

Fix: add internal links from relevant pages, include new pages in your navigation or sidebar, and link from high-authority pages to new content. See [Internal Linking Strategy](/learn-seo/nuxt/routes-and-rendering/internal-linking) for architecture patterns.

### Low Site Authority (E-E-A-T)

New sites with few backlinks face stricter indexing thresholds; Google prioritizes crawling sites it already trusts.

Fix: build backlinks and brand mentions over time: guest posts, linkable assets like tools or original research, and industry directory listings all help. This is ongoing work, not a one-time fix. See [Backlinks & Authority](/learn-seo/backlinks) for developer-friendly link building strategies.

## Fixing "Discovered - Currently Not Indexed"

### Site Too New

Google publishes no fixed timeline for crawling new sites. Site owners commonly report slower initial crawling for brand-new domains until Google establishes a regular crawl pattern.

Fix: submit your sitemap, request indexing for critical pages via URL Inspection, and keep publishing regularly.

### Crawl Budget Issues

Google's crawl-budget guidance targets [sites with 10,000+ pages updated daily, or 1M+ pages updated weekly](https://developers.google.com/search/docs/crawling-indexing/large-site-managing-crawl-budget), though it calls these rough estimates rather than hard thresholds. Server speed affects the budget directly: "if the site slows down or responds with server errors, the limit goes down."

Fix: speed up your server. There's no official crawl-budget millisecond threshold, but web.dev's [TTFB guidance](https://web.dev/articles/ttfb) puts "Good" at under 800ms. Enable caching, use a CDN, optimize database queries, and monitor response times in Search Console's Crawl Stats report.

Cache instead of re-rendering on every crawl with `routeRules`:

```ts
// nuxt.config.ts
export default defineNuxtConfig({
  routeRules: {
    '/blog/**': { swr: 3600 },
    '/api/**': { cache: { maxAge: 60 } }
  }
})
```

Block unnecessary URLs in robots.txt, either with a static file:

```txt [public/robots.txt]
User-agent: *
Disallow: /admin/
Disallow: /search?*
Disallow: /*?filter=*
Disallow: /print-version/
```

Or the `@nuxtjs/robots` module for config-driven control:

```ts
// nuxt.config.ts
export default defineNuxtConfig({
  modules: ['@nuxtjs/robots'],
  robots: {
    disallow: [
      '/admin/',
      '/search?*',
      '/*?filter=*',
      '/print-version/'
    ]
  }
})
```

Pages that exist only in your sitemap, with no internal links pointing to them, get the same low-priority treatment. Fix: add internal links from relevant pages and don't rely solely on sitemaps for discovery. [Internal linking signals importance](/learn-seo/nuxt/routes-and-rendering/internal-linking).

## Verifying SSR in Nuxt

Nuxt renders pages on the server by default, which helps indexing. Verify it's working:

### Check the Server Response

View your page source to confirm content is in the initial HTML, not just what DevTools shows after hydration:

```bash
# Check if content is in server-rendered HTML
curl -s https://yoursite.com/page | grep "expected content"
```

If your content isn't there, check that:

1. The page doesn't set `ssr: false` in `definePageMeta()`
2. Data fetching uses `useAsyncData()` or `useFetch()`, not a client-only method
3. `nuxt.config.ts` doesn't set `ssr: false` globally

### Verify Data Fetching

```vue
<script setup lang="ts">
// CORRECT: data available during SSR
const { data: products } = await useFetch('/api/products')

// WRONG: only loads on client, Google might miss this
// onMounted(() => {
//   (async () => {
//     products.value = await $fetch('/api/products')
//   })()
// })
</script>
```

### Handle Client-Only Content

For content that must load client-side, give it fallback text that Google can still index:

```vue
<template>
  <div>
    <h1>Product Catalog</h1>
    <ClientOnly>
      <LazyProductList />
      <template #fallback>
        <p>Loading 500+ products from our catalog...</p>
      </template>
    </ClientOnly>
  </div>
</template>
```

### Test Rendering Modes

Nuxt supports hybrid rendering. Check your route rules match what each route needs:

```ts
// nuxt.config.ts
export default defineNuxtConfig({
  routeRules: {
    // Static pages (prerendered)
    '/': { prerender: true },
    '/about': { prerender: true },

    // Dynamic pages (SSR)
    '/blog/**': { swr: 3600 },

    // Client-only pages (if genuinely needed)
    '/dashboard/**': { ssr: false }
  }
})
```

Then confirm what Google sees:

1. Search Console → URL Inspection
2. Enter your page URL, click "Test Live URL"
3. Click "View Tested Page" → "Screenshot"

Compare the screenshot to your actual page. With proper SSR, they should be identical.

## AI Visibility Gaps

A page can be indexed for regular search and still get skipped by AI Overviews. Likely reasons:

- No structured data: [JSON-LD](/learn-seo/nuxt/mastering-meta/schema-org) helps LLMs parse a page's purpose faster than plain HTML
- Content that's hard to parse: poor heading structure or a wall of undifferentiated text
- A `nosnippet` tag: this also blocks the page from AI Overviews, since [AI features use the same snippet controls as regular search results](https://developers.google.com/search/docs/appearance/ai-features)

## Requesting Re-Indexing

After fixing an issue, request re-indexing via URL Inspection:

1. Search Console → URL Inspection
2. Enter the fixed URL
3. Click "Request Indexing"

[A crawl request doesn't guarantee inclusion](https://developers.google.com/search/docs/crawling-indexing/ask-google-to-recrawl): "Requesting a crawl does not guarantee that inclusion in search results will happen instantly or even at all. Our systems prioritize the fast inclusion of high quality, useful content." Google's crawlers also revisit indexed pages on their own to [pick up changes](https://developers.google.com/search/docs/crawling-indexing/large-site-managing-crawl-budget), so save manual requests for infrequent, important changes.

For many URLs, request indexing programmatically with the [Google Indexing API](https://developers.google.com/search/apis/indexing-api/v3/quickstart), which only covers `JobPosting` and `BroadcastEvent` structured data, or [RequestIndexing](https://requestindexing.com/) for general content:

```ts
// server/api/request-indexing.post.ts
import { google } from 'googleapis'

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

  const auth = await google.auth.getClient({
    scopes: ['https://www.googleapis.com/auth/indexing']
  })

  const indexing = google.indexing({ version: 'v3', auth })

  await indexing.urlNotifications.publish({
    requestBody: {
      url,
      type: 'URL_UPDATED'
    }
  })

  return { success: true }
})
```

## Monitoring Progress

Track indexing status changes over time:

1. Search Console → Page Indexing
2. Check the "Not indexed" count weekly
3. Look for status changes from "Crawled - not indexed" to "Indexed"

Google re-evaluates pages on its own schedule, not on demand, so there's no fixed timeline for a status change to show up.

Checking "Not indexed" counts by hand every week doesn't scale past a few pages. [Nuxt SEO Pro](https://nuxtseo.com/pro) tracks each page's indexing status over time and tells you why a URL is stuck (crawled-not-indexed, discovered-not-indexed, blocked, redirect), so you act on diagnoses instead of re-checking a dashboard.

## Checklist

<checklist id="nuxt-indexing-issues">

- View source confirms your content ships in Nuxt's initial HTML, not only after hydration
- Data fetching uses `useFetch()` or `useAsyncData()`, never a bare `onMounted()` fetch
- Duplicate pages have a canonical tag pointing to one primary version
- Low-value or filtered URLs are noindexed or blocked in robots.txt
- `routeRules` cache heavy routes instead of re-rendering on every crawl
- New or fixed pages are submitted via URL Inspection or the Indexing API

</checklist>