• ✓ individuelle SEO-Beratung & -Betreuung
  • ✓ keine Abnahmeverpflichtung
  • ✓ zertifizierte SEO-Experten
  • ✓ transparente & faire Arbeitsweise
  • ✓ nachhaltige SEO-Strategien
Google Search Console & R: Nicht relevante Crawling-Fehler automatisch beheben & löschen

Google Search Console & R: Nicht relevante Crawling-Fehler automatisch beheben & löschen

Inhaltsverzeichnis
Bei get:traction gehen wir üblicherweise so vor, dass wir bei Neukunden erst einmal einen Blick in die Google Search Console (GSC) werfen, um uns bspw. einen Überblick über die dort aufgeführten Crawling-Fehler zu verschaffen. Insbesondere die 404-Fehler („Nicht gefunden“) sind hinsichtlich der Nutzer besonders unerfreulich, da sie keine gute User Experience bieten. Notfalls kann der Nutzer über eine gut gemachte 404-Seite auf der Website gehalten werden – dies sollte jedoch nicht die Regel sein. Daher ist es wichtig, für nicht mehr vorhandene Seiten Weiterleitungen zur neuen URL oder zu ähnlichen Inhalten zu definieren. Hört sich erst einmal einfach an, kann aber sehr schnell in Sisyphos-Arbeit ausarten. Je nach Größe und Art der Kunden-Website können schnell mehrere Tausend URLs als „Nicht gefunden“ gelistet werden.

Die Problemstellung mit den GSC-404-Crawlingfehlern

GSC Crawlingfehler Hier beginnt das Problem allein schon bei der Datenerhebung, denn über die GSC werden nur 1.000 URLs je Property angezeigt und zum Export bereitgestellt. Zusätzlich enthält der Export über das GSC-Dashboard nicht die linkgebenden Seiten der vermeintlichen 404-Fehler. Aber auch schon bei einigen Hundert bemängelten URLs kann der zeitliche Aufwand erheblich sein, denn im Grunde muss jede URL einzeln angefasst werden. Nicht jede gelistete URL muss zwangsläufig weitergeleitet werden. So kann die Übersicht URLs enthalten, die mittlerweile wieder mit 200 OK antworten oder bereits weitergeleitet werden. Oder es werden URLs gelistet, die gar nicht mehr verlinkt werden – weder intern noch von anderen Websites. Bei Ersterem wird dem Nutzer wieder die Seite oder eine ähnliche Seite angezeigt. Bei Letzterem gelangt der Nutzer gar nicht mehr auf diese Seite. Nur solche URLs, die den HTTP-Statuscode 404 erzeugen und verlinkt sind, sind für mich also von besonderem Interesse. Allein für diese möchte ich herausfinden, warum die Seite nicht gefunden wird und ggf. Weiterleitungen definieren oder interne Links abbauen. Bis ich aber an diese URLs herankomme, muss viel stupide Fleißarbeit geleistet werden.
  • Workflow 404 Crawlingfehler Google Search Console GSC(1) Eine URL auswählen und überprüfen, ob sie noch mit 404 antwortet.
  • Wenn ja, (2) lasse ich mir die verlinkenden Seiten anzeigen und
  • rufe diese (3) einzeln auf, um zu überprüfen, ob hier der Link noch vorhanden ist.
Bei 100 nicht gefundenen URLs und bis zu 10 verlinkenden URLs sind das dann schon 1.100 URLs, die ich betrachten muss, bis ich mit der richtigen Arbeit beginnen kann. Da wäre es natürlich toll, wenn mir zumindest die Fleißarbeit irgendwie abgenommen werden könnte.

GSC-Crawlingfehler (404) automatisiert bewerten

Glücklicherweise lassen sich die meisten Aufgaben, die man mit „stupide“ und „Fleißarbeit“ beschreiben kann, automatisieren. R to the rescue! R ist eine statistische Programmiersprache, die wir bei get:traction unter anderem für die Analyse von Crawls und Logfiles sowie die Auswertung von Google Analytics-Daten verwenden. In Kombination mit der searchConsoleR-Library von Mark Edmondson lässt sich ein Programm schreiben, dass uns die zuvor beschriebene Arbeit abnimmt. Über die Library können die Crawling-Fehler über die GSC-API abgefragt und als behoben markiert werden. Das Programm soll hier nicht im Detail beschrieben (der Code findet sich hier auf GitHub), sondern der Ablauf kurz skizziert werden. Ablauf automatisierte GSC 404 Crawlingfehler Bewertung
  1. Beim ersten Ausführen muss dem Skript der Zugriff auf das jeweilige GSC-Konto eingeräumt werden. Die Authentifizierung erfolgt aktuell noch über den Browser, soll aber zukünftig über einen Google Service-Account erfolgen, damit das lästige Hantieren mit den OAuth-Dateien entfällt.
  2. Ist der Account verifiziert, lädt das Skript alle verifizierten Properties herunter, von der eine ausgewählt werden kann.
  3. Für diese Property werden dann alle URLs heruntergeladen, die als „not found“ bemängelt werden. Dies erfolgt sowohl für die Plattform Web als auch Smartphone.
  4. Im Anschluss beginnt der erste Teil der „Fleißarbeit“. Für alle not-found-URLs wird der Statuscode erhoben, um zu überprüfen, ob sie immer noch mit 404 antworten. URLs, die mittlerweile wieder mit 200 OK oder 301 Redirect antworten, werden in eine separate Tabelle geschrieben, um sie später über die API als behoben zu markieren. Wir erinnern uns: Ist die URL wieder erreichbar oder wird weitergeleitet, brauche ich natürlich keine Weiterleitung definieren. Sie ist für mich also nicht von Interesse und kann als behoben markiert werden. Die restlichen URLs, die weiterhin mit 404 antworten, werden weiterverarbeitet.
  5. Für diese URLs werden nun alle verlinkenden URLs ebenfalls auf ihren Statuscode überprüft. Ist der Statuscode bei einer verlinkenden URL 4xx, wird die verlinkte URL in die zuvor genannte Tabelle geschrieben, um sie als behoben zu markieren. Hier greift also die Prämisse, dass URLs, die zwar mit 404 antworten, aber nicht mehr verlinkt werden, aussortiert werden sollen, da der Nutzer sie sowieso nicht aufrufen kann. Folglich brauchen auch keine Weiterleitungen definiert werden. Alle bemängelten URLs, deren verlinkenden URLs jedoch mit 200 OK antworten, werden weiterverarbeitet.
  6. Bisher wurde von den (vermeintlich) Link-gebenden URLs nur der Statuscode ermittelt. In diesem Schritt wird nun auch der HTML-Quellcode der jeweiligen Seite heruntergeladen, um zu gucken, ob die bemängelte URL weiterhin verlinkt wird. Findet sich der Link nicht mehr im Quellcode, werden auch diese URLs in die Tabelle geschrieben, um sie in der GSC als behoben zu markieren.
  7. Zum Schluss liegen damit zwei Tabellen vor: 1) Eine Tabelle mit den „echten“ Crawling-Fehlern, also solche URLs, die immer noch mit 404 antworten und verlinkt werden. Sie werden als CSV exportiert, um sie händisch prüfen zu können. 2) Eine Tabelle mit den URLs, die über die API als behoben markiert werden können, weil die URLs wieder mit 200 antworten, weitergeleitet werden oder nicht mehr verlinkt werden.

Fazit: Google Crawlingfehler schnell automatisiert bewerten und bearbeiten

Mit ein bisschen R-Magie können wir uns das Leben deutlich einfacher machen. Auf Knopfdruck bereinigen wir die GSC-Auflistung, sodass nur noch die Fehler angezeigt werden, die wirklich relevant sind und unserer Aufmerksamkeit bedürfen. Auch das Problem großer Websites mit (hundert-)tausenden von Crawling-Fehlern lässt sich damit begegnen. Wird das Skript ausgeführt, wird mit Sicherheit ein Großteil der 1.000 URLs als behoben markiert. Dadurch können neue URLs nachrücken, die wir dann durch ein erneutes Ausführen des Skripts weiter reduzieren, und so weiter. Gerade bei der initialen Auswertung eines neuen Kundenaccounts befreien wir uns dadurch von unnötigem Ballast und können uns schnell auf das Wesentliche konzentrieren. Aber auch im laufenden Betrieb — bspw. wöchentlich — hilft die Automatisierung dabei, Ordnung zu halten. Hier noch einmal der Link auf das GitHub-Repro.

[Update: 16.10.2017] Anleitung

Erst einmal vielen Dank für das rege Interesse an meinem Skript. Gerne reiche ich natürlich eine kurze Anleitung nach, wie es überhaupt ausgeführt wird.

Installation von R und RStudio

Unter folgedem Link kann R heruntergeladen werden: https://cran.rstudio.com/index.html. Wählt das für Euch passende OS aus; im Nachfolgenden werde ich die Installation für Windows beschreiben. Installation für Windows Am besten verwendet Ihr die base -Variante. base-Variante Ladet die R-3.4.2-win.exe herunter und führt sie aus. R.-3.4.2-win.exe herunterladen Nachdem Ihr dem Installationsdialog gefolgt seid, ist R im Verzeichnis C:\Program Files\R (oder dem von Euch gewählten Verzeichnis) installiert. Aktuell kann R jedoch nur auf der Kommandozeile ausgeführt werden. Deutlich mehr Komfort bietet daher eine IDE wie RStudio, die unter folgendem Link kostenlos heruntergeladen werden kann: https://www.rstudio.com/products/rstudio/download/#download. Auch hier ladet ihr euch den passenden Installer (RStudio-1.1.383.exe) herunter, führt ihn aus und folgt dem Installationsdialog. Installationsdialog im Installer ausführen Danach findet sich im Verzeichnis C:\Program Files\RStudio\ die RStudio-Installation und im Unterverzeichnis /bin die rstudio.exe zum Starten den Programms.

RStudio öffnen, ein neues Projekt anlegen und das Skript importieren

Nachdem Ihr RStudio gestartet habt, kurz noch einige Anmerkungen zum Aufbau von RStudio. Aufbau von RStudio Direkt vorweg: Bei mir sieht die GUI etwas anders aus, als bei einer Erstinstallation, da ich sie meinen Bedürfnissen entsprechend angepasst habe. So sind meine Panels (mehr dazu gleich) anders angeordnet und ich verwende ein schwarzes Theme. An der grundlegenden Funktionalität ändert das natürlich nichts. RStudio ist in vier Panels aufgeteilt, die verschiedene Aufgaben übernehmen:
  1. Der Filemanager listet alle Dateien des aktuellen Projekts (auf Projekte komme ich gleich zu sprechen) oder wenn kein Projekt ausgewählt ist, die Ordner der einzelnen Projekte.
  2. Der Editor dient dazu, Skripte zu schreiben und zu speichern.
  3. Das Enviroment-Tab listet alle Variablen eines Projekts und ermöglicht es so, sich die Daten genauer anzusehen.
  4. Die Console dient zum Ausführen von Skripten.
Als Erstes legen wir ein neues Projekt an, in dem wir das Skript speichern können. Dazu wählt Ihr in der Navigationsleiste File → New Project… → New Directory → New Project. Vergebt einen Projektnamen wie bspw. gsc_crawling_erros und wählt als Speicherort ein Verzeichnis aus. Ich speichere meine Projekte standardmäßig in der Dropbox, sodass ich E:/Dropbox/Rstudio als Verzeichnis angeben, in dem RStudio dann einen Ordner gsc_crawling_errors erzeugt. Habt Ihr das Projekt erstellt, wechselt RStudio automatisch in das Verzeichnis, dass zunächst nur die Projektdatei gsc_crawling_errors.Rproj enthält. Anschließend erzeugt ihr ein neus R-Skript. Drückt dazu STRG + SHIFT + N oder geht über die Navigationsleiste wie im Screenshot zu sehen. R-Script erzeugen Es öffnet sich das Editor-Panel mit dem neuen Skript, das aktuell natürlich leer ist. Drückt als erstes STRG + S, um das Skript zu speichern und vergebt einen Dateibennenung wie bspw. gsc_crawling_errors.R. Als Nächstes kopiert ihr das R-Skript von GitHub und fügt es in die gerade erstellte, leere Datei in RStudio ein. Euer RStudio sollte dann in etwa wie folgt aussehen. RStudio nachdem ihr das R-Skript von GitHub eingefügt habt

Installation der benötigten Packages

Am Anfang des Skripts seht ihr einige Libraries, die ich importiere, um sie im Skript zu verwenden. Da Ihr R resp. RStudio komplett neu installiert habt, müsst ihr diese zunächst herunterladen. Führt dazu in der Konsole (bei mir rechts unten im Bild) folgenden Befehl aus:
install.packages(c("searchConsoleR",
	"googleAuthR",
	"tidyverse",
	"urltools",
	"stringr",
	"rvest",
	"httr"))

Variablen definieren

Als Nächstes müsst ihr einige Variablen im Skript anpassen. Das macht Ihr an folgender Stelle:
# Setup -------------------------------------------------------------------
# Die Variable auf FALSE setzen, wenn bereits eine Authentifizierung durchgeführt und eine .httr-oauth-Datei gespeichert wurde.
# Zur Verfikation eines anderen Google-Accounts die httr.oauth-Datei löschen und Variable wieder auf TRUE setzen
new_auth <- TRUE
# Hier den Pfad für den CSV-Export eintragen, in den die zu überpüfenden URLs geschrieben werden
path_to_csv_export <- "C:/Pfad/zur/export.csv"
# Hier die Goolge API Client ID eintragen
client_id <- "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX.apps.googleusercontent.com"
# Hier den Google API Clientschlüssel eintragen
client_secret <- "XXXXXXXXXXXXXXXXXXXXXXX"
  • Die Variable new_auth belasst Ihr zunächst auf TRUE. Sie dient dazu die initiale Authentifizierung durchzuführen (dazu nachher mehr).
  • Die Variable path_to_csv_export ändert Ihr zu einem beliebigen Pfad mit Dateiangabe. Dort wird das Skript die 404-Fehler als CSV speichern, die ihr euch genauer angucken müsst, da sie vom Skript als „echte“ 404er ermittelt wurden. Ich möchte die Datei bspw. auf meinem Desktop speichern, also trage ich ein: C:/Users/Patrick/Desktop/404_export.csv. (Hinweis: Nicht wundern, Pfadangaben in R/Rstudio müssen unter Windows nicht mit einem Backslash angegeben werden.)
  • Die client_id und client_secret müsst Ihr wahrscheinlich erst einmal erzeugen. Das machen wir jetzt.

Google API Client-ID erzeugen und Google Search Console API aktivieren

Ruft dazu folgende URL auf und meldet euch mit eurem Google-Account an : https://console.developers.google.com/apis/credentials. Navigiert zu Credentials → Create credentials → OAuth client ID. Google API Client-ID erzeugen und Google Search Console API aktivieren Ihr erhaltet den Hinweis, dass Ihr zunächst einen Consent Screen konfigurieren müsst. Diese Einwilligung wird euch nachher angezeigt, wenn Ihr Euch mit dem Skript authentifizieren wollt. Klick also auf: Configure consent screen. Credentials Es reicht aus, wenn Ihr den Product name ausfüllt und dann auf Save klickt. Danach gelangt Ihr wieder auf den Auswahl-Screen für den Application type. Wählt hier Other, vergebt einen Namen und drückt auf Create. Namen vergeben In einem Fenster werden Euch dann Eure Zugangsdaten angezeigt, die Ihr entsprechend in die Variablen des Skripts eintragt. Variablen des Scripts eintragen Zu guter Letzt müsst Ihr die Search Console API an sich noch aktivieren. Wechselt dazu links in der Navigation auf Library und sucht nach Google Search Console API, wählt sie aus und aktiviert sie. Google Search Console API aktivieren Hinweis: Die Aktivierung kann einige Minuten dauern. In der Zwischenzeit führe ich Euch weiter durchs Skript.

Das Skript ausführen

Bisher haben wir nur Werte ins Skript eingetragen, aber noch nichts ausgeführt. Um einzelne Zeilen oder Abschnitte eines Skripts auszuführen, können diese mit der Maus markiert und mittels STRG + ENTER ausgeführt werden. Als erstes führt Ihr die Zeilen 1 bis 65 aus; also bis zum und inklusive folgenden Skript-Abschnitt, der für die Authentifizierung zuständig ist.
# Authentifizierung --------------------------------------------------------
options(googleAuthR.client_id = client_id,
				googleAuthR.client_secret = client_secret,
				googleAuthR.httr_oauth_cache = TRUE,
				googleAuthR.scopes.selected = "https://www.googleapis.com/auth/webmasters")
if (new_auth) {
	file.remove(".httr-oauth")
	gar_auth()
} else {
	Sys.setenv(GAR_AUTH_FILE = ".httr-oauth")
	gar_auto_auth(required_scopes = "https://www.googleapis.com/auth/webmasters")
}
Wird dieser Abschnitt ausgeführt, öffent sich Euer Browser und Ihr müsst die Authentifizierung mit dem Google-Account zulassen, für den Ihr die GSC-Fehler abfragen wollt (Sagt „Hallo“ zu eurem vorher erstellten Consent Screen). SEO Monitoring: Zulassen anklicken Habt Ihr auf Zulassen geklickt, seht Ihr im Filemanager von RStudio, dass eine .httr-oauth-Datei erzeugt wurde. Damit Ihr euch nicht jedes Mal neu authentifizieren müsst, setzt die Variable new_auth am Anfang des Skripts jetzt auf FALSE. Zukünftig wird das Skript die Datei dann verwenden, um sich gegenüber der API zu authentifizieren. Wollt Ihr einen anderen Google-Account authentifizieren, setzt die Variable wieder auf TRUE und führt die Schritte bis hierher erneut aus. Als Nächstes führt Ihr dann folgende Zeile aus:
# Auswahl der Property ---------------------------------------------------------
# Die Funktion gibt alle Properties des Google-Accounts in einem DataFrame zurück.
properties <- list_websites()
Dadurch erhaltet Ihr alle Properties, die für den Google-Account freigegeben sind. Klickt Ihr im Enviroment-Panel auf die Variable properties, werden sie Euch in tabellarischer Form angezeigt. Variable properties in tabellarischer Form Wählt eine der Properties aus und tragt sie in die nachfolgende Variable property ein. Wie bereits oben erwähnt, kann die Aktivierung der GSC-API einige Minuten dauern. Wenn Ihr also zu schnell gelesen habt und folgende Fehlermeldung seht, macht genau das, was dort steht und holt euch erst einmal einen ☕. Nach ca. 5 Minuten, sollte die Aktivierung erfolgt sein. Fehlermeldung Das war’s erst einmal an manuellen Einstellungen. Führt jetzt die restlichen Zeilen des Skripts aus.

Einige (nerdige) Anmerkungen

Direkt vorweg ein Disclaimer: Wer schon einmal Websites gescrapt oder auch nur URLs automatisiert abgefragt hat, weiß, dass jedes Skript früher oder später knallt, weil nicht alle Eventualitäten im Vorfeld bedacht werden können … oder weil Google wieder mal an seiner API herumbastelt oder was auch immer. Ich prognostiziere also schon einmal, dass das Skript früher oder später nicht mehr in der gewünschten Form funktionieren wird. Da wir es aber bei get:traction selbst verwenden, werde ich es entsprechend aktualisieren und den neuen Code auf GitHub einstellen.

User-Agent

# User-Agent definieren ----------------------------------------------------------
set_config(user_agent("Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html"))
Über diese Konfiguration könnt Ihr einen anderen User-Agent definieren. Standardmäßig verwendet das httr-Package keinen User-Agent, was einige Websites nicht mögen und dann keinen Inhalt zurückgeben.

Error-Handling

Es kann immer mal wieder vorkommen, dass URLs nicht wie erwartet antworten (ノಠ益ಠ)ノ彡┻━┻ s. Disclaimer). Damit das Skript nicht abbricht, fange ich solche Errors mit einem simplen tryCatch, der dann einfach ein NA zurückgibt, die URL also „hinten runter fallen lässt“. In der Console wird aber zumindest die URL ausgegeben, bei der das Problem aufgetreten ist.

URLs als behoben markieren

Aktuell kommt es immer wieder zu folgender Fehlermeldung, wenn URLs als behoben markiert werden sollen:
> fix_sample_url("podcast/beyond-pageviews-podcast/bp-2-3-warum-google-tag-manager/%20%E2%80%8E",siteURL = property,platform = "web",category = "notFound")
Request Status Code: 404
Error : lexical error: invalid char in json text.
                                       Not Found
                     (right here) ------^
In addition: There were 21 warnings (use warnings() to see them)
Error: lexical error: invalid char in json text.
                                       Not Found
                     (right here) ------^
In addition: Warning message:
No JSON content found in request
Ursache dafür ist, dass die Funktion fix_sample_url() nicht mit URL-encodierten Zeichen (bspw. wie in folgender URL: podcast/beyond-pageviews-podcast/bp-2-3-warum-google-tag-manager/%20%E2%80%8E) umgehen kann. An einem Fix arbeite ich. Außerdem kann es vorkommen, dass URLs nicht direkt aus der GSC verschwinden, wenn Ihr sie als behoben markiert habt. Um zu testen, ob der API-Call überhaupt funktionert, könnt Ihr ihn mit der Funktion fix_sample_url() testen. Tragt dazu eine URL aus der GSC ein. Wenn die Funktion mit TRUE antwortet, hat das Senden an die API auf jeden Fall funktioniert. Sollte das nicht geklappt haben, kann es sein, dass Ihr nur einen lesenden Zugriff auf die Property habt.

Fin?

Wie Ihr seht, gibt es an dem Skript noch einiges zu tun. Denn wie Tolstoi schon so schön gesagt hat: — Alle glücklichen URLs antworten gleich, jede unglückliche URL antwortet auf ihre eigene Weise unglücklich. Für Anregungen und Probleme, über die Ihr gestolpert seid, oder sogar Verbesserungsvorschläge bin ich daher immer offen. Bis dahin: Happy R! 👋 Hier noch einmal der Link auf das GitHub-Repro.
get:traction Partner Patrick Lürwer

Patrick Lürwer

Senior-Analyst & Partner

In meinem Studium des Bibliotheksmanagements habe ich mich von Anfang an mehr für die Metadaten als für die Bücher interessiert. Meine Leidenschaft für Daten — das Erfassen, Aufbereiten und Analysieren — habe ich anschließend durch mein Master-Studium der Informationswissenschaft weiter ausleben und vertiefen können. Bei get:traction kombiniere ich meine Data-Hacking-Skills und meine Online-Marketing-Expertise, um datengestützte Empfehlungen für Kunden zu formulieren und umgesetzte Maßnahmen zu messen. Mein Hauptaufgabenbereich liegt dabei in der Analyse von Crawls, Logfiles und Tracking-Daten, der Konzeption von Informationsarchitekturen und der Anreicherung von Webinhalten mittels semantischer Auszeichnungen.

4.7/5 - (35 votes)

29 Kommentare:

Großartiger Artikel. Vielen Dank dafür!
Leider habe ich noch nie mit R gearbeitet. Muss ich mir mal anschauen, aber ansonsten Bau ich mir das mit JS nach.

Patrick Lürwersagt:

Servus Jimie-Dean,
vielen Dank, freut mich, dass dir der Beitrag gefallen hat.
Viele Wege führen ja bekanntlich nach Rom, von daher sollte einer Umsetzung mit JS nichts im Wege stehen.
Viel Spaß auf jeden Fall beim Coden. 🙂

Rolandsagt:

Hi, danke für den hilfreichen Artikel!
Nur, was genau muss getan werden, um das Programm nutzen zu können?
Hier wäre ebenfalls eine Schrift-für-Schritt Anleitung cool.
Danke und Grüße
Roland

Patrick Lürwersagt:

Servus Roland,
ich habe den Beitrag jetzt mal ein „bisschen“ ergänzt. Ich hoffe, dass jetzt einiges klarer wird. 😀 Ansonsten immer her mit deinen Fragen. 🙂

Hi Patrick,
vielen Dank für das Script. Nachdem ich mich gestern authentifizieren konnte, bemerkte ich beim Ausführen, dass zwar eine Excel Datei generiert wird, die Fehler aber nicht als erledigt markiert werden. Ich dachte deshalb es wäre ggf. eine gute Idee die Authentifizierung neu anzustoßen. Keine gute Idee. Denn jetzt erscheint ein 401 oauth client was not found Fehler. Was tun?
VG
Sebastian

Patrick Lürwersagt:

Servus Sesi,
der Fehler ist mir leider noch nicht untergekommen. Grundsätzlich sollte aber eine erneute Authentifizierung kein Problem sein. Lösch am besten erst einmal die oauth-Datei manuell, setzt die Variable new_auth wieder auf TRUE und versuch es dann noch einmal. Sollte es immer noch nicht klappen, musst du eventuell die GSC-API im Google API Explorer noch mal deaktivieren und erneut aktivieren („Hello. IT. Have you tried turning it off and on again?“).
Falls das auch nicht klappt, schreib mich noch mal auf Twitter an, da lässt es sich leichter schreiben. 🙂
Viele Grüße

Hi Patrick,
super Anleitung. Musste jetzt ein wenig rumprobieren, aber jetzt dachte ich, ich wäre am Ziel.
Doch jetzt kommt folgende Fehlermeldung:

> mark_as_fixed_list %>%
+   pmap(safely(fix_sample_url))
Request Status Code: 404
Error : lexical error: invalid char in json text.
                                       Not Found
                     (right here) ------^
In addition: Warning message:
In checkGoogleAPIError(req) : No JSON content detected
[[1]]
[[1]]$result
[1] TRUE

Da kein JSON content detected (es sind über 700 URL – nicht gefunden) wird, bleibt auch die errors Tabelle leer.
Kennst du die Fehlermeldung und hast du eine Idee, was ich noch falsch mache?
Ansonsten super Sache, wenns funzt und genau zum richtigen Zeitraum 😉
Wird es weitere R Auswertungs – GSC Beiträge geben?
Beste Grüße
Christian

Patrick Lürwersagt:

Servus Christian,
freut mich, dass dir der Beitrag gefallen hat. 🙂 Ich bin gerade dabei, den Post um einige Aspekte zu ergänzen. Unter anderem auch um den Fehler, dem du gerade begegnet bist.
Ich vermute, dass die URL, die du als behoben markieren willst, URL-encodierte Zeichen enthält. Ich habe bspw. folgende URL, für die ich die gleiche Fehlermeldung bekomme: podcast/beyond-pageviews-podcast/bp-2-3-warum-google-tag-manager/%20%E2%80%8E
Aktuell arbeite ich an einem Fix, um solche Fehler zu fangen. Der hat es jedoch noch nicht auf GitHub geschafft.

Mit Sicherheit wird es noch weitere R-GSC-Skripte geben. Als nächstes steht aber erst einmal ein Skript auf der Agenda, mit dem sich Screamingfrog-Crawls abgleichen lassen.
Viele Grüße
Patrick

Hi Patrick,
danke für die Info und ich freue mich auf den Abgleich mit Screamingfrog.
Ich habe jetzt die URL`s mit „%“ manuell als korrigiert markiert. Dann gab es keine Fehlermeldung, aber noch keine URLs in die csv geschrieben.
Also habe ich manuell noch die Soft – 404 und Sonstiges bei Desktop sowie Smartphone nicht gefunden und blockiert manuell korrigiert.
Jetzt kommt folgende Fehlermeldung:

No error samples available.
Error in UseMethod("select_") :
  no applicable method for 'select_' applied to an object of class "NULL"
In addition: Warning messages:
1: Unknown or uninitialised column: 'linked_from_url'.
2: Unknown or uninitialised column: 'url_not_found'.
3: Unknown or uninitialised column: 'linked_from_url'.
4: In lces(path_arguments = list(sites = siteURL), pars_arguments = params) :
  API Data failed to parse.  Returning parsed from JSON content.
                    Use this to test against your data_parse_function.

Was heißt das? Bin ich zu blöd?
Beste Grüße
Christian

Patrick Lürwersagt:

Servus Christian,
die Soft-404, Server-Fehler etc. werden vom Skript nicht berücksichtigt, da sie sich nicht so leicht überprüfen lassen. Nur die „notFound“ werden überprüft.
Deine Fehlermeldung resultiert daraus, dass die angefragte Property keine notFound-Fehler aufweist (No error samples available.). Da keine Daten vorhanden sind, kann das select_ etc. nicht ausgeführt werden und die Funktion bricht ab.
Um manuell zu überprüfen, ob die GSC-API für eine bestimmte Property und Plattform Fehler zurückgibt, kannst du folgende Funktion verwenden: list_crawl_error_samples("https://www.gettraction.de/",category = "notFound", platform = "web").
LG
Patrick

Dennissagt:

Hallo,
Vielen Dank für den Artikel. Das hilft mir in der täglichen Arbeit wirklich sehr.

Patrick Lürwersagt:

Servus Dennis,
freut mich zu hören. 🙂

Stefansagt:

Hallo Patrick,
sehr guter Artikel. Da ich kein Entwickler bin, freue ich mich immer über step-by-step Anleitungen. Leider bekomme ich nach dem Ausführen der Skriptzeilen 1 bis 65 nur die folgende Fehlermeldung und kein Browserfenster, in dem ich die Authentifizierung übers Google-Konto zulassen soll.

Error: option('googleAuthR.httr_oauth_cache') must be set to
         valid cache file location,
         not TRUE or FALSE - (example: '.httr-oauth')
In addition: Warning message:
In file.remove(".httr-oauth") :
  cannot remove file '.httr-oauth', reason 'No such file or directory'

Hast du eine Idee dazu?

Patrick Lürwersagt:

Hallo Stefan,
freut mich, dass dir dir Anleitung geholfen hat, auch wenn sie in einem Fehler endet. 😀
Da habe ich leider etwas übersehen. Das Skript versucht die oauth-Datei zu löschen, die es bei dir natürlich noch gar nicht geben kann. Danke für den Hinweis. 🙂
Ich habe das Skript auf GitHub aktualisiert.
Viele Grüße

Vielen Dank für die Anleitung. Bei mir erscheint nach Ausführen der Zeilen 1-65 die folgende Fehlermeldung, der Auth-Browserfenster öffnet sich erst gar nicht:

Error: option('googleAuthR.httr_oauth_cache') must be set to
         valid cache file location,
         not TRUE or FALSE - (example: '.httr-oauth')
In addition: Warning message:
In file.remove(".httr-oauth") :
  cannot remove file '.httr-oauth', reason 'No such file or directory'

Hast du vielleicht eine Idee, was ich falsch gemacht habe?

Patrick Lürwersagt:

Hallo Matthias,
du hast gar nichts falsch gemacht, sondern ich. 🙂
Das Skript versucht hier die oauth-Datei zu löschen, die es bei dir noch gar nicht geben kann. Ich habe eine aktualisierte Version auf GitHub hochgeladen.
Viele Grüße

Stefansagt:

Hi Patrick,
habe vielen Dank für den schnellen Fix. Leider ist ein Teil der Fehlermeldung geblieben, nämlich:

Error: option('googleAuthR.httr_oauth_cache') must be set to
         valid cache file location,
         not TRUE or FALSE - (example: '.httr-oauth')

Hmphhh, …. Noch eine Idee dazu?

Patrick Lürwersagt:

Servus Stefan,
hast du dir das angepasste Skript noch einmal von GitHub heruntergeladen? Für mich sieht das so aus, dass im Block # authentication --- weiterhin die Option googleAuthR.httr_oauth_cache = TRUE gesetzt ist. Der gesamte Authentifizierungsblock sollte wie folgt aussehen:

# authentification --------------------------------------------------------
options(googleAuthR.client_id = "XXXXX.apps.googleusercontent.com",
        googleAuthR.client_secret = "XXXXX",
        googleAuthR.scopes.selected = "https://www.googleapis.com/auth/webmasters")
if (new_auth) {
  if(file.exists(".httr-oauth")) {
    file.remove(".httr-oauth")
  }
  gar_auth()
} else {
  Sys.setenv(GAR_AUTH_FILE = ".httr-oauth")
  gar_auto_auth(required_scopes = "https://www.googleapis.com/auth/webmasters")
}
Stefansagt:

Naja, bis auf die Tatsache, dass bei den Options jeweils die zuvor gesetzte Variable referenziert wird (also googleAuthR.client_secret = client_secret), habe ich dasselbe da stehen. Hatte mir das aktuellste Skript heruntergeladen.

Stefansagt:

Also ich habe jetzt alles noch mal deinstalliert und dann neu installiert. Jetzt läuft es! Danke dir für die Mühe.

Patrick Lürwersagt:

Perfekt. Und danke für’s Feedback geben.

Hallo Patrick,
sehr cooles Script, vielen Dank dafür.
Eine Frage:
Neben notFound bietet die GSC API noch weitere Status, bspw:
+ authPermissions
+ serverError
+ soft404
Wie können wir diese denn abarbeiten?
Innerhalb von list_crawl_error_samples haben wir ja die category.
Wechsle ich dort von notFound auf authPermissions scheint das Script sich aber einfach tot zu laufen, oder hätte ich dem einfach mehr Zeit geben sollen?
Würde mich freuen, wenn Du darauf noch eingehen könntest.
Vielen Dank und beste Grüße aus Hochfranken!
Michael

Patrick Lürwersagt:

Hallo Michael,
freut mich, dass dir das Skript hilft.
Ich muss gestehen, dass ich das Skript noch nie mit den anderen Fehlertypen getestet habe. Daher müsste ich für jeden Fehlertyp den Datenfluss noch einmal im Detail nachvollziehen, um zu gucken, ob sich die Überprüfung der notFound im Skript 1 zu 1 auf die anderen Typen übertragen lässt.
Grundsätzlich würde ich die restlichen Fehlertypen aber eh anders handhaben, da diese eher für Website-weite Fehler- / Konfigurationsmuster stehen – im Gegensatz zu den notFound, bei denen ich mir jede URL einzeln angucken sollte, ob ich sie weiterleite oder nicht. Um hier die Menge zu reduzieren, prüft das Skript die Aktualität der URLs, sodass ich mir nur noch die angucken muss, die weiterhin 404 sind und immernoch verlinkt werden. Bei den restlichen Fehlertypen kann ich mir im Grund die aktuellen Fehler nehmen und gucken, ob ich ein Muster erkennen kann, der den Fehler bedingt. Ich packe hier also weniger einzelne URLs an, sondern gehe auf Ursachensuche.
403er sind von mir aktiv gesetzt, von daher muss ich hier nur stichprobenartig anhand der URLs gucken, ob die Logik richtig ist. Bei euch resultieren bspw. fast alle 403er aus dem Mitgliederbereich. Der ist natürlich stark verlinkt, entsprechend viele 403er liegen vor, die aber per se nicht zu "reparieren" sind, denn der Bereich ist ja bewusst zugangsbeschränkt. Die Verlinkung auf die URLs zu überprüfen oder die URLs in der GSC als behoben zu markieren, bringt daher nicht viel, denn die "Fehler" werden immer wieder kommen, da das Verhalten der URLs / der Status Code ja korrekt ist.
Serverfehler sind meist keine persistenten Fehler. Je nach Last auf dem Server oder basierend auf anderen Ursachen kann immer wieder einer andere URL mit 500 antworten. Eine Überprüfung der URL an sicher / der Verlinkung ist hier also auch nicht sinnvoll, denn wahrscheinlich antwortet die verlinkte URL zum Zeitpunkt der Überprüfung eh wieder mit 200. Evtl. kann hier aber wirklich ein systemischer, wiederkehrender Fehler bei einzelnen URLs / Seitentypen vorliegen. Um solche Muster zu ermitteln macht es hier durchaus Sinn, die Fehler in der GSC regelmäßig als behoben zu markieren, um zu gucken, ob einige URLs immer wieder kommen, die entsprechend dauerhaft mit 500 antworten. Bei denen müsste man dann mal nach einem Muster suchen.
Soft404er sind meistens durch eine bestimmte Weiterleitungslogik bedingt. Kann ich hier die entsprechende Logik anpassen, beheben ich damit auch alle Fehler. Auch hier macht es Sinn, initital einfach mal alle als behoben zu markieren und dann zu gucken, was noch auftaucht.
Wenn ihr die Behebung nicht manuell machen wollt, könnt ihr folgendens Snippet verwenden – ggf. noch um Loops über die Properties, Categories und Platforms erweitern:

library(googleAuthR)
library(searchConsoleR)
library(tidyverse)
library(urltools)
options(googleAuthR.client_id = "XXX.apps.googleusercontent.com",
        googleAuthR.client_secret = "XXX",
        googleAuthR.scopes.selected = "https://www.googleapis.com/auth/webmasters",
        googleAuthR.verbose = 2)
property <- ""
category <- "soft404"
platform <- "web"
gar_auth(token = "XXXX")
lces <- list_crawl_error_samples(siteURL = property,
                                    category = category,
                                    platform = platform) %>%
  select(pageUrl) %>%
  mutate(siteUrl = property,
         platform = platform,
         category = category)
mark_as_fixed_list <- list(siteURL = lces$siteUrl,
                           pageURL = url_encode(lces$pageUrl),
                           category = lces$category,
                           platform = lces$platform)
mark_as_fixed_list %>%
  pmap(safely(fix_sample_url))

Ich hoffe, ich konnte dir etwas weiter helfen.
Viele Grüße aus Berlin
Patrick

Leck mich am Arsch,
was für eine erstklassige Antwort. 🙂
Vielen, vielen Dank für den Rundumschlag, das Script und die Zeit die Du dir für alles genommen hast.
Ich geb dir mit allen Punkten recht, allerdings liegen die Umstände bei uns was die 403/401 Meldungen angeht noch etwas anders/spezieller.
Um unser System nicht durch DDoS Attacken zu gefährden, sperren wir nach X Zugriffen von einer Quelle automatisch die Zugriffe und liefern nur noch 403 aus, gleich ob die Seite eigentlich normal erreichbar wäre, oder nicht.
Leider ist auch Google in diesen Mechanismus gerutscht und so haben wir nun >270.000 angebl. 403/401 Fehler in der GSC, welche aber zu 99% keine sind.
Trauriger weise kann ich ja immer nur 1000/Tag "abarbeiten", was mich also 270 Tage kosten würde.
Ich hatte nun gehofft, dass via Script die Fehlermeldungen global zurück gesetzt werden könnten, oder ich zumindest automatisiert immer die 1000/Tag zurücksetzen kann.
Aber das einfache zurücksetzen, sollte ja mittels deines Scripts funktionieren, oder?
Und gibts vielleicht doch noch sowas wie einen "Alles auf 0" Schalter, Script, Button, …?
Ich glaubs ja nicht, aber die Hoffnung stirbt zuletzt.
Sonnige Grüße nach Berlin,
Michael

Patrick Lürwersagt:

Servus Michael,
gerne doch. 🙂
Alle Fehler auf einmal als behoben zu markieren, geht leider nicht. Das treibt mich auch regelmäßig in den Wahnsinn, wenn ich vor lauter Fehlern den Wald nicht mehr sehen. Das war auch einer der Gründe, warum ich das Skript geschrieben habe, um zumindest jeden Tag 1.000 Fehler abzubauen.
Kurz: Den Magic-Button gibt es leider nicht, aber mit dem obigen Snippet kannst du zumindest 1.000 Fehler/Tag beheben.
Grüße aus dem gerade noch etwas bewölkten Berlin.

Hallo Patrick,
ich bräuchte deine Hilfe nochmal. 🙂
Wir hatten heute mal versucht die Ausführung des Scripts zu automatisieren, doch leider bekommen wir einen Fehler. Ich hab die oauth Datei nochmal weggeworfen und versucht mich neu zu authentifizieren.
Doch dabei scheint etwas nicht zu passen:
2018-11-06 10:09:44> No local token found in session
2018-11-06 10:09:44> Auto-refresh of token not possible, manual re-authentication required
Error: Failed to create local cache ('4/AABFsn11zAVC8qhcnKE0dF0rvFdqsFpOb5LJN-Inb34p5Po4XGRwkFI')
Die Credentials Einstellungen unter https://console.developers.google.com/apis/ passen aber und sind weiterhin korrekt.
Könnte es daher vllt. sein, dass im Zuge der neuen GSC sich auch bei der Konnektivität etwas getan hat und das Script nicht mehr so läuft wie es noch vor ein paar Monaten lief?
Ich sag schonmal vielen Dank und wünsche noch einen tollen Tag.
Sonnige Grüße in den Norden.
Michael

Patrick Lürwersagt:

Servus Michael,
ich bin gerade in Vorbereitung auf den SEO-Day etwas am rotieren, deshalb kann ich jetzt nicht genau nachgucken, woran es liegen kann. Ich habe aber eine Vermutung.
Tausch mal bitte die GSC-Authentifizierung aus. Also die Stelle:

# Authentifizierung --------------------------------------------------------
library(searchConsoleR)
library(googleAuthR)
options(googleAuthR.client_id = client_id,
				googleAuthR.client_secret = client_secret,
				googleAuthR.httr_oauth_cache = TRUE,
				googleAuthR.scopes.selected = "https://www.googleapis.com/auth/webmasters")
if (new_auth) {
	file.remove(".httr-oauth")
	gar_auth()
} else {
	Sys.setenv(GAR_AUTH_FILE = ".httr-oauth")
	gar_auto_auth(required_scopes = "https://www.googleapis.com/auth/webmasters")
}

Durch diesen Code:

library(searchConsoleR)
library(googleAuthR)
options(googleAuthR.client_id = "XXXX.apps.googleusercontent.com",
	googleAuthR.client_secret = "XXXX",
	googleAuthR.scopes.selected = "https://www.googleapis.com/auth/webmasters")
if (file.exists("sc.oauth")) {
	gar_auth(token = "sc.oauth")
} else {
	gar_auth(new_user = T)
}

Probier mal, ob das klappt. Wenn nicht, meld dich noch mal. Komme dann allerdings erst nächste Woche dazu, dir zu antworten. :/
Grüße 🙂

Hi Patrick,
nochmal vielen Dank für Deinen Vortrag und den Talk auf dem SEO Day!! ich bin mal direkt in RStudio eingetaucht, vielen Dank für Deine top Anleitung.
Gruß
Heiko

Patrick Lürwersagt:

Servus Heiko,
vielen Dank für das Lob, freut mich zu hören. 🙂
Schöne Grüße und einen guten Start in die Woche.


Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert