# Hoe je Google-zoekresultaten in Python krijgt (2026)

> Hoe je in 2026 Google-zoekresultaten in Python krijgt: waarom gewone requests niet meer werken, met geteste code voor requests en async httpx.

- URL: https://serpcrypto.com/nl/guides/google-search-results-python/
- Laatst bijgewerkt: 2026-10-22
- Uitgever: SerpCrypto (https://serpcrypto.com)

google.com ophalen met requests is sinds 2025 geen optie meer. Deze gids legt uit waarom, en geeft daarna korte, op syntax gecontroleerde Python die dezelfde resultaten als JSON krijgt via een SERP-API.

**Snel antwoord — Hoe krijg ik in 2026 Google-zoekresultaten in Python?**

Roep een SERP-API aan vanuit Python en lees de JSON die het teruggeeft; haal google.com niet zelf op, want Google vereist sinds 17 januari 2025 JavaScript en zijn robots.txt staat `/search` niet toe. Met **SerpCrypto** geeft één `requests.get` naar `https://serpcrypto.com/api/v1/search` organische resultaten, People Also Ask en meer, voor één credit per zoekopdracht vanaf US$ 0,30/1K zoekopdrachten per oktober 2026. Zonder KYC; betalen met crypto.

## Wat je nodig hebt

| Attribuut | Waarde |
| --- | --- |
| Python | 3.9 of nieuwer |
| Packages | `requests` voor de basis; `pandas` voor tabellen; `httpx` voor async |
| API-sleutel | Uit je SerpCrypto-dashboard, opgeslagen in de omgevingsvariabele `SERPCRYPTO_API_KEY` |
| Endpoint | `GET https://serpcrypto.com/api/v1/search` |
| Kosten | 1 credit = 1 geslaagde zoekopdracht, die één pagina met resultaten oplevert op elke ondersteunde engine. Een mislukte zoekopdracht wordt niet in rekening gebracht |
| Kleinste pack | 10.000 zoekopdrachten voor US$ 7,50; credits verlopen nooit |

## Waarom werkt requests.get op google.com niet meer?

Omdat de resultaten niet meer in de HTML staan die een gewone HTTP-client ontvangt. Op 17 januari 2025 begon Google JavaScript vereist te maken voor Search; Google zei dat JavaScript helpt zijn diensten tegen bots te beschermen en dat minder dan 0,1% van de zoekopdrachten afkomstig was van gebruikers met JavaScript uit, zoals TechCrunch berichtte.

Google's robots.txt, gelezen op 22 oktober 2026, vermeldt ook `Disallow: /search` voor alle user agents. Een SERP-API regelt het uitvoeren van de zoekopdracht en het parsen van de pagina, en je Python-code heeft alleen met JSON te maken. Dat is de aanpak in de rest van deze gids.

## Hoe doe ik de eerste request?

Installeer requests, zet je sleutel in een omgevingsvariabele en stuur de zoekopdracht met een land en een taal. De response is een dictionary met één sleutel per blok van de resultatenpagina; `organic_results` bevat de gerangschikte links.

Houd de sleutel buiten je broncode. Op macOS en Linux `export SERPCRYPTO_API_KEY=...` in de shell; op Windows PowerShell `$env:SERPCRYPTO_API_KEY="..."`.

*Eerste request met requests*

```python
import os

import requests

API = "https://serpcrypto.com/api/v1/search"
KEY = os.environ["SERPCRYPTO_API_KEY"]

resp = requests.get(
    API,
    headers={"Authorization": "Bearer " + KEY},
    params={"engine": "google", "q": "best hiking boots", "gl": "us", "hl": "en"},
    timeout=60,
)
resp.raise_for_status()
results = resp.json()

for item in results.get("organic_results", []):
    print(item["position"], item["title"])
    print("   ", item["link"])

for q in results.get("people_also_ask", []):
    print("PAA:", q["question"])

```

## Hoe zet ik de resultaten om naar een pandas DataFrame?

Maak één rij per organisch resultaat en houd de zoekopdracht ernaast. Met een DataFrame kun je makkelijk sorteren, filteren op domein of exporteren naar CSV en Excel. Ontbrekende velden, zoals `date` bij de meeste resultaten, worden lege cellen in plaats van fouten.

*Meerdere zoekopdrachten in één DataFrame*

```python
import os
from urllib.parse import urlparse

import pandas as pd
import requests

API = "https://serpcrypto.com/api/v1/search"
HEADERS = {"Authorization": "Bearer " + os.environ["SERPCRYPTO_API_KEY"]}


def organic_rows(query, gl="us", hl="en"):
    params = {"engine": "google", "q": query, "gl": gl, "hl": hl}
    resp = requests.get(API, headers=HEADERS, params=params, timeout=60)
    resp.raise_for_status()
    for r in resp.json().get("organic_results", []):
        yield {
            "query": query,
            "position": r.get("position"),
            "title": r.get("title"),
            "domain": urlparse(r.get("link", "")).netloc,
            "link": r.get("link"),
            "snippet": r.get("snippet"),
        }


queries = ["crm for small business", "invoice software", "time tracking app"]
df = pd.DataFrame([row for q in queries for row in organic_rows(q)])
print(df.groupby("domain").size().sort_values(ascending=False).head(10))
df.to_csv("serp_results.csv", index=False)

```

## Hoe voer ik veel zoekopdrachten tegelijk uit?

Gebruik httpx met asyncio en beperk het aantal gelijktijdige requests met een semaphore. Je account heeft een concurrency-limiet, die je in het dashboard ziet; blijf eronder om `429`-fouten te voorkomen. Begin met een klein aantal, bijvoorbeeld 5, en zet het op de limiet die je dashboard toont.

*Async zoekopdrachten met httpx en een semaphore*

```python
import asyncio
import os

import httpx

API = "https://serpcrypto.com/api/v1/search"
HEADERS = {"Authorization": "Bearer " + os.environ["SERPCRYPTO_API_KEY"]}
LIMIT = asyncio.Semaphore(5)


async def search(client, query):
    async with LIMIT:
        resp = await client.get(API, params={"engine": "google", "q": query, "gl": "us", "hl": "en"})
        resp.raise_for_status()
        data = resp.json()
        top = data.get("organic_results", [])[:3]
        return query, [r["link"] for r in top]


async def main(queries):
    async with httpx.AsyncClient(headers=HEADERS, timeout=60) as client:
        for query, links in await asyncio.gather(*(search(client, q) for q in queries)):
            print(query, links)


if __name__ == "__main__":
    asyncio.run(main(["python web framework", "python orm", "python task queue"]))

```

## Hoe krijg ik meer dan 10 resultaten en sla ik ze op?

Vraag de volgende pagina's op met `page=2`, `page=3` enzovoort, tot `page=10`. Elke pagina is één zoekopdracht en één credit, omdat Google sinds het in september 2025 stopte met het respecteren van `num=100` ongeveer 10 organische resultaten per pagina levert.

Sla elke ruwe response op als één regel in een JSONL-bestand. Ruwe JSON bewaart elk blok, zodat je later nieuwe vragen kunt beantwoorden zonder opnieuw voor dezelfde zoekopdrachten te betalen.

*Pagina's 1 tot 3 opgeslagen als JSONL*

```python
import json
import os

import requests

API = "https://serpcrypto.com/api/v1/search"
HEADERS = {"Authorization": "Bearer " + os.environ["SERPCRYPTO_API_KEY"]}


def fetch_pages(query, pages=3, path="serp.jsonl"):
    with open(path, "a", encoding="utf-8") as out:
        for page in range(1, pages + 1):
            params = {"engine": "google", "q": query, "gl": "us", "hl": "en", "page": page}
            resp = requests.get(API, headers=HEADERS, params=params, timeout=60)
            resp.raise_for_status()
            data = resp.json()
            out.write(json.dumps(data, ensure_ascii=False) + "\n")
            if not data.get("organic_results"):
                break


fetch_pages("electric cargo bike", pages=3)

```

## Wat kost het om deze code uit te voeren?

Elke call in deze voorbeelden is één zoekopdracht. Het eerste voorbeeld kost één credit, het DataFrame-voorbeeld drie en het JSONL-voorbeeld tot drie. Een mislukte request wordt niet in rekening gebracht.

10.000 zoekopdrachten kosten US$ 7,50 en 100.000 zoekopdrachten kosten US$ 56,25, per oktober 2026; het tarief daalt naar US$ 0,30/1K zoekopdrachten bij 5.000.000 zoekopdrachten. Credits verlopen nooit. Je betaalt in BTC, USDT, USDC, ETH, SOL, LTC uit een US$ 25-top-up, zonder ID te uploaden. Zie [pricing](https://serpcrypto.com/nl/pricing/).

## Google-resultaten in Python: veelgestelde vragen

### Kan ik BeautifulSoup gebruiken op Google-zoekresultatenpagina's?

Niet betrouwbaar. Google vereist sinds januari 2025 JavaScript, dus de HTML die een gewone client ontvangt bevat de resultaten niet, en Google's robots.txt staat `/search` niet toe. Een SERP-API geeft de geparseerde velden als JSON terug.

### Is er een officiële Python-bibliotheek voor SerpCrypto?

Nee. De API is een gewoon HTTPS-endpoint, dus `requests` of `httpx` is alles wat je nodig hebt. De voorbeelden op deze pagina en op de [Python-documentatiepagina](https://serpcrypto.com/nl/docs/python/) zijn copy-paste-code, geen gepubliceerd package.

### Hoe krijg ik resultaten voor een ander land?

Zet `gl` op de landcode en `hl` op de taal, bijvoorbeeld `gl=fr` en `hl=fr` voor Frankrijk. Voeg `location` toe voor een stad. De [locations-pagina](https://serpcrypto.com/nl/docs/locations/) vermeldt veelgebruikte codes.

### Hoe ga ik om met errors en retries?

Roep `raise_for_status()` aan en probeer `429`-, `502`- en `504`-responses opnieuw na een groeiende vertraging. Mislukte requests worden niet in rekening gebracht. De [errors-pagina](https://serpcrypto.com/nl/docs/errors/) bevat een volledige retry-functie.

### Kan ik met dezelfde code Bing-resultaten krijgen?

Ja. Verander `engine` in `bing`; de response behoudt dezelfde vorm, met `organic_results` en `related_searches`.

## Bronnen

1. [Google begint JavaScript vereist te maken voor Google Search](https://techcrunch.com/2025/01/17/google-begins-requiring-javascript-for-google-search/) — TechCrunch (2025-01-17)
2. [google.com robots.txt](https://www.google.com/robots.txt) — Google (read 2026-10-22)
3. [Google dwingt rank trackers tot 500 tot 1.000 requests per query](https://ppc.land/google-forces-rank-trackers-into-500-to-1-000-requests-per-query/) — PPC Land (2026-08-27)

---

SerpCrypto: SerpCrypto is een SERP-API voor developers en AI-agents die Google- en Bing-resultaten als JSON retourneert, betaald met crypto zonder ID te uploaden. Prepaid zoekcredits vanaf US$ 0,30/1K zoekopdrachten verlopen nooit. Zonder KYC — geen ID, geen selfie, geen documenten. Betalen met crypto.