Google Search Console: Zeilenlimit von 1.000 über API umgehen

Der Leistungsbericht in der Google Search Console hat einige Limitierungen. Eine Limitierung ist die Anzeige und der Export von max. 1.000 Zeilen:

Es gibt aber Auswege: Entweder du stellst eine Verknüpfung zu Google Analytics her und hast mehr als 1.000 Datensätze in Google Analytics. Oder du gehst über die Google Search Console API und exportierst dir die Daten selbst. Wie letzteres geht, zeige ich dir in diesem Beitrag.

Grobe Vorgehensweise

Um die Google Search Console API abzufragen, benutze ich Postman. Postman ist ein API-Tool, mit dem man APIs erstellen, testen oder auch dokumentieren kann. Wie du später sehen wirst, müssen wir bei Postman bestimmte Daten eingeben. Welche Daten benötigt werden bzw. wie wir die Google Search Console API abfragen müssen, ist in der Dokumentation der GSC-API vermerkt. Da wir dabei keine öffentlich zugänglichen Daten abfragen, brauchen wir eine Autorisierung für die Requests. Deshalb werden wir auch die notwendigen Daten für einen Zugriff über OAuth 2.0 erstellen.

Nachfolgend werde ich folgende Schritte durchführen:

  1. API-Zugriff mit OAuth 2.0 konfigurieren
  2. Wichtige Informationen aus der Google Search Console API holen
  3. Request über Postman durchführen
  4. Gelieferte Daten analysieren

API-Zugriff mit OAuth 2.0 konfigurieren

Damit wir der API später nachweisen können, dass wir autorisiert sind unsere eigenen Daten abzurufen, müssen wir zunächst OAuth 2.0 konfigurieren. Heißt: Der Zugriff auf die GSC-Daten kann nur erfolgen, wenn du auch Zugang zur Google Search Console Property hast.

Zunächst musst du zur Google Cloud Console wechseln. Erstelle dann ein neues Projekt mit Klick auf “Neues Projekt”:

Vergebe einen Projektnamen:

Danach wird dein Projekt erstellt und du musst kurz warten bis es fertig ist. Bleibe dann in deinem Projekt. Suche im Suchfeld nach “Google Search Console API” und klicke das entsprechende Ergebnis an:

Auf der API-Seite musst du nun die GSC-API aktivieren:

Hat das erfolgreich geklappt, siehst du hier die Bestätigung:

Als nächstes müssen wir einen OAuth-Zustimmungsbildschirm erstellen, damit wir auf die GSC-Daten später zugreifen können. Navigiere in der Google Cloud zu “APIs und Dienste” und dann zu “OAuth-Zustimmungsbildschirm”. Als Typ kannst du entweder “Intern” (wenn das Projekt mit einer Cloud Organisation verknüpft ist) oder “Extern” wählen. Für die meisten wird eher “Extern” in Frage kommen. Klicke dann auf “Erstellen”:

Auf der nächsten Seite musst du zunächst einen Anwendungsnamen definieren – z.B. “GSC API”. Wähle dann die Nutzersupport-Email aus der Liste aus (das wird vermutlich die E-Mail-Adresse sein, mit der du dich in die Cloud Console angemeldet hast). Weiter unten unter “Autorisierte Domains” gibst du noch “getpostman.com” ein:

Zuletzt stellst du noch eine E-Mail-Adresse zur Verfügung, über der du über Neuigkeiten von Google informiert werden möchtest (wenn es Änderungen im Projekt gibt) und bestätigst deine Eingaben. Im nächsten Schritt müssen die Bereiche definiert werden, auf die OAuth zugreifen darf. Diese festzulegenden Bereiche bzw. Scopes sind in der Google Search Console API-Dokumentation definiert:

  • https://www.googleapis.com/auth/webmasters
  • https://www.googleapis.com/auth/webmasters.readonly

Klicke also in der Cloud Konsole auf “Bereiche hinzufügen oder entfernen” und füge die 2 genannten Scopes hinzu. Um schneller hinzukommen, kannst du die Suche benutzen (hier in blau):

Sind beide Scopes ausgewählt kannst du wieder auf “Speichern und Fortfahren” klicken. Im nächsten Schritt “Testnutzer” kannst du ebenfalls einfach auf “Speichern und Fortfahren” klicken ohne was auszuwählen:

Danach ist die Erstellung des OAuth-Zustimmungsbildschirms erledigt.

Hinweis
Der Veröffentlichungsstatus ist dann zunächst auf “Test” gesetzt. Es gibt dann die Möglichkeit den Status auf “In Produktion” zu setzen. Wenn du das tust, steht die App allen Nutzern mit einem Google-Konto zur Verfügung. Daher lassen wir die App auf “Test”, da sie dann nur max. 100 Nutzern zur Verfügung steht, was aber bei der Arbeit mit der GSC API in der Regel ausreichen sollte.

Gehe anschließend zu “Anmeldedaten” (findest du in der linken Navigation im Bereich “APIs und Dienste”). Dann wähle “Anmeldedaten erstellen” und dann “OAuth-Client-ID”:

Wähle dann als Anwendungstyp “Webanwendung” und vergebe einen Namen (z.B. “getpostman”). Unter “Autorisierte Weiterleitungs-URIs” gibst du “https://oauth.pstmn.io/v1/browser-callback” ein:

Klicke dann auf “Erstellen”. Im darauffolgenden Fenster bekommst du nun die Client-ID und den Clientschlüssel, den du nun irgendwo sicher abspeichern solltest. Nun fehlt noch ein Schritt und wir können das Setup des OAuth-Zugriffs abschließen. In der linken Navigation wechseln wir wieder zu “OAuth-Zustimmungsbildschirm”. Dort sehen wir unseren vorher erstellen Zustimmungsbildschirm. Unter “Testnutzer” solltest du nun deine Google-Mail-Adresse (und die der Nutzer, die mit der API arbeiten werden) angeben:

Mit Klick auf “Add Users” gibst du die E-Mail-Adressen an und bestätigst deine Angaben.

Wichtige Informationen aus der Google Search Console API holen

Bevor wir mit der Erstellung des ersten Requests in Postman fortfahren, machen wir zunächst etwas, was man immer macht bevor man mit einer API arbeitet: Wir werfen einen Blick in die Dokumentation der API. Die Dokumentation der Search Console API ist hier zu finden: https://developers.google.com/webmaster-tools

Für uns ist vor allem die Referenz zu “query” wichtig: https://developers.google.com/webmaster-tools/search-console-api-original/v3/searchanalytics/query

Folgende Infos sind für uns daraus im nächsten Schritt relevant:

  • Der Endpoint der API lautet: https://www.googleapis.com/webmasters/v3/sites/https%3A%2F%2Fwww.example.com%2F/searchAnalytics/query
  • Als Request-Methode müssen wir POST nutzen
  • Wir müssen uns mittels OAuth 2.0 autorisieren (haben wir alles schon im vorherigen Schritt vorbereitet)
  • Im Request-Body sind die Parameter startDate und endDate Pflichtfelder. Diese spezifizieren den Datumsbereich unserer Daten-Abfrage. Weitere optionale Parameter sind in der Doku zu finden.

Mit diesen Informationen können wir nun Postman nutzen, um die API abzufragen und um mehr als 1.000 Zeilen aus dem GSC-Report zu exportieren.

Request über Postman durchführen

In diesem Schritt musst du dir zunächst Postman holen: https://www.postman.com/. Postman gibt es in unterschiedlichen Versionen – von kostenlosen Versionen für einzelne Nutzer bis hin zu kostenpflichtigen Enterprise-Lizenzen. Du kannst Postman im Browser benutzen oder aber auch als lokale App. Wie du Postman nutzt bleibt dir überlassen.

Nach der Einrichtung und dem erstmaligen Login landest du auf der Startseite. Unter “Workspace” wählst du dann “My Workspace”. Ein Workspace ist ein Arbeitsbereich und hilft euch eure Arbeit und APIs besser zu organisieren. Standardmäßig legt Postman für euch diesen ersten “My Workspace” an, den ihr später auch umbenennen könnt. Im Workspace seht ihr ganz oben das Menü. Im linken Bereich kannst du deine Arbeit organisieren (grüner Bereich im Screenshot) und im rechten Bereich (blauer Bereich im Screenshot) finden dann die eigentlichen API-Aufrufe statt:

Um nun einen neuen HTTP-Request zu erstellen klickt man entweder auf “New” und dann “HTTP Request” oder man klickt im rechten Arbeitsbereich einfach auf das Plus-Symbol:

Im beiden Fällen öffnet sich im rechten Bereich ein Request-Tab, indem nun die verschiedenen Felder für einen Request an die Google Search Console API befüllt werden können:

Einige der Felder werden wir aber nicht direkt befüllen, sondern eine wertvolle Funktion innerhalb von Postman nutzen: Variablen. Mit Variablen können wir Werte abspeichern und dann immer wiederverwenden. Zudem erhöht sich durch den Einsatz von Variablen die Sicherheit unserer HTTP-Requests, da einige sensible Informationen (wie z.B. Client-ID und Clientschlüssel) mit übergeben werden. Um Variablen zu erstellen, klicken wir zunächst im rechten oberen Bereich das Auge an:

Je nachdem wo die Variablen verfügbar sein sollen, kann zwischen “Environment” oder “Global” gewählt werden. Da wir die Variablen über alle Umgebungen hinweg verfügbar haben möchten, können wir hier unter “Global” -> “Add” wählen. Daraufhin öffnet sich in unserem Arbeitsbereich eine Tabelle, die mit unseren Variablen befüllt werden kann.

Folgende Variablen können nun angelegt werden:

  • siteUrl: Die URL der in der Google Search Console eingetragenen Domain.
  • clientId: Die erstellte Client-ID des OAuth.
  • clientKey: Der Clientschlüssel des OAuth.
  • authUrlGoogle: Diese wird auf https://accounts.google.com/o/oauth2/auth gesetzt.
  • accessTokenGoogle: Setze diese Variable auf https://accounts.google.com/o/oauth2/token.
  • scopeGsc: Hier wird der Scope mit https://www.googleapis.com/auth/webmasters.readonly gesetzt.

Die Variablennamen deklariere ich in lowerCamelCase, du kannst jedoch auch eine andere Schreibweise benutzen. Nachdem du fertig bist, solltest du nun folgende Tabelle haben:

Die Werte der Client-ID und des Clientschlüssels habe ich hier ausgegraut, da dies vertrauliche Informationen sind. Ich empfehle dir mit diesen Daten ebenfalls sehr sorgfältig umzugehen. Nachdem du alle Werte hinterlegt hast, kannst du mit Klick auf “Save” oben rechts deine Eingaben speichern. Den Tab “Globals” kannst du schließen. Nun sollte dein vorhin erstellter – noch leerer – Request zu sehen sein. Der Standardname ist zunächst “Untitled Request”. Wenn du nun rechts auf “Save” klickst:

Öffnet sich ein Fenster, wo du einen Namen für den Request vergeben kannst bevor du diesen für wiederkehrende Zwecke abspeicherst. Ist das getan, kann es endlich losgehen. Wähle zunächst als Request-Methode statt “GET” die Methode “POST”. Ins Eingabefeld gibst du folgende URL ein:

https://www.googleapis.com/webmasters/v3/sites/{{siteUrl}}/searchAnalytics/query

Hier siehst du auch schon wie man die vorhin definierten Variablen angeben kann. Als siteUrl haben wir vorhin die hinterlegte Domain in der Google Search Console abgespeichert. Wenn man die Variable nutzen möchte, so muss man diese in doppelt geschweiften Klammern setzen. Hier das vorläufige Resultat:

Dann klicken wir auf das Tab “Authorization” und wählen “OAuth 2.0”. Unter “Configure New Token” sollte “Configuration Options” ausgewählt sein:

Im Bereich “Configuration Options” befüllen wir nun die Felder:

  • Token Name: Wähle einen beliebigen Namen.
  • Grant Type: Setze diesen auf “Authorization Code”.
  • Callback URL: Belasse es so wie es von Postman vorgegeben ist, also https://oauth.pstmn.io/v1/browser-callback
  • Auth URL: Setze hier die vorhin erstellte Variable {{authUrlGoogle}}
  • Access Token URL: Setze hier die vorhin erstellte Variable {{accessTokenGoogle}}
  • Client ID: Setze hier die vorhin erstellte Variable {{clientId}}
  • Client Secret: Setze hier die vorhin erstellte Variable {{clientKey}}
  • Scope: Setze hier die vorhin erstellte Variable {{scopeGsc}}
  • State: Leer lassen.
  • Client Authentication: Auf “Send as Basic Auth header” setzen.

So sollte es fertig aussehen:

Klicke im Anschluss auf “Get New Access Token”. Danach öffnet sich ein Google-Anmeldefenster. Dies ist unser vorhin erstellter OAuth-Zustimmungsbildschirm. Melde dich hier an. War alles erfolgreich bekommst du zunächst folgendes Fenster angezeigt:

Dann folgt folgendes Fenster, wo du auf “Use Token” klicken solltest:

Das Access Token wird dann automatisch als Header Prefix gesetzt. Bevor wir nun den Request anstoßen sollten wir noch 2 Pflichtfelder im Header mitgeben: startDate und endDate. Rufe dazu das Tab “Body” auf und wähle dann “Raw”:

Ins weiße Feld fügen wir nun unseren Body für den Request hinzu:

{
"startDate": "2021-01-01",
"endDate": "2021-12-01"
}

Man definiert damit, welchen Daten-Datumsbereich man wählen möchte. Das Datum wird im Format YYYY-MM-DD mitgegeben. Das Ganze sieht folgendermaßen aus:

Anschließend klicken wir auf “Send ” und erhalten unten nun die Antwort der Google Search Console API:

Man sieht nun wie viele Klicks und Impressionen wir im gewählten Zeitraum für die definierte Domain hatten. Dieser Request sollte uns jedoch nur als Test dienen. Um unser initiales Ziel zu erreichen (mehr als 1.000 Zeilen exportieren), müssen wir unsere Daten im Body anpassen:

{
"startDate": "2021-01-01",
"endDate": "2021-12-01",
"dimensions": ["query","page", "device"],
"type": "web",
"rowLimit": "20000",
"aggregationType": "byPage"
}

Neben dem Zeitraum geben wir noch einige Daten-Dimensionen mit (Suchbegriff, Seite und Gerät), als Daten-Typ wollen wir “Web” (was aber auch der Standard-Wert wäre, wenn wir keinen Typ mitgeben), als Zeilenlimit geben wir 20.000 mit und aggregieren die Daten auf Basis der URLs. Als Antwort bekommen wir nun ein langes JSON, welches wir nun mit Klick auf “Save Response” als Datei speichern können.

Gelieferte Daten analysieren

Diese Daten können nun in Excel importiert werden, um sie näher zu analysieren. Wie man sehen kann stehen uns nun deutlich mehr als 1.000 Zeilen zur Verfügung:

Keine Kommentare möglich.