# Comment obtenir les résultats de recherche Google en Python (2026)

> Résultats de recherche Google en Python en 2026 : pourquoi les requêtes simples échouent, du code testé avec requests, pandas et httpx en asynchrone.

- URL: https://serpcrypto.com/fr/guides/google-search-results-python/
- Dernière mise à jour: 2026-10-22
- Éditeur: SerpCrypto (https://serpcrypto.com)

Récupérer google.com avec requests n'est plus une option depuis 2025. Ce guide explique pourquoi, puis fournit du code Python court et vérifié syntaxiquement qui obtient les mêmes résultats en JSON via une API SERP.

**Réponse rapide — Comment obtenir les résultats de recherche Google en Python en 2026 ?**

Appelez une API SERP depuis Python et lisez le JSON renvoyé ; ne récupérez pas google.com vous-même, car Google exige JavaScript depuis le 17 janvier 2025 et son robots.txt interdit `/search`. Avec **SerpCrypto**, une `requests.get` à `https://serpcrypto.com/api/v1/search` renvoie les résultats organiques, People Also Ask et plus encore, pour un crédit par recherche à partir de 0,30 $US/1K requêtes en octobre 2026. Sans KYC ; payez en crypto.

## Ce qu'il vous faut

| Attribut | Valeur |
| --- | --- |
| Python | 3.9 ou plus récent |
| Paquets | `requests` pour les bases ; `pandas` pour les tableaux ; `httpx` pour l'asynchrone |
| Clé API | Depuis votre tableau de bord SerpCrypto, stockée dans la variable d'environnement `SERPCRYPTO_API_KEY` |
| Endpoint | `GET https://serpcrypto.com/api/v1/search` |
| Coût | 1 crédit = 1 requête réussie, qui renvoie une page de résultats sur n'importe quel moteur pris en charge. Une requête qui échoue n'est pas facturée |
| Plus petit pack | 10 000 recherches pour 7,50 $US ; les crédits n'expirent jamais |

## Pourquoi requests.get sur google.com ne fonctionne-t-il plus ?

Parce que les résultats ne figurent plus dans le HTML qu'un client HTTP simple reçoit. Le 17 janvier 2025, Google a commencé à exiger JavaScript pour la recherche ; il a déclaré que JavaScript l'aide à protéger ses services contre les bots et que moins de 0,1 % des recherches provenaient d'utilisateurs ayant désactivé JavaScript, comme l'a rapporté TechCrunch.

Le robots.txt de Google, consulté le 22 octobre 2026, liste également `Disallow: /search` pour tous les user agents. Une API SERP se charge d'exécuter la recherche et d'analyser la page, et votre code Python ne manipule que du JSON. C'est l'approche utilisée dans la suite de ce guide.

## Comment effectuer la première requête ?

Installez requests, placez votre clé dans une variable d'environnement et envoyez la requête avec un pays et une langue. La réponse est un dictionnaire avec une clé par bloc de la page de résultats ; `organic_results` contient les liens classés.

Gardez la clé hors de votre code source. Sur macOS et Linux, `export SERPCRYPTO_API_KEY=...` dans le shell ; sur Windows PowerShell, `$env:SERPCRYPTO_API_KEY="..."`.

*Première requête avec 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"])

```

## Comment convertir les résultats en DataFrame pandas ?

Créez une ligne par résultat organique et conservez la requête à côté. Un DataFrame facilite le tri, le filtrage par domaine ou l'export vers CSV et Excel. Les champs manquants, comme `date` sur la plupart des résultats, deviennent des cellules vides au lieu d'erreurs.

*Plusieurs requêtes dans un seul 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)

```

## Comment exécuter de nombreuses recherches en même temps ?

Utilisez httpx avec asyncio et limitez le nombre de requêtes en cours avec un sémaphore. Votre compte a une limite de concurrence, affichée dans le dashboard ; rester en dessous évite les erreurs `429`. Commencez par un petit nombre, par exemple 5, puis réglez-le sur la limite indiquée par votre dashboard.

*Recherches asynchrones avec httpx et un sémaphore*

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

```

## Comment obtenir plus de 10 résultats et les enregistrer ?

Demandez les pages suivantes avec `page=2`, `page=3`, etc., jusqu'à `page=10`. Chaque page correspond à une requête et à un crédit, car Google sert environ 10 résultats organiques par page depuis qu'il ne respecte plus `num=100` en septembre 2025.

Enregistrez chaque réponse brute sur une ligne d'un fichier JSONL. Le JSON brut conserve tous les blocs, ce qui vous permet de répondre à de nouvelles questions plus tard sans repayer les mêmes requêtes.

*Pages 1 à 3 enregistrées en 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)

```

## Combien coûte l'exécution de ce code ?

Chaque appel dans ces exemples correspond à une requête. Le premier exemple coûte un crédit, l'exemple DataFrame trois, et l'exemple JSONL jusqu'à trois. Une requête échouée n'est pas facturée.

10 000 recherches coûtent 7,50 $US et 100 000 recherches coûtent 56,25 $US, en octobre 2026 ; le tarif descend à 0,30 $US/1K requêtes à 5 000 000 de requêtes. Les crédits n'expirent jamais. Vous payez en BTC, USDT, USDC, ETH, SOL, LTC depuis une recharge de 25 $US, sans envoi de pièce d'identité. Voir [tarifs](https://serpcrypto.com/fr/pricing/).

## Résultats Google en Python : questions fréquentes

### Peut-on utiliser BeautifulSoup sur les pages de résultats Google ?

Pas de manière fiable. Google exige JavaScript depuis janvier 2025, donc le HTML reçu par un client simple ne contient pas les résultats, et le robots.txt de Google interdit `/search`. Une API SERP renvoie à la place les champs parsés en JSON.

### Existe-t-il une bibliothèque Python officielle pour SerpCrypto ?

Non. L'API est un simple endpoint HTTPS, donc `requests` ou `httpx` suffit. Les exemples de cette page et de la [page de doc Python](https://serpcrypto.com/fr/docs/python/) sont du code à copier-coller, pas un package publié.

### Comment obtenir des résultats pour un autre pays ?

Définissez `gl` sur le code pays et `hl` sur la langue, par exemple `gl=fr` et `hl=fr` pour la France. Ajoutez `location` pour une ville. La [page des localisations](https://serpcrypto.com/fr/docs/locations/) liste les codes courants.

### Comment gérer les erreurs et les retries ?

Appelez `raise_for_status()`, puis réessayez les réponses `429`, `502` et `504` après un délai croissant. Les requêtes échouées ne sont pas facturées. La [page des erreurs](https://serpcrypto.com/fr/docs/errors/) contient une fonction de retry complète.

### Peut-on obtenir des résultats Bing avec le même code ?

Oui. Remplacez `engine` par `bing` ; la réponse garde la même structure, avec `organic_results` et `related_searches`.

## Sources

1. [Google commence à exiger JavaScript pour Google Search](https://techcrunch.com/2025/01/17/google-begins-requiring-javascript-for-google-search/) — TechCrunch (2025-01-17)
2. [robots.txt de google.com](https://www.google.com/robots.txt) — Google (read 2026-10-22)
3. [Google contraint les trackers de positions à 500 à 1 000 requêtes par mot-clé](https://ppc.land/google-forces-rank-trackers-into-500-to-1-000-requests-per-query/) — PPC Land (2026-08-27)

---

SerpCrypto: SerpCrypto est une API SERP pour les développeurs et les agents IA qui renvoie les résultats de recherche Google et Bing en JSON, payable en crypto sans envoi de pièce d'identité. Les crédits de recherche prépayés à partir de 0,30 $US/1K requêtes n'expirent jamais. Sans KYC — pas de pièce d'identité, pas de selfie, pas de documents. Payer en crypto.