Früher reichte es, eine Sitemap bei Google einzureichen und ein bisschen zu warten. Heute sieht das etwas anders aus: Wer neue Inhalte schnell bei Google platzieren will, muss gezielter vorgehen.

Stellen Sie sich vor: Sie launchen eine neue Produktseite, einen wichtigen Blogartikel oder 160 Landingpages für eine Kampagne. Mit der klassischen Sitemap-Methode dauert es oft 3-7 Tage, bis Google crawlt und indexiert. Mit der Google Indexing API sind es oft nur wenige Stunden. Bei zeitkritischen Inhalten – etwa für Events, Produktlaunches oder News – macht das den entscheidenden Unterschied.

“Schnelle Indexierung ist kein Luxus mehr – es ist ein Wettbewerbsvorteil.”

In diesem Artikel erfährst du, wie die Google Indexing API funktioniert, welche Einschränkungen es gibt und wie du sie konkret für deine Seite einrichtest – mit Code-Beispielen, Tool-Empfehlungen und praktischen Workflows.

Früher: Sitemap & URL-Inspection in der Search Console

Bis vor wenigen Jahren war das Standard-Vorgehen relativ einfach:

Der klassische Workflow

1. XML-Sitemap anlegen – alle URLs in einer strukturierten Datei
2. In der Google Search Console einreichen – Google informieren, wo die Sitemap liegt
3. Warten – bis Google crawlt (kann Stunden bis Wochen dauern)
4. Optional: Einzelne URLs manuell via URL-Inspection einreichen

Die Probleme dieses Ansatzes

Bei wenigen Seiten: Funktioniert noch ganz gut. Eine Handvoll URLs kann man manuell einreichen.

Bei vielen Seiten (z.B. 160 URLs):

• Zeitaufwand: Jede URL einzeln per URL-Inspection einreichen ist mühsam
• Crawl-Budget: Google crawlt nicht alle Seiten gleichzeitig
• Verzögerung: Selbst nach Einreichung kann es Tage dauern
• Keine Garantie: Google entscheidet, wann (und ob) gecrawlt wird

Praxis-Beispiel:

Ein E-Commerce-Shop launcht 50 neue Produktseiten für eine Sommer-Kampagne. Mit der Sitemap-Methode:

• Tag 1: Sitemap eingereicht
• Tag 3: Google crawlt erste 10 Seiten
• Tag 7: 30 Seiten indexiert
• Tag 14: Restliche 20 Seiten indexiert

Problem: Die Kampagne läuft nur 2 Wochen – die Hälfte der Produkte ist erst sichtbar, wenn die Kampagne fast vorbei ist.

Neu & schneller: Google Indexing API

Die Google Indexing API erlaubt es, URLs direkt an Google zu „pushen”. Das heißt: Du sendest pro Seite eine gezielte Anfrage an Google, damit diese möglichst zeitnah gecrawlt und in den Index aufgenommen wird.

Vorteile

1. Geschwindigkeit:

• Indexierung oft innerhalb von 2-24 Stunden (statt Tage/Wochen)
• Bei wichtigen Updates: noch schneller

2. Automatisierung:

• Keine manuelle Einreichung pro URL nötig
• Per Skript alle URLs auf einmal übermitteln
• In CI/CD-Pipelines integrierbar (z.B. nach Deployment)

3. Kontrolle:

• Du entscheidest, welche URLs priorisiert werden
• Sofortige Bestätigung über API-Response
• Tracking von erfolgreichen vs. fehlgeschlagenen Requests

Einschränkungen (wichtig!)

Offizieller Anwendungsbereich:

• Die API ist offiziell nur für JobPosting- und BroadcastEvent-Seiten gedacht
• Google dokumentiert explizit: “Not intended for general use”

Inoffizielle Nutzung:

• Funktioniert auch für normale Seiten (Blogs, Produktseiten, etc.)
• Kein offizieller Support bei Problemen
• Risiko: Google könnte zukünftig Nicht-Job/Event-URLs ablehnen

Technische Limits:

• 200 URLs pro Tag pro Property (Google Cloud Projekt)
• 600.000 API-Calls pro Monat (mehr als ausreichend für die meisten Projekte)
• Rate Limiting: Max. 600 Requests/Minute

Praxis-Tipp: Für die meisten Websites (auch ohne Job/Event-Content) funktioniert die API problemlos. Große Portale sollten zusätzlich weiterhin auf Sitemaps setzen.

Technische Voraussetzungen & Setup

Um die Indexing API zu nutzen, brauchst du einige technische Vorbereitungen. Hier eine Schritt-für-Schritt-Anleitung:

Schritt 1: Google Cloud Projekt anlegen

1. Gehe zu Google Cloud Console
2. Erstelle ein neues Projekt (z.B. “Indexing-API-Projekt”)
3. Wähle das Projekt aus

Schritt 2: Indexing API aktivieren

1. Navigiere zu APIs & Services → Library
2. Suche nach “Indexing API”
3. Klicke auf Enable (Aktivieren)

Schritt 3: Service Account einrichten

Ein Service Account ist wie ein “Robot-Benutzer”, der API-Anfragen im Namen deiner Domain stellt.

Vorgehensweise:

1. Gehe zu APIs & Services → Credentials
2. Klicke Create Credentials → Service Account
3. Name: z.B. “indexing-bot”
4. Role: Owner (wichtig für Search Console Zugriff)
5. Klicke Done

Private Key erstellen:

1. Klicke auf den neu erstellten Service Account
2. Gehe zu Keys → Add Key → Create new key
3. Wähle JSON
4. Download der Datei (z.B. indexing-service-account.json)

⚠️ Wichtig: Diese JSON-Datei enthält Zugangsdaten – niemals in Git committen oder öffentlich teilen!

Schritt 4: Search Console Verknüpfung

Der Service Account muss als Owner deiner Domain in der Search Console eingetragen werden:

1. Gehe zu Google Search Console
2. Wähle deine Property aus
3. Einstellungen → Nutzer und Berechtigungen
4. Klicke Nutzer hinzufügen
5. E-Mail-Adresse: Die Service Account E-Mail aus dem JSON-File (z.B. [email protected])
6. Berechtigung: Inhaber (Owner)
7. Bestätigen

Ohne diesen Schritt funktioniert die API nicht!

Schritt 5: API-Anfragen senden

Jetzt kannst du URLs an die API übermitteln.

API-Endpunkt:

POST https://indexing.googleapis.com/v3/urlNotifications:publish

Request-Body:

{
  "url": "https://www.deineseite.de/beispiel",
  "type": "URL_UPDATED"
}

Response:

{
  "urlNotificationMetadata": {
    "url": "https://www.deineseite.de/beispiel",
    "latestUpdate": {
      "url": "https://www.deineseite.de/beispiel",
      "type": "URL_UPDATED",
      "notifyTime": "2025-07-13T10:30:00.000Z"
    }
  }
}

Code-Beispiele für verschiedene Sprachen

Node.js (JavaScript)

const { google } = require('googleapis');
const key = require('./indexing-service-account.json');

async function indexURL(url) {
  const jwtClient = new google.auth.JWT(
    key.client_email,
    null,
    key.private_key,
    ['https://www.googleapis.com/auth/indexing'],
    null
  );

  await jwtClient.authorize();

  const indexing = google.indexing('v3');
  
  const response = await indexing.urlNotifications.publish({
    auth: jwtClient,
    requestBody: {
      url: url,
      type: 'URL_UPDATED'
    }
  });

  console.log(`✓ Indexed: ${url}`);
  return response.data;
}

// Beispiel: Mehrere URLs indexieren
const urls = [
  'https://www.deineseite.de/seite-1',
  'https://www.deineseite.de/seite-2',
  'https://www.deineseite.de/seite-3'
];

(async () => {
  for (const url of urls) {
    await indexURL(url);
    // Kleine Pause zwischen Requests (Rate Limiting)
    await new Promise(resolve => setTimeout(resolve, 100));
  }
})();

Installation:

npm install googleapis

Python

from oauth2client.service_account import ServiceAccountCredentials
from httplib2 import Http
import json

SCOPES = ["https://www.googleapis.com/auth/indexing"]
JSON_KEY_FILE = "indexing-service-account.json"

def index_url(url):
    credentials = ServiceAccountCredentials.from_json_keyfile_name(
        JSON_KEY_FILE, scopes=SCOPES
    )
    http = credentials.authorize(Http())
    
    content = {
        "url": url,
        "type": "URL_UPDATED"
    }
    
    response, content = http.request(
        "https://indexing.googleapis.com/v3/urlNotifications:publish",
        method="POST",
        headers={"Content-Type": "application/json"},
        body=json.dumps(content)
    )
    
    print(f"✓ Indexed: {url}")
    return json.loads(content)

# Beispiel: URLs aus Sitemap indexieren
urls = [
    "https://www.deineseite.de/seite-1",
    "https://www.deineseite.de/seite-2",
    "https://www.deineseite.de/seite-3"
]

for url in urls:
    index_url(url)

Installation:

pip install oauth2client httplib2

Bash/Shell (mit curl)

#!/bin/bash

# Service Account JSON parsen
CLIENT_EMAIL=$(jq -r .client_email indexing-service-account.json)
PRIVATE_KEY=$(jq -r .private_key indexing-service-account.json)

# OAuth2 Token holen
TOKEN=$(curl -s -X POST https://oauth2.googleapis.com/token \
  -H "Content-Type: application/json" \
  -d "{
    \"grant_type\": \"urn:ietf:params:oauth:grant-type:jwt-bearer\",
    \"assertion\": \"$(echo -n '...' | base64)\"
  }" | jq -r .access_token)

# URL indexieren
URL="https://www.deineseite.de/beispiel"

curl -X POST https://indexing.googleapis.com/v3/urlNotifications:publish \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d "{
    \"url\": \"$URL\",
    \"type\": \"URL_UPDATED\"
  }"

Hinweis: Die Shell-Variante ist komplexer wegen JWT-Handling – Node.js oder Python sind einfacher.

Automatisierung: URLs aus Sitemap indexieren

Ein praktischer Workflow: Automatisch alle URLs aus deiner Sitemap an die API senden.

Node.js Beispiel mit Sitemap-Parsing

const { google } = require('googleapis');
const axios = require('axios');
const xml2js = require('xml2js');
const key = require('./indexing-service-account.json');

async function getSitemapURLs(sitemapUrl) {
  const response = await axios.get(sitemapUrl);
  const parser = new xml2js.Parser();
  const result = await parser.parseStringPromise(response.data);
  
  return result.urlset.url.map(entry => entry.loc[0]);
}

async function indexURL(url, jwtClient, indexing) {
  try {
    await indexing.urlNotifications.publish({
      auth: jwtClient,
      requestBody: {
        url: url,
        type: 'URL_UPDATED'
      }
    });
    console.log(`✓ ${url}`);
  } catch (error) {
    console.error(`✗ ${url}: ${error.message}`);
  }
}

(async () => {
  // JWT Client einmalig erstellen
  const jwtClient = new google.auth.JWT(
    key.client_email,
    null,
    key.private_key,
    ['https://www.googleapis.com/auth/indexing'],
    null
  );
  await jwtClient.authorize();
  
  const indexing = google.indexing('v3');
  
  // URLs aus Sitemap holen
  const urls = await getSitemapURLs('https://www.deineseite.de/sitemap.xml');
  
  console.log(`Found ${urls.length} URLs in sitemap`);
  
  // Limit: 200 URLs/Tag
  const limitedUrls = urls.slice(0, 200);
  
  // URLs indexieren mit Rate Limiting
  for (const url of limitedUrls) {
    await indexURL(url, jwtClient, indexing);
    // 100ms Pause (max 600 requests/min)
    await new Promise(resolve => setTimeout(resolve, 100));
  }
  
  console.log(`\nDone! Indexed ${limitedUrls.length} URLs`);
})();

Installation:

npm install googleapis axios xml2js

Optional: Fertige Tools nutzen

Falls dir die API-Einrichtung zu aufwändig ist oder du schnell starten willst, gibt es kommerzielle und Open-Source-Tools:

Kommerzielle Tools

Open-Source-Alternativen

• instant-indexing-cli – Node.js CLI-Tool
• google-indexing-api-python – Python-Wrapper

Vorteil von Tools: Keine technische Einrichtung, sofort nutzbar

Nachteil: Kosten, weniger Flexibilität, Abhängigkeit von Drittanbietern

Alternative: Sitemap weiterhin pflegen

Auch wenn die Indexing API deutlich schneller ist: Eine gepflegte XML-Sitemap bleibt wichtig.

Warum Sitemaps weiterhin relevant sind

1. Backup-Mechanismus: Falls die API Probleme hat
2. Crawl-Priorisierung: Google versteht die Struktur deiner Site
3. Metadaten: lastmod, changefreq, priority geben Hinweise
4. Compliance: Manche Branchen/Projekte verlangen Sitemaps

Best Practices für Sitemaps

Struktur:

<?xml version="1.0" encoding="UTF-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
  <url>
    <loc>https://www.deineseite.de/seite-1</loc>
    <lastmod>2025-07-13</lastmod>
    <changefreq>monthly</changefreq>
    <priority>0.8</priority>
  </url>
  <url>
    <loc>https://www.deineseite.de/seite-2</loc>
    <lastmod>2025-07-12</lastmod>
    <changefreq>weekly</changefreq>
    <priority>1.0</priority>
  </url>
</urlset>

Referenz in robots.txt:

User-agent: *
Allow: /

Sitemap: https://www.deineseite.de/sitemap.xml

Sitemap manuell “pingen”

Du kannst Google auch direkt über eine URL benachrichtigen:

https://www.google.com/ping?sitemap=https://www.deineseite.de/sitemap.xml

Hinweis: Funktioniert, aber keine Garantie für schnellere Indexierung. Die Indexing API ist zuverlässiger.

Kosten-Übersicht

Fazit: Die API selbst ist kostenlos. Nur wenn du andere Google Cloud Services nutzt, können Kosten entstehen.

Best Practices & Tipps

1. Nicht alle URLs gleichzeitig senden

Problem: 160 URLs auf einmal übermitteln kann Rate Limits triggern.

Lösung:

• Schicke maximal 200 URLs/Tag
• Bei großen Sitemaps: In Batches aufteilen (z.B. 50 URLs alle 2 Stunden)
• Pause zwischen Requests: ~100ms (600 requests/min Limit)

2. Priorisierung wichtiger Seiten

Nicht alle Seiten sind gleich wichtig.

Strategie:

• Hoch-priorisierte URLs (neue Produkte, wichtige Blogartikel): Sofort via API
• Standard-Seiten: Via Sitemap (langsamere Indexierung ok)
• Low-Priority (alte Archiv-Seiten): Nur Sitemap

3. Monitoring & Fehlerbehandlung

Erfolgreiche Requests tracken:

const fs = require('fs');

async function logIndexing(url, success, error = null) {
  const log = {
    timestamp: new Date().toISOString(),
    url,
    success,
    error
  };
  
  fs.appendFileSync('indexing-log.json', JSON.stringify(log) + '\n');
}

Fehlgeschlagene URLs erneut probieren:

• Timeout-Fehler: Später erneut versuchen
• 403 Forbidden: Service Account Berechtigung prüfen
• 429 Too Many Requests: Rate Limiting – Pause einlegen

4. Kombination mit anderen SEO-Maßnahmen

Die Indexing API alleine reicht nicht:

Zusätzlich wichtig:

• Interne Verlinkung – Google folgt Links
• Externe Backlinks – erhöht Crawl-Frequenz
• Content-Qualität – schlechter Content wird nicht besser indexiert
• Core Web Vitals – Performance beeinflusst Crawling

5. Regelmäßige Aktualisierungen

Workflow-Idee:

• Nach jedem Deployment: Geänderte URLs automatisch via API senden
• Wöchentlich: Sitemap-Check und neue URLs indexieren
• Monatlich: Search Console Performance prüfen

Häufige Fehler & Troubleshooting

Error: “Permission denied”

Ursache: Service Account nicht als Owner in Search Console eingetragen

Lösung:

1. Search Console → Einstellungen → Nutzer
2. Service Account E-Mail als Inhaber hinzufügen

Error: “The caller does not have permission”

Ursache: Falsche Scopes in der JWT-Authentifizierung

Lösung: Scope muss sein:

['https://www.googleapis.com/auth/indexing']

URLs werden nicht indexiert trotz API-Call

Mögliche Gründe:

• noindex-Tag im HTML
• robots.txt blockiert Crawling
• Duplicate Content – Google ignoriert die Seite
• Qualität – Seite erfüllt nicht Googles Standards

Prüfung:

1. URL-Inspection in Search Console
2. robots.txt prüfen
3. HTML-Meta-Tags checken

Rate Limit überschritten

Error: “429 Too Many Requests”

Lösung:

• Requests pro Minute reduzieren (max. 600)
• Längere Pausen zwischen Batches
• Über mehrere Tage verteilen

Praxis-Beispiel: 160 URLs indexieren

Szenario: Du hast eine neue Website mit 160 Landingpages gelauncht.

Workflow:

1. Sitemap generieren:

# Alle URLs sammeln
https://www.deineseite.de/sitemap.xml

2. Skript vorbereiten:

// urls.json
[
  "https://www.deineseite.de/seite-1",
  "https://www.deineseite.de/seite-2",
  // ... 158 weitere
]

3. Indexierung starten:

node index-urls.js

4. Ergebnis:

• Tag 1: 160 URLs via API gesendet
• Nach 6 Stunden: Erste 50 URLs indexiert
• Nach 24 Stunden: 140 URLs indexiert
• Nach 48 Stunden: Alle 160 URLs im Index

Vergleich mit Sitemap-Methode:

• Tag 1-3: Keine Indexierung
• Tag 7: ~40 URLs indexiert
• Tag 14: ~120 URLs indexiert
• Tag 21: Alle URLs indexiert

Zeitersparnis: ~19 Tage! Bei zeitkritischen Kampagnen entscheidend.

Zusammenfassung: Wann welche Methode?

Empfehlung für 2025

Die beste Strategie kombiniert mehrere Ansätze:

1. Indexing API für neue/wichtige Seiten (Launch, Updates, Events)
2. Sitemap als Basis für alle URLs (langfristige Absicherung)
3. URL Inspection für kritische Einzelseiten bei Problemen
4. Interne Verlinkung für natürliches Crawling

Wer heute viele Seiten neu veröffentlicht oder ändert, sollte sich mit der Google Indexing API beschäftigen. Für Entwickler mit etwas API-Erfahrung ist die Einrichtung gut machbar und spart langfristig enorm viel Zeit. Mit einer Kombination aus API und gepflegter Sitemap bist du technisch auf der sicheren Seite und bekommst deine Inhalte deutlich schneller sichtbar.

Die investierte Zeit (2-4 Stunden Setup) amortisiert sich bereits beim ersten größeren Content-Launch. Und in einer Zeit, wo schnelle Sichtbarkeit oft über Erfolg oder Misserfolg einer Kampagne entscheidet, ist die Indexing API ein klarer Wettbewerbsvorteil.

---

Weiterführende Informationen

Offizielle Google Ressourcen:

• Google Indexing API Quickstart – Offizielle Dokumentation
• Google Search Console – Property Management
• Google Cloud Console – API-Aktivierung

Tools & Services:

• getIndexed.io – Kommerzielle Indexing-Plattform
• IndexNow – Microsoft/Bing Alternative
• RankMath – WordPress SEO Plugin mit Instant Indexing

Code & Beispiele:

• instant-indexing-cli (GitHub) – Open-Source CLI-Tool
• Google APIs Node.js Client – Offizielle Library

Sitemap-Tools:

• XML-Sitemaps.com – Sitemap Generator
• Screaming Frog – SEO Crawler für große Sites

Die Google Indexing API ist 2025 der schnellste Weg zu besserer Sichtbarkeit – nutze sie!