Ik heb voor $0 een Google Search Console-dashboard gebouwd. Hier is de code.

TL;DR: Google Search Console levert exact dezelfde gegevens over zoekopdrachten, pagina’s, posities en vertoningen die SEMrush en Ahrefs voor $129–$449/maand opnieuw verpakken. De GSC-API biedt gratis 1.200 requests per minuut, een payload-limiet van 25.000 rijen en vier endpoints die circa 90 % van wat een solo-founder nodig heeft afdekken. Dit artikel laat zien hoe je service-account-OAuth inricht, welke vier endpoints ertoe doen, een uitvoerbaar Python-script dat een query-per-pagina-CTR-matrix ophaalt, en drie automatiseringspatronen (cron + Slack, Google Sheets, een lichte Django-view) waarmee je ruwe API-rijen omzet in een bruikbaar dashboard. Wil je de integratie niet zelf onderhouden, dan regelt SEOJuice dezelfde bekabeling als managed service.

Wat GSC Gratis Biedt (en Betaalde Tools Re-verpakken)

Het frustrerende aan een SEO-suite van $449/maand is dat ongeveer 70 % van wat in het dashboard verschijnt data is die Google al gratis via Search Console verstrekt. Betaalde tools voegen drie dingen toe: externe rank-tracking via gehuurde proxies, een backlink-grafiek uit gecrawlde webarchieven, en een UI waarvoor je geen SQL hoeft te schrijven. Van die drie heeft een solo-founder eigenlijk alleen de UI nodig, en die is het goedkoopst om zelf na te bouwen.

Dit is wat de API oplevert voor elke property waarvan je eigendom hebt geverifieerd:

16 maanden historische prestatiedata: elke zoekopdracht die een klik of vertoning opleverde, met positie, CTR en datum.
Pagina-niveau-uitdraaien voor hetzelfde venster: welke URL’s rankten op welke queries en waar het klikvolume neerkwam.
Index-dekking per URL: laatste crawldatum, indexeringsstatus, door Google gekozen canonieke URL, mobiele bruikbaarheid, structured-data-parsing.
Sitemap-status: welke sitemaps Google ophaalde, wanneer, en hoeveel URL’s ontdekt vs. geïndexeerd werden.
Segmentatie op apparaat, land en zoek-weergave op dezelfde query/pagina-data.

Wat ontbreekt is alles buiten je eigen property: rankings van concurrenten, backlink-groei op rivaliserende domeinen, share-of-voice-berekeningen. Voor de meeste founders vóór PMF zijn dat ijdelheids-metrics die toch niet bepalen wat je hierna shipt. Ik schreef een langer stuk over het terugbrengen van een SEO-stack tot twee tools; conclusie bleef overeind: GSC plus één schrijfbasis geeft genoeg signaal om op te handelen.

“De data in Search Console komt rechtstreeks van Google. Het is de meest nauwkeurige bron om te begrijpen hoe je site presteert in Google-zoekresultaten.”
Uit Google’s eigen Search Console Help-documentatie.

De GSC-API Inrichten met een Service-account

Voor de GSC-API bestaan twee bruikbare auth-flows: user-flow OAuth (browser-redirect, refresh-tokens) en service-account OAuth (server-to-server, geen browser). Voor een founder die een cron op één VPS draait zijn service-accounts korter en duurzamer — geen vervallende refresh-tokens, geen consent-screen-onderhoud.

Het opzetten kost zo’n tien minuten en is gratis:

Open de Google Cloud Console en creëer een nieuw project (of hergebruik er een). De gratis laag volstaat; hier worden nooit kosten gerekend.
Schakel de Google Search Console API in via de API-bibliotheek.
Ga naar IAM & Admin → Service Accounts en maak een nieuw service-account aan met de naam gsc-dashboard-reader. Geen projectrollen nodig.
Genereer een JSON-sleutel voor dit account en download die. Behandel hem als een API-sleutel; commit hem niet.
Voeg in Search Console onder Instellingen → Gebruikers en rechten het e-mailadres van het service-account toe (eindigend op @<project-id>.iam.gserviceaccount.com). Beperkt is genoeg om te lezen.

Die laatste stap wordt vaak gemist. Het service-account is wel een Google-identiteit, maar tenzij je het expliciet toegang geeft tot je Search Console-property, retourneert de API een officieel klinkende foutmelding 403 user does not have sufficient permission for site. Verleen per property toegang; herhaal dus als je er meerdere hebt.

Diagram van de service-account-OAuth-flow: GCP-project, service-account, JSON-sleutel, Search Console-machtiging — Service-account-OAuth-flow voor GSC. Het credential-bestand authenticeert bij Google; de machtiging per property binnen Search Console autoriseert de datatoegang.

De Vier Endpoints die 90 % Afdekken

Het oppervlak van de GSC-API is klein. Vier endpoints samen dekken query-data, sitemap-status, URL-inspectie en de lijst met properties waar je toegang toe hebt. Sla de rest van de reference over totdat je een concrete reden hebt om die te lezen.

Endpoint	Wat het teruggeeft	Quotakosten	Nuttig voor
`searchanalytics.query`	Maximaal 25.000 rijen met kliks, vertoningen, positie, CTR per query, pagina, datum, apparaat, land	1 unit / request	De kern van het dashboard; welke queries verkeer sturen, welke pagina’s vertoningen omzetten in kliks
`sitemaps.list`	Alle ingediende sitemaps met status, laatste fetch-tijd, URL-aantallen	1 unit / request	Sitemap-gezondheidsalerts; signaleren van uitgevallen of deels geïndexeerde sitemaps
`urlInspection.index.inspect`	Per URL: dekkingsstatus, laatste crawl, canonieke URL, mobiele bruikbaarheid, AMP- en structured-data-oordeel	2.000 / dag (apart quota)	Steekproeven op kritieke pagina’s; geautomatiseerde index-audits
`sites.list`	Alle properties die de geauthenticeerde identiteit kan lezen	1 unit / request	Dashboards over meerdere properties; itereren over een portfolio

Het quotum van 1.200/min op read-endpoints is voor solo-gebruik feitelijk onbeperkt. De limiet van 2.000/dag op URL Inspection is de enige echte grens en dekt een dagelijkse audit van elke pagina op een site met 1.500 URL’s.

Een Echte Python-Pull: Topqueries en de Query-per-Pagina-Matrix

De meest bruikbare query is een query-per-pagina-overzicht over de afgelopen 28 dagen. Daarmee zie je welke pagina op welke zoekopdracht rankt en hoe de CTR op het snijpunt is. Cellen met veel vertoningen en lage CTR zijn je kortetermijndoelen voor optimalisatie.

Installeer twee dependencies:

pip install google-auth google-api-python-client

Het minimale script: auth, query, print. Sla je gedownloade JSON-sleutel op als gsc-credentials.json in dezelfde map:

from datetime import date, timedelta
from google.oauth2 import service_account
from googleapiclient.discovery import build

SCOPES = ["https://www.googleapis.com/auth/webmasters.readonly"]
SITE_URL = "sc-domain:example.com"  # of "https://example.com/"
KEY_FILE = "gsc-credentials.json"

creds = service_account.Credentials.from_service_account_file(
    KEY_FILE, scopes=SCOPES
)
service = build("searchconsole", "v1", credentials=creds)

end = date.today() - timedelta(days=2)  # GSC loopt ~2 dagen achter
start = end - timedelta(days=27)

request = {
    "startDate": start.isoformat(),
    "endDate": end.isoformat(),
    "dimensions": ["query"],
    "rowLimit": 25,
    "orderBy": [{"field": "clicks", "descending": True}],
}
response = service.searchanalytics().query(
    siteUrl=SITE_URL, body=request
).execute()

for row in response.get("rows", []):
    q = row["keys"][0]
    print(f"{row['clicks']:>5}  {row['impressions']:>6}  "
          f"{row['ctr']*100:>5.1f}%  pos={row['position']:>5.1f}  {q}")

Dat is de hele integratie. Draai het en je ziet de 25 belangrijkste queries van de laatste 28 dagen, gesorteerd op kliks. Twee opmerkingen: sc-domain:example.com is voor domein-properties (aanbevolen type); gebruik de volledige URL-vorm alleen voor URL-prefix-properties. GSC-data loopt ongeveer twee dagen achter, daarom eindigen we op today - 2.

De query-per-pagina-matrix — de versie die echt beslissingen stuurt — voegt een tweede dimensie toe en verhoogt de rijenlimiet:

request = {
    "startDate": start.isoformat(),
    "endDate": end.isoformat(),
    "dimensions": ["query", "page"],
    "rowLimit": 5000,
    "orderBy": [{"field": "impressions", "descending": True}],
}
response = service.searchanalytics().query(
    siteUrl=SITE_URL, body=request
).execute()

opportunities = []
for row in response.get("rows", []):
    query, page = row["keys"]
    impressions = row["impressions"]
    ctr = row["ctr"]
    position = row["position"]
    # Cellen met >500 vertoningen en CTR <2 % zijn kandidaten met CTR-lekkage
    if impressions > 500 and ctr < 0.02 and position < 15:
        opportunities.append((impressions, query, page, position, ctr))

opportunities.sort(reverse=True)
for imp, q, p, pos, ctr in opportunities[:20]:
    print(f"{imp:>6} imp  pos={pos:>4.1f}  ctr={ctr*100:>4.1f}%  {q}  →  {p}")

Het filter onderaan (hoge vertoningen, lage CTR, positie top-15) is de klassieke lijst voor het herschrijven van title-tags. Je rankt al; de doorklik is het lek. Dit is dezelfde logica die betaalde tools presenteren als “ranking opportunities”, geschreven in zes regels.

Voorbeeldoutput van de query-per-pagina-matrix met vertoningen, CTR, positie, query en doel-URL-kolommen — Output van de query-per-pagina-matrix. Elke rij is een query × URL-kruising. Rijen met veel vertoningen en lage CTR zijn kandidaten om de titel te herschrijven.

Wat te Visualiseren: de Vier Grafieken die de Moeite Waard Zijn

Heb je eenmaal de rijen, dan is de vraag wat je in kaart brengt. De meeste betaalde SEO-tools overladen je met 40 widgets; je hebt er maar vier nodig om wekelijkse beslissingen te nemen. Bouw ze in de charting-library die je al gebruikt: Chart.js voor HTML, matplotlib voor Jupyter, native grafieken als je in Google Sheets uitkomt.

Lijngrafiek met dagelijkse kliks én vertoningen, 90-dagenvenster. De belangrijkste grafiek. Laat zien of verkeer groeit, vlak is of afneemt. Divergentie (vertoningen omhoog, kliks vlak) is het kenmerk van AI Overview.
Balkgrafiek met de 20 belangrijkste queries, kleur op positie. Gesorteerd op kliks. Groen voor posities 1–5, geel voor 6–10, rood voor 11+. Laat zien welke queries je wint, welke op het spel staan, welke een refresh verdienen.
Scatterplot van positiedaling. X-as: positie vier weken geleden. Y-as: positie vandaag. De diagonaal is “geen verandering”. Punten boven de diagonaal zijn gedaald; eronder verbeterd. De rode cluster rechtsboven is je decay-watchlist; zie het content-refresh-stuk voor de workflow.
Impactschatting van AI Overview. Zet vertoningen en kliks als twee lijnen op dezelfde as, genormaliseerd zodat ze op dag 1 overlappen. Als ze uit elkaar lopen (vertoningen stabiel, kliks dalen), is de kloof ruwweg AI-Overview-kannibalisatie. Niet perfect schoon, maar richtinggevend nuttig.

Mock-up van de vier kern-GSC-grafieken: dagelijkse kliks-lijn, topqueries-balk, decay-scatter, AI-Overview-divergentie — De vier grafieken. Betaalde SEO-dashboards tonen >40 widgets; voor een solo-founder dekken deze vier zo’n 90 % van de beslissingen.

Automatiseringspatronen: Cron, Slack, Sheets, Django

Handmatig trekken is prima voor één keer. Het dashboard wordt pas nuttig als het zichzelf draait. Drie patronen, gerangschikt op opzetinspanning:

Patroon 1: Cron en Slack-alerts. De goedkoopste optie. Een dagelijkse cron draait het script en post naar Slack als een van drie condities triggert — kliks >20 % week-op-week gedaald, een top-10-query uit de top-20 gevallen, of een eerder geïndexeerde pagina raakt de index kwijt. Circa 80 regels Python inclusief webhook. Draait in 4 s op een VPS van $5. Je dashboard doet één ding: schreeuwen als er iets verandert.

import json, os, urllib.request

def post_slack(text):
    payload = {"text": text}
    req = urllib.request.Request(
        os.environ["SLACK_WEBHOOK_URL"],
        data=json.dumps(payload).encode(),
        headers={"Content-Type": "application/json"},
    )
    urllib.request.urlopen(req, timeout=10).read()

# Na het berekenen van wow_change uit twee opeenvolgende 7-daagse GSC-pulls:
if wow_change < -0.20:
    post_slack(
        f":warning: GSC clicks dropped {wow_change*100:.0f}% WoW "
        f"({last_week} → {this_week}). Top falling queries: {falling[:3]}"
    )

Patroon 2: Google Sheets-sink. Pomp de rijen in een Google Sheet via de Sheets-API of de eenvoudigere wrapper gspread. Het sheet is je dashboard: draaitabellen voor ad-hoc-snedes, native grafieken, deelbaar met een niet-technische co-founder. Ongeveer 30 regels bovenop de GSC-pull. Nadeel: refresh-latency hangt af van je cron-frequentie en Sheets wordt traag boven ~20.000 rijen.

Patroon 3: Lichte Django-view. Eén view die de GSC-pull uitvoert, 6 u in Redis cachet en de vier grafieken inline rendert met Chart.js. Rond 200 regels Python en HTML. De moeite waard zodra een co-founder halverwege de week wil spieken. Cache is cruciaal; zonder cache triggert elke pageview een nieuwe GSC-call en trek je op een drukke lanceringsdag het per-minute-quotum leeg.

“Mijn Ahrefs-abonnement van $329/maand opgezegd nadat ik besefte dat ik dagelijks maar één widget bekeek: ‘top organic queries’. In één middag tegen de Search Console-API aangebouwd.”
Een patroon dat regelmatig opduikt in indie-hacker-threads op Hacker News en de bootstrap-hoeken van IndieHackers.

DIY vs SEMrush vs SEOJuice vs Ahrefs vs de Gratis GSC-UI

De vergelijking die founders echt willen gaat niet tussen betaalde tools — maar tussen er één betalen, het zelf bouwen, of de gratis GSC-UI gebruiken en de beperkingen accepteren. Zo stapelen de vijf opties:

Optie	Maandelijkse kosten	Setuptijd	Onderhoud	Multi-property	Historische data
Gratis GSC-UI	$0	0 u (al aanwezig)	Geen	Handmatig wisselen	16 mnd, maar langzame exports
DIY GSC-API + cron + Sheets	$0–$5 (VPS)	4–8 u eerste keer	~30 min/kwartaal (auth-rotatie, incidentele API-deprecatie)	Eenvoudige loop	16 mnd, querybaar in seconden
SEOJuice	$29–$99	~10 min	Geen (managed)	Ingebouwd	16 mnd uit GSC plus eigen crawl-historie
SEMrush	$139–$499	~30 min	Geen (managed)	Project-limieten per plan	2+ jaar op betaalde plannen
Ahrefs	$129–$449	~30 min	Geen (managed)	Project-limieten per plan	2+ jaar op betaalde plannen

DIY wint op kosten, scoort gelijk op datadiepte voor alles binnen je eigen property en verliest op concurrent- en backlink-informatie. Ben je early-stage en is je SEO-vraag “wat werkt op mijn eigen site?”, dan is DIY het juiste antwoord. Ben je aan het opschalen, doe je concurrent-research of jaag je backlinks, dan verdienen de betaalde tools hun prijs. De tools-pagina van SEOJuice zit ertussenin: beheerde GSC-integratie plus audit en AI-zichtbaarheid zonder de enterprise-overhead van SEMrush.

Wat AI Overviews Verkeerd Doen met GSC-Data

Vraag ChatGPT of Gemini hoe je GSC-data interpreteert en je krijgt plausibel klinkende antwoorden die op drie specifieke punten fout zijn. Die fouten duiken op in elke “AI-gegenereerde SEO-rapport”-tool op de markt.

Fout #1: “Position is het gemiddelde van je ranking voor die query.” Position is het gemiddelde van de hoogste positie die een van je URL’s innam in vertoningen waarbij de query een resultaat met jouw site triggerde. Als twee URL’s voor dezelfde query in dezelfde SERP ranken, telt alleen de hoogste. Daarom verandert “position” wanneer je een nieuw artikel publiceert dat een ouder overstijgt: de positie van de oude URL verandert niet, maar die op query-niveau wel.

Fout #2: “CTR wordt per vertoning berekend.” CTR is kliks ÷ vertoningen op het aggregatieniveau dat je opvraagt. Alleen op datum geeft sitebrede dagelijkse CTR; query+pagina geeft CTR per cel. De cijfers tellen niet op tussen aggregatieniveaus omdat de noemer wijzigt.

Fout #3: “Als een query vertoningen maar geen kliks heeft, rankt de pagina slecht.” In het AI-Overview-tijdperk is dit steeds vaker het teken dat je geciteerd wordt in de Overview maar niet wordt aangeklikt. Vertoningen gelijk, kliks omlaag is het klassieke patroon. De pagina rankt niet slechter; de SERP-vorm is veranderd. Het stuk over AI-Overview-citations gaat dieper in op wat je kunt doen.

Valkuilen om te Vermijden als je het Zelf Bouwt

Vijf scherpe randen waar eerste-keer-GSC-API-gebruikers tegenaan lopen. Ze vooraf kennen scheelt een week:

De 25.000-rijlimiet per request is keihard. Daarboven pagineren met startRow. De wrapper google-api-python-client pagineert niet automatisch; lus door totdat de response minder dan 25.000 rijen teruggeeft.
Service-account-sleutels verlopen niet, maar Google trekt ze in bij lekken. Behandel het JSON-bestand als een database-wachtwoord — secret manager in productie, nooit in git.
De 2-daagse datalast is per dag, niet per query. Vandaag levert lege data. Twee dagen geleden is bijna definitief; gisteren is gedeeltelijk.
Domein- (sc-domain:) en URL-prefix-properties (https://...) rapporteren verschillende cijfers. Domein-properties aggregeren over alle subdomeinen en protocollen. Als je beide registreert, zie je overlappende maar niet identieke data. Kies er één als bron van waarheid.
De bucket “anonymized queries” slokt circa 15–25 % van je long-tail. Laag-volume-zoekopdrachten worden om privacy-redenen samengevoegd in (anonymized) en zijn niet terug te halen. Plan top-query-analyses rond de benoemde queries.

Geen showstoppers, maar elk kostte mij de eerste keer een uur. De officiële query-reference documenteert ze allemaal, alleen niet luid genoeg.

FAQ

Hoe lang bewaart de GSC-API historische data? 16 maanden. Daarna is de data weg; er is geen archief-endpoint. Wil je langere trenddata, sla het rollend venster zelf op. Een 365-dagenvenster in Postgres is enkele honderden MB per property.

Kan ik de API gebruiken om URL’s in te dienen voor indexatie? Nee. URL-indiening is in 2020 verwijderd na spam-misbruik. De Indexing-API bestaat nog maar werkt alleen voor vacatures en livestream-events; hem gebruiken voor regulier content is tegen Google-beleid.

Wat is het verschil tussen impressions en clicks? Impressions tellen elke keer dat je URL op een SERP werd getoond, of de gebruiker er nu naartoe scrolde of niet. Clicks tellen gebruikerskliks. CTR is de ratio. Het AI-Overview-tijdperk vergroot de kloof omdat gebruikers het Overview-antwoord zien en niet doorklikken naar de bron.

Is er een gratis laag boven het standaardquotum? Het quotum is voor iedereen gelijk: 1.200 requests/min per project op de analytics-endpoints, 2.000/dag op URL Inspection. Geen betaalde upgrade-optie; quotumverhogingen zijn via Google Cloud Console aan te vragen maar zelden nodig voor solo-workloads.

Kan ik toegang delegeren zonder mijn Google-account te delen? Ja, precies daarvoor is het service-account gemaakt. Maak er per integratie een aan, geef Beperkte toegang tot de property en trek die in zonder je eigen login aan te raken.

Welke language bindings ondersteunt de API? Officieel: Python, Node, Java, PHP, Ruby, Go, .NET. Onofficieel: alles wat een REST-endpoint met een Bearer-token kan aanroepen. JSON-vormen zijn identiek over talen heen.

Vergelijking naast elkaar van gratis GSC-UI, DIY-dashboard, SEOJuice, SEMrush en Ahrefs op kosten, set-up en onderhoud — De vijf opties voor het SEO-dashboard van een founder, uitgezet op kosten en set-uptijd. De DIY-route is gratis maar vraagt engineering-uren.

Wanneer DIY Niet Meer Rendabel Is

Het DIY-dashboard betaalt zichzelf terug zolang de data die je nodig hebt binnen je eigen property leeft. Zodra de vraag wordt “waarom rankt mijn concurrent beter?” of “wie linkt naar hen maar niet naar mij?”, heb je het plafond bereikt van wat GSC blootlegt. Dan is de keuze $129–$449/maand betalen aan SEMrush of Ahrefs voor backlink- en concurrentiedata, of een kleiner tooltje zoals SEOJuice betalen voor dezelfde GSC-integratie plus managed crawl, audit en AI-zichtbaarheid, meestal 15–25 % van wat de enterprise-suites vragen.

Voor de meeste solo-founders ligt het kantelpunt ergens tussen $500/maand MRR en $5K/maand MRR. Onder de ondergrens: zelf bouwen; engineering-tijd is goedkoper dan het abonnement en je leert de data onderweg. Boven de bovengrens: je tijd is te kostbaar om auth-rotaties en quota-retries te onderhouden. Daartussen is het een coin-flip afhankelijk van hoeveel je ervan geniet om middernacht Python te schrijven.

Het andere pad: bouw dit weekend de cron + Slack-versie (zes uur inclusief OAuth-setup), draai hem een maand en kijk wat je echt bekijkt. Als je alleen de alert “top queries dalen” checkt en de rest negeert, heb je ontdekt dat je maar één widget nodig had — blijf bouwen, of koop iets. Het stuk over betaalbare SEO-strategieën behandelt het budget-playbook.

Our powerful suite of automation tools for SEO

Learn, discover, and get inspired by our content