# Google-Suchergebnisse in Python abrufen (2026)

> Google-Suchergebnisse in Python 2026 abrufen: Warum einfache requests scheitern, dann getesteter Code für requests, pandas, async httpx und JSONL-Dateien.

- URL: https://serpcrypto.com/de/guides/google-search-results-python/
- Zuletzt aktualisiert: 2026-10-22
- Herausgeber: SerpCrypto (https://serpcrypto.com)

google.com mit requests abzurufen ist seit 2025 keine Option mehr. Dieser Leitfaden erklärt warum und liefert dann kurzen, syntaxgeprüften Python-Code, der dieselben Ergebnisse als JSON über eine SERP-API erhält.

**Kurze Antwort — Wie bekomme ich 2026 Google-Suchergebnisse in Python?**

Rufen Sie eine SERP-API aus Python auf und lesen Sie das zurückgegebene JSON; rufen Sie google.com nicht selbst ab, denn Google verlangt seit dem 17. Januar 2025 JavaScript und seine robots.txt untersagt `/search`. Mit **SerpCrypto** liefert eine `requests.get` an `https://serpcrypto.com/api/v1/search` organische Ergebnisse, People Also Ask und mehr, für einen Credit pro Suchanfrage ab 0,30 $/1K Suchanfragen, Stand Oktober 2026. Ohne KYC; mit Krypto bezahlen.

## Was Sie brauchen

| Attribut | Wert |
| --- | --- |
| Python | 3.9 oder neuer |
| Pakete | `requests` für die Grundlagen; `pandas` für Tabellen; `httpx` für async |
| API-Schlüssel | Aus Ihrem SerpCrypto-Dashboard, gespeichert in der Umgebungsvariable `SERPCRYPTO_API_KEY` |
| Endpoint | `GET https://serpcrypto.com/api/v1/search` |
| Kosten | 1 Credit = 1 erfolgreiche Suchanfrage, die eine Ergebnisseite auf jeder unterstützten Engine liefert. Eine fehlgeschlagene Anfrage wird nicht berechnet |
| Kleinstes Pack | 10.000 Suchanfragen für 7,50 $; Credits verfallen nie |

## Warum funktioniert requests.get auf google.com nicht mehr?

Weil die Ergebnisse nicht mehr im HTML stehen, das ein einfacher HTTP-Client erhält. Am 17. Januar 2025 begann Google, für die Suche JavaScript zu verlangen; Google erklärte, JavaScript helfe, die Dienste vor Bots zu schützen, und weniger als 0,1 % der Suchanfragen stammten von Nutzern mit deaktiviertem JavaScript, wie TechCrunch berichtete.

Die robots.txt von Google, gelesen am 22. Oktober 2026, führt zudem `Disallow: /search` für alle User-Agents. Eine SERP-API übernimmt das Ausführen der Suchanfrage und das Parsen der Seite, und Ihr Python-Code hat es nur mit JSON zu tun. Das ist der Ansatz im Rest dieses Leitfadens.

## Wie stelle ich die erste Anfrage?

Installieren Sie requests, legen Sie Ihren Schlüssel in einer Umgebungsvariable ab und senden Sie die Suchanfrage mit einem Land und einer Sprache. Die Antwort ist ein Dictionary mit einem Schlüssel pro Block der Ergebnisseite; `organic_results` enthält die gerankten Links.

Halten Sie den Schlüssel aus Ihrem Quellcode heraus. Unter macOS und Linux `export SERPCRYPTO_API_KEY=...` in der Shell; unter Windows PowerShell `$env:SERPCRYPTO_API_KEY="..."`.

*Erste Anfrage mit 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"])

```

## Wie wandle ich die Ergebnisse in einen pandas DataFrame um?

Bauen Sie eine Zeile pro organischem Ergebnis und behalten Sie die Suchanfrage daneben. Ein DataFrame macht es einfach, zu sortieren, nach Domain zu filtern oder nach CSV und Excel zu exportieren. Fehlende Felder, etwa `date` bei den meisten Ergebnissen, werden zu leeren Zellen statt zu Fehlern.

*Mehrere Suchanfragen in einem 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)

```

## Wie führe ich viele Suchanfragen gleichzeitig aus?

Verwenden Sie httpx mit asyncio und begrenzen Sie die Anzahl gleichzeitig laufender Anfragen mit einem Semaphore. Ihr Konto hat ein Nebenläufigkeitslimit, das im Dashboard angezeigt wird; bleiben Sie darunter, um `429`-Fehler zu vermeiden. Beginnen Sie mit einer kleinen Zahl, etwa 5, und setzen Sie sie auf das Limit, das Ihr Dashboard anzeigt.

*Asynchrone Suchanfragen mit httpx und einem 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"]))

```

## Wie bekomme ich mehr als 10 Ergebnisse und speichere sie?

Fordern Sie die nächsten Seiten mit `page=2`, `page=3` und so weiter an, bis zu `page=10`. Jede Seite ist eine Suchanfrage und ein Credit, denn Google liefert seit September 2025 etwa 10 organische Ergebnisse pro Seite, nachdem `num=100` nicht mehr berücksichtigt wird.

Speichern Sie jede Rohantwort als eine Zeile einer JSONL-Datei. Rohes JSON enthält jeden Block, sodass Sie später neue Fragen beantworten können, ohne dieselben Suchanfragen erneut zu bezahlen.

*Seiten 1 bis 3 als JSONL gespeichert*

```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)

```

## Was kostet es, diesen Code auszuführen?

Jeder Aufruf in diesen Beispielen ist eine Suchanfrage. Das erste Beispiel kostet einen Credit, das DataFrame-Beispiel drei und das JSONL-Beispiel bis zu drei. Eine fehlgeschlagene Anfrage wird nicht berechnet.

10.000 Suchanfragen kosten 7,50 $ und 100.000 Suchanfragen kosten 56,25 $, Stand Oktober 2026; der Preis sinkt auf 0,30 $/1K Suchanfragen bei 5.000.000 Suchanfragen. Credits verfallen nie. Sie zahlen in BTC, USDT, USDC, ETH, SOL, LTC aus einem 25 $-Guthaben, ohne Ausweis-Upload. Siehe [Preise](https://serpcrypto.com/de/pricing/).

## Google-Ergebnisse in Python: häufige Fragen

### Kann ich BeautifulSoup auf Google-Suchergebnisseiten verwenden?

Nicht zuverlässig. Google verlangt seit Januar 2025 JavaScript, daher enthält das HTML, das ein einfacher Client empfängt, nicht die Ergebnisse, und Googles robots.txt verbietet `/search`. Eine SERP-API liefert die geparsten Felder stattdessen als JSON.

### Gibt es eine offizielle Python-Bibliothek für SerpCrypto?

Nein. Die API ist ein einfacher HTTPS-Endpoint, daher genügen `requests` oder `httpx`. Die Beispiele auf dieser Seite und auf der [Python-Dokumentationsseite](https://serpcrypto.com/de/docs/python/) sind Copy-Paste-Code, kein veröffentlichtes Paket.

### Wie bekomme ich Ergebnisse für ein anderes Land?

Setzen Sie `gl` auf den Ländercode und `hl` auf die Sprache, zum Beispiel `gl=fr` und `hl=fr` für Frankreich. Fügen Sie `location` für eine Stadt hinzu. Die [Seite mit den Standorten](https://serpcrypto.com/de/docs/locations/) listet gängige Codes.

### Wie gehe ich mit Fehlern und Wiederholungen um?

Rufen Sie `raise_for_status()` auf und wiederholen Sie dann `429`-, `502`- und `504`-Antworten nach einer wachsenden Verzögerung. Fehlgeschlagene Anfragen werden nicht berechnet. Die [Fehlerseite](https://serpcrypto.com/de/docs/errors/) enthält eine vollständige Wiederholungsfunktion.

### Kann ich mit demselben Code Bing-Ergebnisse bekommen?

Ja. Ändern Sie `engine` zu `bing`; die Antwort behält dieselbe Struktur, mit `organic_results` und `related_searches`.

## Quellen

1. [Google verlangt ab sofort JavaScript für die Google-Suche](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 zwingt Rank-Tracker in 500 bis 1.000 Anfragen pro Query](https://ppc.land/google-forces-rank-trackers-into-500-to-1-000-requests-per-query/) — PPC Land (2026-08-27)

---

SerpCrypto: SerpCrypto ist eine SERP-API für Entwickler und KI-Agenten, die Google- und Bing-Ergebnisse als JSON zurückgibt und mit Krypto bezahlt wird, ohne Ausweisupload. Vorausbezahlte Such-Credits ab 0,30 $/1K Suchanfragen verfallen nie. Ohne KYC — kein Ausweis, kein Selfie, keine Dokumente. Mit Krypto bezahlen.