Come estrarre dati da Google Maps con Python

Se hai mai provato a costruire una lista mirata di contatti commerciali, a esplorare nuovi mercati o a confrontare i concorrenti, sai bene che Google Maps è una miniera d’oro. Ma c’è un dato che spiega perché: ogni mese ci sono oltre 1,5 miliardi di ricerche “vicino a me” e il 76% degli utenti che cerca attività locali le visita entro 24 ore (). La domanda di dati aziendali aggiornati e geolocalizzati non è mai stata così alta.

Che tu lavori in sales, marketing o operations, estrarre dati strutturati da Google Maps può fare la differenza tra una chiamata a freddo e un lead caldo, con un tasso di conversione alto.

Lavoro da anni nel mondo SaaS e dell’automazione e ho visto in prima persona come i team usino Python (e oggi anche strumenti basati su AI come ) per trasformare Google Maps in un asset strategico.

In questa guida ti mostrerò esattamente come estrarre dati da Google Maps con Python nel 2026, passo dopo passo, con codice, suggerimenti sulla conformità e un confronto con le soluzioni no-code. Se sei già esperto di Python o vuoi solo la strada più veloce per arrivare a dati utilizzabili, sei nel posto giusto.

Cosa significa estrarre dati da Google Maps con Python?

Partiamo dalle basi: estrarre dati da Google Maps con Python significa raccogliere in modo programmatico informazioni sulle attività commerciali — come nomi, indirizzi, valutazioni, recensioni, numeri di telefono e coordinate — da Google Maps, così da poterle analizzare, filtrare ed esportare per uso aziendale.

Ci sono due modi principali per farlo:

1. Google Maps Places API: il metodo ufficiale e autorizzato. Usi una chiave API per interrogare i server di Google e ottenere dati JSON strutturati. È stabile, prevedibile e, in gran parte, conforme, ma prevede quote e costi.
2. Web scraping dell’HTML: automatizzi un browser (con strumenti come Playwright o Selenium) per caricare Google Maps, eseguire ricerche e analizzare la pagina renderizzata. È più flessibile, ma anche più fragile: Google cambia spesso la struttura del sito e lo scraping dell’HTML può violare i termini di Google.

Campi dati tipici che puoi estrarre:

• Nome dell’attività
• Categoria/tipo
• Indirizzo completo (più città, stato, CAP, paese)
• Latitudine e longitudine
• Numero di telefono
• URL del sito web
• Valutazione e numero di recensioni
• Fascia di prezzo
• Stato dell’attività (aperta/chiusa)
• Orari di apertura
• Place ID (l’identificatore univoco di Google)
• URL di Google Maps

Perché è importante? Perché questi campi alimentano tutto: dalla generazione di lead alla pianificazione territoriale, dal benchmarking dei concorrenti alla ricerca di mercato. La chiave è puntare ai dati giusti in base ai tuoi obiettivi di business: non limitarti a estrarre tutto alla cieca.

Perché i team di sales e marketing estraggono dati da Google Maps con Python

Scendiamo nel concreto. Perché nel 2026 così tanti team di sales e marketing sono ossessionati dai dati di Google Maps?

• Generazione di lead: crea elenchi iper-mirati di attività locali, completi di contatti e valutazioni, per le campagne di outreach.
• Pianificazione territoriale: mappa territori commerciali, zone di consegna o aree di servizio in base alla reale densità e tipologia delle attività.
• Monitoraggio dei concorrenti: tieni traccia nel tempo di sedi, valutazioni e recensioni dei competitor per individuare trend e opportunità.
• Ricerche di mercato: analizza categorie di attività, orari di apertura e sentiment delle recensioni per definire la strategia go-to-market.
• Scelta della location: per real estate e retail, valuta le possibili sedi in base ai servizi vicini, al flusso di passaggio e alla concorrenza.

Impatto reale: secondo il , il 92% delle organizzazioni sales prevede di aumentare gli investimenti in AI e dati, e i team che usano dati locali e mirati vedono tassi di conversione fino a 8 volte più alti rispetto a chi si affida a liste fredde generiche (). Uno studio sulla lead generation per franchising ha rilevato 15 dollari di nuovo fatturato per ogni dollaro speso in liste lead basate su Google Maps.

Come collegare gli obiettivi di business ai campi di Google Maps:

Configurare il tuo estrattore Python per Google Maps: strumenti e requisiti

Prima di iniziare l’estrazione, devi configurare l’ambiente Python e procurarti gli strumenti giusti. Ecco cosa ti serve nel 2026:

1. Installa Python e le librerie necessarie

Versione Python consigliata: 3.10 o successiva.

Installa le librerie chiave:

1pip install \
2  requests==2.33.1 httpx==0.28.1 \
3  beautifulsoup4==4.14.3 lxml==6.0.3 \
4  pandas==2.3.3 \
5  selenium==4.43.0 playwright==1.58.0 \
6  googlemaps==4.10.0 google-maps-places==0.8.0 \
7  schedule==1.2.2 APScheduler==3.11.2 \
8  python-dotenv==1.2.2 tenacity==9.1.4
9playwright install chromium

A cosa servono:

• requests, httpx: richieste HTTP (chiamate API)
• beautifulsoup4, lxml: parsing HTML (per il web scraping)
• pandas: pulizia, analisi ed esportazione dei dati
• selenium, playwright: automazione del browser (per scraping HTML)
• googlemaps, google-maps-places: client API di Google Maps
• schedule, APScheduler: pianificazione delle attività
• python-dotenv: carica in modo sicuro le API key dai file .env
• tenacity: logica di retry per la gestione degli errori

2. Ottieni una chiave API di Google Maps (per lo scraping basato su API)

• Vai su .
• Crea o seleziona un progetto.
• Abilita la fatturazione (obbligatoria, anche per l’uso nel free tier).
• Abilita “Places API (New)” in APIs & Services > Library.
• Vai su Credentials > Create Credentials > API Key.
• Limita la chiave ad API e IP specifici per maggiore sicurezza.
• Conserva la chiave API in un file .env (non inserirla mai nel codice):

1GOOGLE_MAPS_API_KEY=la_tua_chiave_api_reale_qui

Nota: da marzo 2025, Google non offre più un credito universale gratuito di 200 dollari al mese. Al suo posto, prevede soglie mensili gratuite per ogni tier API (vedi ).

Come estrarre dati da Google Maps con Python: guida passo passo

Vediamo nel dettaglio i due approcci principali — basato su API e scraping HTML — così potrai scegliere quello più adatto alle tue esigenze.

Approccio 1: usare la Google Maps Places API (consigliato)

Passo 1: installa e importa le librerie necessarie

1import os
2import httpx
3import pandas as pd
4from dotenv import load_dotenv

Passo 2: carica la chiave API in modo sicuro

1load_dotenv()
2API_KEY = os.environ["GOOGLE_MAPS_API_KEY"]

Passo 3: costruisci la query di ricerca

Userai l’endpoint Text Search per trovare le attività che corrispondono ai tuoi criteri.

1URL = "https://places.googleapis.com/v1/places:searchText"
2FIELD_MASK = ",".join([
3    "places.id", "places.displayName", "places.formattedAddress",
4    "places.location", "places.rating", "places.userRatingCount",
5    "places.priceLevel", "places.types",
6    "places.nationalPhoneNumber", "places.websiteUri",
7    "nextPageToken",
8])

Passo 4: invia la richiesta API

1def text_search(query, lat, lng, radius=3000, min_rating=4.0):
2    body = {
3        "textQuery": query,
4        "minRating": min_rating,  # filtro lato server
5        "includedType": "restaurant",
6        "openNow": False,
7        "pageSize": 20,
8        "locationBias": {
9            "circle": {
10                "center": {"latitude": lat, "longitude": lng},
11                "radius": radius,
12            }
13        },
14    }
15    headers = {
16        "Content-Type": "application/json",
17        "X-Goog-Api-Key": API_KEY,
18        "X-Goog-FieldMask": FIELD_MASK,  # Impostalo sempre!
19    }
20    r = httpx.post(URL, json=body, headers=headers, timeout=30)
21    r.raise_for_status()
22    return r.json()

Passo 5: gestisci la paginazione e raccogli i risultati

1def collect_all_results(query, lat, lng, radius=3000, min_rating=4.0):
2    results = []
3    next_page_token = None
4    while True:
5        data = text_search(query, lat, lng, radius, min_rating)
6        places = data.get('places', [])
7        results.extend(places)
8        next_page_token = data.get('nextPageToken')
9        if not next_page_token:
10            break
11    return results

Passo 6: esporta i dati con Pandas

1df = pd.DataFrame(collect_all_results("coffee shops in Brooklyn", 40.6782, -73.9442))
2df.to_csv("brooklyn_coffee_shops.csv", index=False)

Suggerimenti pratici:

• Imposta sempre l’header X-Goog-FieldMask per controllare i costi. Se richiedi recensioni o foto, il prezzo per 1.000 richieste può salire da 5 a 25 dollari ().
• Usa filtri lato server (come minRating, includedType, locationBias) per non sprecare crediti su risultati irrilevanti.
• Memorizza i valori di place_id per deduplicare i dati e aggiornarli facilmente in futuro.

Approccio 2: scraping HTML di Google Maps (per uso educativo o occasionale)

Attenzione: Google Maps è una single-page app. Devi usare l’automazione del browser (Playwright o Selenium) e lo scraping dell’HTML può violare i termini di Google. Usalo per ricerca, non in produzione.

Passo 1: installa Playwright e avvia un browser

1from playwright.sync_api import sync_playwright
2import time, re
3def scrape_maps(query, max_results=100):
4    with sync_playwright() as pw:
5        browser = pw.chromium.launch(headless=True)
6        ctx = browser.new_context(
7            user_agent="Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
8            locale="en-US",
9        )
10        page = ctx.new_page()
11        page.goto("https://www.google.com/maps", timeout=60_000)
12        page.fill("#searchboxinput", query)
13        page.click('button[aria-label="Search"]')
14        page.wait_for_selector('div[role="feed"]')
15        feed = page.locator('div[role="feed"]')
16        prev = 0
17        while True:
18            feed.evaluate("el => el.scrollBy(0, el.scrollHeight)")
19            time.sleep(2)
20            count = page.locator('div[role="feed"] > div > div[jsaction]').count()
21            if count == prev or count >= max_results:
22                break
23            prev = count
24            if page.locator("text=You've reached the end of the list").count():
25                break
26        rows = []
27        cards = page.locator('div[role="feed"] > div > div[jsaction]')
28        for i in range(cards.count()):
29            c = cards.nth(i)
30            name = c.locator("div.fontHeadlineSmall").inner_text() if c.locator("div.fontHeadlineSmall").count() else ""
31            rating_el = c.locator('span[role="img"]').first
32            raw = rating_el.get_attribute("aria-label") if rating_el.count() else ""
33            m = re.search(r"([\d.]+)\s+stars?\s+([\d,]+)\s+Reviews", raw or "")
34            rating  = float(m.group(1)) if m else None
35            reviews = int(m.group(2).replace(",", "")) if m else None
36            rows.append({"name": name, "rating": rating, "reviews": reviews})
37        browser.close()
38        return rows

Consigli:

• Google randomizza le classi CSS ogni poche settimane, quindi questo codice potrebbe richiedere aggiornamenti regolari.
• Usa ritardi simili a quelli umani ed evita di fare scraping troppo velocemente per ridurre il rischio di blocco.
• Non provare mai a bypassare CAPTCHA o il sistema SearchGuard di Google: potresti esporti a rischi legali.

Evita lo scraping cieco: come puntare con precisione ai dati che ti servono

Estrarre tutto è un modo sicuro per perdere tempo e gonfiare i dataset. Ecco come puntare solo ai dati che contano:

• Genera liste di URL mirate: usa i filtri di ricerca di Google Maps (categoria, posizione, valutazione, aperto ora) per restringere i risultati prima dello scraping.
• Usa la corrispondenza esatta delle frasi: cerca tipologie di attività o parole chiave precise (per esempio, “vegan bakery in Austin”).
• Filtri geografici: specifica città, quartiere o persino coordinate e raggio per una precisione millimetrica.
• Filtraggio lato server (API): usa minRating, includedType e locationBias nel body della richiesta API.
• Filtraggio lato client (Python): dopo l’estrazione, usa pandas per filtrare attività con valutazione superiore a 4.0, più di 50 recensioni o categorie specifiche.

Esempio: filtrare solo i ristoranti di Manhattan con valutazione superiore a 4.0

1df = pd.DataFrame(results)
2filtered = df[(df['rating'] >= 4.0) & (df['types'].apply(lambda x: 'restaurant' in x))]
3filtered.to_csv("manhattan_top_restaurants.csv", index=False)

Usare le librerie Python per organizzare ed esportare i dati di Google Maps

Una volta estratti i dati, è il momento di pulirli, analizzarli ed esportarli per il tuo team.

Pulire e strutturare i dati con Pandas

1import pandas as pd
2df = pd.read_json("brooklyn_restaurants.json")
3df = (
4    df.dropna(subset=["name", "address"])
5      .drop_duplicates(subset=["place_id"])
6      .assign(
7          name=lambda d: d["name"].str.strip(),
8          phone=lambda d: d["phone"].astype(str)
9              .str.replace(r"\D", "", regex=True)
10              .str.replace(r"^1?(\d{10})$", r"+1\1", regex=True),
11          rating=lambda d: pd.to_numeric(d["rating"], errors="coerce"),
12          user_ratings_total=lambda d: pd.to_numeric(
13              d["user_ratings_total"], errors="coerce"
14          ).fillna(0).astype("int32"),
15      )
16)

Analizzare e riassumere i dati

Esempio: valutazione media per quartiere

1by_neighborhood = (
2    df.groupby("neighborhood", as_index=False)
3      .agg(avg_rating=("rating", "mean"),
4           n_places=("place_id", "nunique"),
5           median_reviews=("user_ratings_total", "median"))
6      .sort_values("avg_rating", ascending=False)
7)

Esportare in Excel o CSV

1df.to_csv("brooklyn_top.csv", index=False)
2df.to_excel("brooklyn_top.xlsx", index=False, sheet_name="Top Rated")

Hai dataset grandi? Usa il formato Parquet per velocità ed efficienza nello spazio:

1df.to_parquet("brooklyn_top.parquet", compression="zstd")

Thunderbit: alternativa basata su AI all’estrattore Python per Google Maps

Se stai pensando: “Tutto questo setup per una semplice lista lead è troppo”, non sei l’unico. È proprio per questo che abbiamo creato : un web scraper no-code basato su AI che rende l’estrazione dei dati di Google Maps (e molto altro) semplice come pochi clic.

Perché Thunderbit?

• Nessun codice o chiavi API richiesti: apri semplicemente la , vai su Google Maps e clicca “AI Suggest Fields”.
• Rilevamento dei campi con AI: l’AI di Thunderbit legge la pagina e suggerisce le colonne giuste — nome, indirizzo, valutazione, telefono, sito web e altro ancora.
• Scraping delle sottopagine: vuoi arricchire la tua tabella con dati dal sito di ogni attività? Thunderbit può visitare ogni sottopagina ed estrarre automaticamente informazioni extra.
• Esporta in Excel, Google Sheets, Airtable o Notion: niente più lavori complessi con pandas — basta cliccare “Export” e i dati sono pronti per il team.
• Scraping pianificato: imposta job ricorrenti per monitorare i concorrenti o aggiornare automaticamente la tua lista lead.
• Manutenzione zero: l’AI di Thunderbit si adatta ai cambiamenti del sito, quindi non devi continuare a correggere script rotti.

Thunderbit vs workflow Python:

Bonus: Thunderbit è utilizzato da oltre , e il piano gratuito consente di estrarre fino a 6 pagine (o 10 con il boost di prova) senza costi.

Restare conformi: termini di servizio di Google Maps ed etica dello scraping

Qui è dove molti tutorial Python diventano pericolosamente obsoleti. Ecco cosa devi sapere nel 2026:

• I Termini della piattaforma Google Maps §3.2.3 vietano esplicitamente lo scraping, il caching o l’esportazione dei dati al di fuori delle API ufficiali (). L’unica eccezione: i valori di latitudine/longitudine possono essere memorizzati per un massimo di 30 giorni; i Place ID possono essere conservati indefinitamente.
• Gli utenti API sono vincolati da contratto: se usi una chiave API, hai accettato i termini di Google, anche se stai estraendo solo dati pubblici.
• Aggirare le barriere tecniche (CAPTCHA, SearchGuard) può costituire una violazione del DMCA §1201, con possibili sanzioni penali ().
• GDPR e leggi sulla privacy: se raccogli dati personali (email, numeri di telefono, nomi dei recensori) da Google Maps, devi avere una base giuridica e rispettare le richieste di cancellazione. La CNIL francese ha multato KASPR di 200.000 euro nel 2024 per aver estratto contatti da LinkedIn ().
• Buone pratiche:
  • Usa di default la Places API quando possibile.
  • Limita la frequenza delle richieste (≤10 QPS per l’API, 1–2 richieste/s per lo scraping HTML).
  • Non bypassare mai CAPTCHA o blocchi tecnici.
  • Non ridistribuire dati personali estratti.
  • Rispetta le richieste di opt-out e cancellazione.
  • Verifica sempre le leggi locali: GDPR, CCPA e altre sono applicate attivamente.

In sintesi: se la conformità è una preoccupazione, affidati all’API e riduci al minimo i dati raccolti. Per la maggior parte degli utenti business, uno strumento no-code come Thunderbit riduce il rischio (nessuna API key, nessuna redistribuzione).

Pianificare e automatizzare lo scraping di Google Maps con Python

Se devi mantenere i dati aggiornati — per esempio per monitorare i concorrenti ogni settimana o aggiornare la lista lead ogni mese — l’automazione è la tua alleata.

Pianificazione semplice con schedule

1import schedule, time
2from my_scraper import run_job
3schedule.every().day.at("03:00").do(run_job, query="restaurants in Brooklyn")
4schedule.every(6).hours.do(run_job, query="coffee shops in Manhattan")
5while True:
6    schedule.run_pending()
7    time.sleep(30)

Pianificazione di livello produttivo con APScheduler

1from apscheduler.schedulers.background import BackgroundScheduler
2from apscheduler.triggers.cron import CronTrigger
3sched = BackgroundScheduler(timezone="America/New_York")
4sched.add_job(
5    run_job,
6    CronTrigger(hour=3, minute=15, jitter=600),  # 3:15 AM ± 10 min
7    kwargs={"query": "restaurants in Brooklyn"},
8    id="brooklyn_daily",
9    max_instances=1,
10    coalesce=True,
11    misfire_grace_time=3600,
12)
13sched.start()

Suggerimenti per un’automazione sicura

• Aggiungi jitter casuale alla pianificazione per evitare pattern prevedibili.
• Per lo scraping HTML, non superare mai 1–2 richieste al secondo.
• Per l’uso dell’API, monitora la quota e imposta avvisi di fatturazione.
• Registra sempre gli errori e mantieni un file “dead-letter” per le richieste fallite.

Bonus Thunderbit: con Thunderbit puoi pianificare scraping ricorrenti direttamente nell’interfaccia — niente codice, niente cron job, niente configurazione server.

Punti chiave: estrazione dati di Google Maps efficiente, mirata e conforme

Ricapitoliamo gli elementi essenziali:

• Google Maps è la fonte n. 1 per i dati di localizzazione delle attività, e alimenta tutto: dalla lead generation alla ricerca di mercato.
• Lo scraping con Python offre flessibilità e controllo, ma comporta costi di setup, manutenzione e conformità — soprattutto con l’inasprimento delle misure anti-bot e dei controlli legali di Google.
• L’estrazione basata su API è la strada più sicura e scalabile per la maggior parte dei team. Usa sempre field mask e filtri lato server per controllare i costi.
• Lo scraping HTML è fragile e rischioso: usalo solo per ricerche una tantum e non aggirare mai barriere tecniche.
• Punta ai dati giusti: usa corrispondenza per frasi, filtri geografici e workflow con pandas per estrarre solo ciò che ti serve.
• Thunderbit è il percorso più veloce per chi non programma: basato su AI, nessuna configurazione, esportazione immediata e pianificazione integrata.
• La conformità conta: rispetta i termini di Google, le leggi sulla privacy e i limiti di frequenza per evitare grattacapi legali.

Per altri tutorial e consigli, dai un’occhiata al e al nostro .

FAQ

1. È legale estrarre dati da Google Maps con Python nel 2026?

L’estrazione di dati da Google Maps tramite l’API ufficiale è consentita nei limiti dei termini di Google, purché si rispettino le quote e non si ridistribuiscano dati soggetti a restrizioni. Lo scraping HTML di Google Maps è esplicitamente vietato dai termini di servizio di Google e comporta rischi legali, soprattutto se si aggirano barriere tecniche o si raccolgono dati personali senza consenso. Controlla sempre le leggi locali (GDPR, CCPA, ecc.) e segui le best practice di conformità.

2. Qual è la differenza tra usare la Google Maps API e fare web scraping dell’HTML?

L’API è stabile, autorizzata e progettata per l’estrazione di dati, ma richiede una chiave API ed è soggetta a quote e costi. Lo scraping HTML usa l’automazione del browser per estrarre dati dalla pagina renderizzata, ma è fragile (il sito cambia spesso), può violare i termini ed è più rischioso dal punto di vista legale. Per la maggior parte degli usi business, l’API è il percorso consigliato.

3. Quanto costa estrarre dati da Google Maps con Python nel 2026?

Il prezzo della Places API di Google è calcolato per 1.000 richieste e varia da 5 dollari (Essentials) a 25 dollari (Enterprise+Atmosphere), in base ai campi richiesti. Esistono soglie mensili gratuite (10.000 per Essentials, 5.000 per Pro, 1.000 per Enterprise), ma lo scraping su larga scala può diventare costoso rapidamente. Usa sempre field mask e filtri lato server per controllare i costi.

4. Come si confronta Thunderbit con gli scraper Python per Google Maps?

Thunderbit è uno scraper web no-code basato su AI che ti permette di estrarre dati da Google Maps (e molto altro) senza programmazione, chiavi API o manutenzione. È ideale per i team sales e marketing che vogliono esportazioni rapide e affidabili in Excel, Google Sheets, Airtable o Notion. Per utenti tecnici che hanno bisogno di logica personalizzata, Python offre più flessibilità ma richiede più setup e più attenzione alla conformità.

5. Come posso automatizzare estrazioni ricorrenti da Google Maps?

Con Python, usa librerie di scheduling come schedule o APScheduler per eseguire il tuo estrattore a intervalli stabiliti (giornalieri, settimanali, ecc.). Aggiungi jitter casuale per evitare di essere rilevato e monitora la quota API. Con Thunderbit, puoi pianificare scraping ricorrenti direttamente nell’interfaccia, senza codice né configurazione server.

Pronto a trasformare Google Maps nel tuo superpotere per sales e marketing? Che tu sia appassionato di Python o voglia la soluzione no-code più veloce, nel 2026 hai già tutti gli strumenti a disposizione. Prova per uno scraping istantaneo basato su AI — oppure rimboccati le maniche e tuffati nell’API. In ogni caso, che le tue liste lead siano sempre aggiornate, le esportazioni pulite e le campagne piene di prospect locali ad alta conversione. Buon scraping!

Scopri di più