# Come ottenere i risultati di ricerca di Google in Python (2026)

> Risultati di ricerca di Google in Python nel 2026: perché le normali requests falliscono e il codice testato per requests, pandas, httpx asincrono e file JSONL.

- URL: https://serpcrypto.com/it/guides/google-search-results-python/
- Ultimo aggiornamento: 2026-10-22
- Editore: SerpCrypto (https://serpcrypto.com)

Recuperare google.com con requests ha smesso di essere un'opzione nel 2025. Questa guida spiega perché, poi fornisce codice Python breve e verificato nella sintassi che ottiene gli stessi risultati in JSON tramite una API SERP.

**Risposta rapida — Come ottengo i risultati di ricerca di Google in Python nel 2026?**

Chiama una API SERP da Python e leggi il JSON che restituisce; non recuperare google.com da solo, perché Google richiede JavaScript dal 17 gennaio 2025 e il suo robots.txt vieta `/search`. Con **SerpCrypto**, una `requests.get` a `https://serpcrypto.com/api/v1/search` restituisce risultati organici, People Also Ask e altro, per un credito per ricerca a partire da 0,30 USD/1K ricerche a ottobre 2026. Senza KYC; paghi in criptovalute.

## Cosa ti serve

| Attributo | Valore |
| --- | --- |
| Python | 3.9 o successivo |
| Pacchetti | `requests` per le basi; `pandas` per le tabelle; `httpx` per l'asincrono |
| Chiave API | Dalla tua dashboard SerpCrypto, salvata nella variabile d'ambiente `SERPCRYPTO_API_KEY` |
| Endpoint | `GET https://serpcrypto.com/api/v1/search` |
| Costo | 1 credito = 1 richiesta di ricerca andata a buon fine, che restituisce una pagina di risultati su qualsiasi motore supportato. Una richiesta non riuscita non viene addebitata |
| Pack più piccolo | 10.000 ricerche per 7,50 USD; i crediti non scadono mai |

## Perché requests.get su google.com non funziona più?

Perché i risultati non sono più nell'HTML che riceve un semplice client HTTP. Il 17 gennaio 2025 Google ha iniziato a richiedere JavaScript per la Ricerca; ha dichiarato che JavaScript lo aiuta a proteggere i suoi servizi dai bot e che meno dello 0,1% delle ricerche proveniva da utenti con JavaScript disattivato, come riportato da TechCrunch.

Il robots.txt di Google, letto il 22 ottobre 2026, elenca anche `Disallow: /search` per tutti i user agent. Una API SERP si occupa di eseguire la ricerca e fare il parsing della pagina, e il tuo codice Python gestisce solo JSON. È l'approccio usato nel resto di questa guida.

## Come faccio la prima richiesta?

Installa requests, metti la tua chiave in una variabile d'ambiente e invia la query con un paese e una lingua. La risposta è un dizionario con una chiave per ogni blocco della pagina dei risultati; `organic_results` contiene i link classificati.

Tieni la chiave fuori dal tuo codice sorgente. Su macOS e Linux, `export SERPCRYPTO_API_KEY=...` nella shell; su Windows PowerShell, `$env:SERPCRYPTO_API_KEY="..."`.

*Prima richiesta con 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"])

```

## Come trasformo i risultati in un DataFrame pandas?

Crea una riga per ogni risultato organico e tieni la query accanto. Un DataFrame rende facile ordinare, filtrare per dominio o esportare in CSV ed Excel. I campi mancanti, come `date` sulla maggior parte dei risultati, diventano celle vuote invece di errori.

*Più query in un unico 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)

```

## Come posso eseguire molte ricerche contemporaneamente?

Usa httpx con asyncio e limita il numero di richieste in volo con un semaforo. Il tuo account ha un limite di concorrenza, mostrato nella dashboard; restare sotto quel limite evita errori `429`. Inizia con un numero piccolo, ad esempio 5, e impostalo al limite che mostra la tua dashboard.

*Ricerche asincrone con httpx e un semaforo*

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

```

## Come posso ottenere più di 10 risultati e salvarli?

Chiedi le pagine successive con `page=2`, `page=3` e così via, fino a `page=10`. Ogni pagina è una ricerca e un credito, perché Google mostra circa 10 risultati organici per pagina da quando ha smesso di rispettare `num=100` a settembre 2025.

Salva ogni risposta grezza come una riga di un file JSONL. Il JSON grezzo conserva ogni blocco, così potrai rispondere a nuove domande in seguito senza pagare di nuovo per le stesse ricerche.

*Pagine da 1 a 3 salvate come 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)

```

## Quanto costa eseguire questo codice?

Ogni chiamata in questi esempi è una ricerca. Il primo esempio costa un credito, l'esempio con DataFrame tre, e l'esempio JSONL fino a tre. Una richiesta fallita non viene addebitata.

10.000 ricerche costano 7,50 USD e 100.000 ricerche costano 56,25 USD, a ottobre 2026; la tariffa scende a 0,30 USD/1K ricerche a 5.000.000 di ricerche. I crediti non scadono mai. Paghi in BTC, USDT, USDC, ETH, SOL, LTC con una ricarica 25 USD, senza caricare documenti d'identità. Vedi [prezzi](https://serpcrypto.com/it/pricing/).

## Risultati di Google in Python: domande frequenti

### Posso usare BeautifulSoup sulle pagine dei risultati di Google?

Non in modo affidabile. Google richiede JavaScript da gennaio 2025, quindi l'HTML che riceve un client semplice non contiene i risultati, e il robots.txt di Google vieta `/search`. Un'API SERP restituisce invece i campi già analizzati come JSON.

### Esiste una libreria Python ufficiale per SerpCrypto?

No. L'API è un semplice endpoint HTTPS, quindi `requests` o `httpx` è tutto ciò che ti serve. Gli esempi in questa pagina e nella [pagina della documentazione Python](https://serpcrypto.com/it/docs/python/) sono codice da copiare e incollare, non un pacchetto pubblicato.

### Come posso ottenere risultati per un altro paese?

Imposta `gl` sul codice paese e `hl` sulla lingua, ad esempio `gl=fr` e `hl=fr` per la Francia. Aggiungi `location` per una città. La [pagina delle località](https://serpcrypto.com/it/docs/locations/) elenca i codici più comuni.

### Come gestisco errori e tentativi ripetuti?

Chiama `raise_for_status()`, poi riprova le risposte `429`, `502` e `504` dopo un'attesa crescente. Le richieste fallite non vengono addebitate. La [pagina degli errori](https://serpcrypto.com/it/docs/errors/) contiene una funzione di retry completa.

### Posso ottenere risultati di Bing con lo stesso codice?

Sì. Cambia `engine` in `bing`; la risposta mantiene la stessa struttura, con `organic_results` e `related_searches`.

## Fonti

1. [Google inizia a richiedere JavaScript per Google Search](https://techcrunch.com/2025/01/17/google-begins-requiring-javascript-for-google-search/) — TechCrunch (2025-01-17)
2. [robots.txt di google.com](https://www.google.com/robots.txt) — Google (read 2026-10-22)
3. [Google costringe i rank tracker a 500-1.000 richieste per query](https://ppc.land/google-forces-rank-trackers-into-500-to-1-000-requests-per-query/) — PPC Land (2026-08-27)

---

SerpCrypto: SerpCrypto è un'API SERP per sviluppatori e agenti AI che restituisce i risultati di ricerca di Google e Bing in JSON, con pagamento in criptovalute e senza caricare documenti d'identità. I crediti di ricerca prepagati a partire da 0,30 USD/1K ricerche non scadono mai. Senza KYC — niente documento, niente selfie, niente documenti. Paghi in criptovalute.