Hvordan håndterer AI-crawlere uendelig rulling? Innholdet vårt blir ikke indeksert

La meg forklare hvordan ulike AI-crawlere håndterer JavaScript:

AI-crawler JavaScript-støtte:

Kjerneproblemet:

Uendelig rulling krever:

1. Utførelse av JavaScript
2. Utløsning av rullehendelser
3. Ytterligere HTTP-forespørsler
4. Rendering av nytt innhold

De fleste AI-crawlere feiler ved trinn 1 eller 2.

Hvorfor SSR ikke er nok:

SSR leverer den første siden. Men innholdet fra uendelig rulling er ikke “innledende” – det lastes inn ved interaksjon. SSR løser ikke avhengigheten til interaksjon.

Det grunnleggende problemet:

Uendelig rulling er grunnleggende inkompatibelt med dagens AI-crawler-kapasiteter. Du trenger en alternativ løsning.

Vi hadde nøyaktig det samme problemet. Her er løsningen vår:

Implementering av hybrid tilnærming:

// URL-struktur
/blog              // Uendelig rulling (standard for brukere)
/blog/archive/1    // Paginerte (tilgjengelig for crawlere)
/blog/archive/2

Viktige implementeringsdetaljer:

1. Sitemap inkluderer kun paginerte URL-er

   • AI-crawlere finner /blog/archive/* sider
   • Disse gjengir alt innhold fra server

2. Uendelig rulling-side laster samme innhold

   • Bruker paginerings-API i bakgrunnen
   • Bedre UX for mennesker

3. Interne lenker peker til enkeltartikler

   • Ikke til uendelig rulling-posisjon
   • Hver artikkel har sin egen URL

4. robots.txt-veiledning:

# La crawlere fokusere på enkeltartikler
# Ikke uendelig rulling-containeren
Sitemap: /sitemap.xml

Resultater:

• Brukeropplevelsen uendret (uendelig rulling)
• AI-crawlere får tilgang til alt innhold via arkivsider
• Enkeltartikler blir indeksert
• Siteringsraten økte 4x etter implementeringen

Next.js-spesifikk løsning:

Bruke getStaticPaths + getStaticProps:

// pages/blog/page/[page].js
export async function getStaticPaths() {
  const totalPages = await getTotalPages();
  const paths = Array.from({ length: totalPages }, (_, i) => ({
    params: { page: String(i + 1) }
  }));
  return { paths, fallback: false };
}

export async function getStaticProps({ params }) {
  const posts = await getPostsForPage(params.page);
  return { props: { posts, page: params.page } };
}

Fordeler:

• Statiske sider for hver paginering
• Fullt innhold i HTML ved build
• AI-crawlere får komplett innhold
• Rask lasting (statisk)

Legg deretter til uendelig rulling som forbedring:

• Klientside uendelig rulling bruker samme API
• Progressiv forbedring
• Fungerer også uten JS

Dette gir deg det beste fra begge verdener.

Forhåndsrendring som et alternativ:

Forhåndsrendringstjenester for AI-crawlere:

Du kan oppdage AI-crawler user agents og servere forhåndsrendret innhold:

// middleware
if (isAICrawler(req.headers['user-agent'])) {
  return servePrerenderedVersion(req.url);
}

AI-crawler deteksjon:

const aiCrawlers = [
  'GPTBot',
  'ChatGPT-User',
  'Google-Extended',
  'ClaudeBot',
  'PerplexityBot',
  'anthropic-ai'
];

function isAICrawler(userAgent) {
  return aiCrawlers.some(crawler =>
    userAgent.includes(crawler)
  );
}

Forhåndsrendringsvalg:

• Prerender.io
• Rendertron
• Egendefinert Puppeteer-løsning
• Forhåndsrendring ved build

Obs:

Ikke alle AI-crawlere identifiserer seg tydelig. Noen kan bli oversett. Dette er en tilleggsmetode, ikke en erstatning for skikkelig paginering.

Testmetodikk for AI-crawler-tilgjengelighet:

Manuelle tester:

1. Deaktiver JavaScript-test:

   • Åpne bloggen i nettleser
   • Deaktiver JavaScript
   • Hva er synlig?
   • Dette tilsvarer synet til mange crawlere uten JS

2. Vis kildekode-test:

   • Vis sidens kildekode (ikke inspeksjon)
   • Er innholdet i HTML-en?
   • Eller bare JavaScript-plassholdere?

3. curl-test:

   curl -A "GPTBot/1.0" https://dittnettsted.com/blog/
   

   • Inneholder svaret faktisk innhold?

Automatiserte tester:

4. Google Search Console:

   • URL-inspeksjonsverktøy
   • “Vis gjengitt side” viser hva Googlebot ser
   • (Ikke AI-crawlere, men lignende JS-rendering)

5. Lighthouse-gjennomgang:

   • Sjekk “SEO”-kategori
   • Gjennomgang for crawlingsproblemer

Hva du vil se:

• Innhold i første HTML-respons
• Lenker til alle sider oppdagbare
• Ingen JS kreves for synlighet av innhold

E-handelsperspektiv:

Vi har 10 000+ produkter med “last mer”-funksjon. Her er vår løsning:

Kategori-side-struktur:

/category/shoes                    # Første 24 produkter + last mer
/category/shoes?page=2            # Produkter 25-48
/category/shoes?page=3            # Produkter 49-72

Implementering:

1. Første side har alltid pagineringslenker

   • Selv med uendelig rulling aktivert
   • Bunntekst inneholder side 1, 2, 3 … lenker

2. ?page=-parametre er kanoniske

   • Hver side har eget innhold
   • Ikke duplikat av hovedsiden

3. Sitemap inkluderer alle paginerte URL-er

   • Ikke bare uendelig rulling-basert URL

4. Produkter har egne URL-er

   • Kategoripaginering er for oppdagelse
   • Produktene er selve innholdet

Resultat:

AI-plattformer siterer våre individuelle produktsider, som de oppdager via den paginerte kategoristrukturen.

Dette har vært utrolig nyttig. Her er min implementeringsplan:

Tilnærming: Hybrid paginering

Fase 1: Legg til paginerte ruter (Uke 1-2)

• Lag /blog/archive/[page]-ruter
• SSR for alt innhold i HTML
• Inkluder pagineringsnavigasjon
• Oppdater sitemap til å inkludere disse

Fase 2: Oppdater eksisterende uendelig rulling (Uke 3)

• Behold uendelig rulling for /blog
• Bruk arkivsider som datakilde
• Canonical fra /blog til /blog/archive/1

Fase 3: Testing og validering (Uke 4)

• Test med JS deaktivert
• curl-tester for AI-user agents
• Overvåk AI-siteringsrater

Teknisk implementering:

/blog                 → Uendelig rulling (mennesker, canonical til archive/1)
/blog/archive/1       → Paginert (crawlere, canonical til seg selv)
/blog/archive/2       → Paginert (crawlere)
/blog/[slug]          → Enkeltartikler (hovedinnhold)

Viktige prinsipper:

• Innhold tilgjengelig uten JavaScript
• Hvert innhold har en direkte URL
• Sitemap inkluderer alle innholdssider
• Uendelig rulling er en forbedring, ikke et krav

Takk til alle for detaljert teknisk veiledning.