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
| 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="...".
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.
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.
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.
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.
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 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à 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 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 (3)
- Google inizia a richiedere JavaScript per Google Search — TechCrunch (2025-01-17)
- robots.txt di google.com — Google (read 2026-10-22)
- Google costringe i rank tracker a 500-1.000 richieste per query — PPC Land (2026-08-27)