A présent que votre projet est prêt, et que vous avez pu tester l’accès à votre clé API, vous allez pouvoir envoyer vos premières requêtes à l’API Google Maps Places (version New) via le point d’entrée searchText.

L’objectif est de récupérer des informations structurées sur des lieux professionnels en fonction d’un mot-clé, d’une zone géographique, et d’en extraire les champs les plus pertinents pour votre CRM.

1. Quels champs peut-on récupérer avec l’API Places ?

L’API renvoie une grande variété d’informations. En voici une sélection utile (et disponible via le champ places dans la réponse JSON) :

💡 Par défaut, vous ne recevez pas tous ces champs. Il faut les spécifier avec précision dans l’en-tête « X-Goog-FieldMask » . Pour connaître les champs disponnibles exactes n’hésitez pas à consulter la documentation offcielle .

2. Exemple de requête searchText avec l’API Places (New)

L’endpoint searchText , comme son nom l’indique , permet d’effectuer une recherche textuel en limitant les réponses sur une zone géographique donnée. Ainsi en modifiant le fichier main.py on pourra par exemple avoir :

from dotenv import load_dotenv
import os
import requests

# Charger la clé API
load_dotenv()
API_KEY = os.getenv("GOOGLE_MAPS_API_KEY")

# Liste des champs à récupérer
FIELDS = [
    "places.displayName.text",
    "places.formattedAddress",
    "places.location.latitude",
    "places.location.longitude",
    "places.primaryType",
    "places.websiteUri",
    "places.nationalPhoneNumber",
    "places.businessStatus",
    "places.googleMapsUri"
]

# Fonction pour effectuer une requête
def search_places(query, location_bias=None):
    url = "https://places.googleapis.com/v1/places:searchText"

    headers = {
        "Content-Type": "application/json",
        "X-Goog-Api-Key": API_KEY,
        "X-Goog-FieldMask": ",".join(FIELDS)
    }

    data = {
        "textQuery": query,
    }

    if location_bias:
        data["locationBias"] = {
            "circle": {
                "center": {
                    "latitude": location_bias["lat"],
                    "longitude": location_bias["lng"]
                },
                "radius": location_bias["radius"]
            }
        }

    response = requests.post(url, headers=headers, json=data)

    if response.status_code == 200:
        results = response.json().get("places", [])
        return results
    else:
        print("Erreur lors de l’appel API :", response.status_code, response.text)
        return []

# Exemple d’utilisation
if __name__ == "__main__":
    query = "coiffeur"
    location = {"lat": 45.75, "lng": 4.85, "radius": 5000}  # 5 km autour de Lyon

    results = search_places(query, location)

    for place in results:
        print("-" * 40)
        print("Nom :", place.get("displayName", {}).get("text"))
        print("Adresse :", place.get("formattedAddress"))
        print("Téléphone :", place.get("nationalPhoneNumber"))
        print("Site web :", place.get("websiteUri"))

📝 Ce que fait ce code :

1. Charge la clé API depuis le fichier .env
   
2. Envoie une requête POST à l’API searchText avec un mot-clé (ex. : “coiffeur”)
   
3. Applique un filtre géographique (ici : 5 km autour de Lyon).
   
4. Affiche les informations essentielles pour chaque lieu trouvé

Cependant on se rend compte de quelques limites de celle ci. En effet :

• Les requêtes utilisant searchText ne renvoient au maximum que 20 lieux par requêtes
  
• Pour élargir la recherche , il ne faut pas interroger des zones trop large en une seule requête mais multiplier les requêtes sur des zones géographiques plus fines ou différentes
  
• Les données trouvées ne sont pour l’instant pas stockées
  

3. Stratégie pour couvrir toute l’Île-de-France

A présent que nous avons mis en avant les limites de cette première version, je vous propose de rentrer dans le vif du sujet en prenant le cas concret de la région Ile-de-France. L’idée sera donc de segmenter la recherche par département et pour se faire, deux petites notions s’imposent :

• Pour segmenter les zones avec google Maps Places , vous avez le choix entre 2 propriétés : « locationBias » et « locationRestriction »
  
  • locationBias (biais de zone autour d’un point GPS) est idéal Idéal pour des recherches localisées autour d’un point, par exemple dans un rayon de 5 km
    

"locationBias": {
    "circle": {
        "center": {"latitude": 48.8566, "longitude": 2.3522},
        "radius": 5000
    }
}

• • locationRestriction (zone stricte, recommandée pour découper une région) utile si vous voulez segmenter l’Île-de-France en plusieurs zones précises.
    

"locationRestriction": {
    "rectangle": {
        "low": {"latitude": 48.6, "longitude": 2.1},
        "high": {"latitude": 48.9, "longitude": 2.45}
    }
}

• Le deuxième point n’est pas strictement documenté pour Places API (New) via searchText mais Google applique des quotas par minute et par seconde par projet et par IP du nombre de requête qu’un utilisateur peut envoyer. Plus loin ils se réservent le droit de rejeter ou ralentir les requêtes si tu les envoies trop vite ou en rafale.
  

On peut ainsi écrire le code suivant :

from dotenv import load_dotenv
import os
import requests

# Charger la clé API
load_dotenv()
API_KEY = os.getenv("GOOGLE_MAPS_API_KEY")

# Liste des champs à récupérer dans la réponse
FIELDS = [
    "places.displayName.text",
    "places.formattedAddress",
    "places.location.latitude",
    "places.location.longitude",
    "places.primaryType",
    "places.websiteUri",
    "places.nationalPhoneNumber",
    "places.businessStatus",
    "places.googleMapsUri"
]

# Coordonnées rectangulaires approximatives des départements d’Île-de-France
departements_idf = [
    {
        "name": "75 - Paris",
        "low": {"lat": 48.82, "lng": 2.25},
        "high": {"lat": 48.90, "lng": 2.42}
    },
    {
        "name": "92 - Hauts-de-Seine",
        "low": {"lat": 48.77, "lng": 2.15},
        "high": {"lat": 48.95, "lng": 2.33}
    },
    {
        "name": "93 - Seine-Saint-Denis",
        "low": {"lat": 48.88, "lng": 2.35},
        "high": {"lat": 48.97, "lng": 2.52}
    },
    {
        "name": "94 - Val-de-Marne",
        "low": {"lat": 48.73, "lng": 2.39},
        "high": {"lat": 48.82, "lng": 2.53}
    },
    {
        "name": "91 - Essonne",
        "low": {"lat": 48.35, "lng": 2.00},
        "high": {"lat": 48.62, "lng": 2.45}
    },
    {
        "name": "95 - Val-d’Oise",
        "low": {"lat": 48.95, "lng": 1.90},
        "high": {"lat": 49.20, "lng": 2.45}
    },
    {
        "name": "77 - Seine-et-Marne",
        "low": {"lat": 48.40, "lng": 2.45},
        "high": {"lat": 48.90, "lng": 3.40}
    },
    {
        "name": "78 - Yvelines",
        "low": {"lat": 48.65, "lng": 1.50},
        "high": {"lat": 48.90, "lng": 2.10}
    }
]

# Fonction pour interroger l’API Google Places
def search_places(query, rectangle):
    url = "https://places.googleapis.com/v1/places:searchText"

    headers = {
        "Content-Type": "application/json",
        "X-Goog-Api-Key": API_KEY,
        "X-Goog-FieldMask": ",".join(FIELDS)
    }

    data = {
        "textQuery": query,
        "locationRestriction": {
            "rectangle": {
                "low": {
                    "latitude": rectangle["low"]["lat"],
                    "longitude": rectangle["low"]["lng"]
                },
                "high": {
                    "latitude": rectangle["high"]["lat"],
                    "longitude": rectangle["high"]["lng"]
                }
            }
        }
    }

    response = requests.post(url, headers=headers, json=data)

    if response.status_code == 200:
        results = response.json().get("places", [])
        return results
    else:
        print(f"Erreur lors de l’appel API : {response.status_code} - {response.text}")
        return []

# Collecter les résultats pour chaque département d’Île-de-France
def collect_places_by_region(query):
    all_results = []

    for dep in departements_idf:
        print(f"📍 Recherche dans {dep['name']}...")
        results = search_places(query, dep)
        for place in results:
            all_results.append({
                "departement": dep["name"],
                "name": place.get("displayName", {}).get("text"),
                "address": place.get("formattedAddress"),
                "latitude": place.get("location", {}).get("latitude"),
                "longitude": place.get("location", {}).get("longitude"),
                "industry": place.get("primaryType"),
                "website": place.get("websiteUri"),
                "phone": place.get("nationalPhoneNumber"),
                "lifecycle_stage": place.get("businessStatus"),
                "googleMapsUri": place.get("googleMapsUri")
            })

    time.sleep(1)  # Respect du quota API

 return all_results

# Exemple d’utilisation
if __name__ == "__main__":
    mot_cle = "coiffeur"
    donnees = collect_places_by_region(mot_cle)

    print(f"\n✅ Total d'établissements trouvés : {len(donnees)}")
    for d in donnees[:3]:  # aperçu rapide
        print(d)

Dans cette version améliorée du script, nous avons mis en place une structure modulaire avec deux fonctions principales pour interagir proprement avec l’API Google Maps Places :

• La première , la fonction « search_places() » est dédiée à l’interrogation de l’API :
  
  • Elle utilise le paramètre locationRestriction, qui permet de définir une zone géographique précise sous forme de rectangle (délimité par une latitude/longitude basse et haute). Cela permet de cibler précisément chaque département d’Île-de-France sans risque de débordement hors zone, contrairement à l’approche précédente avec un simple cercle (locationBias).
    
  • Elle gère également les en-têtes et le formatage des champs à récupérer, avec X-Goog-FieldMask, pour ne renvoyer que les données utiles (nom, adresse, téléphone, etc.).
    
• La seconde, la fonction « collect_places_by_region() » parcourt les différents départements de la région parisienne.
  
  • Pour chacun, elle appelle search_places() avec les coordonnées géographiques de la zone concernée, puis stocke les données récupérées dans une liste de dictionnaires Python bien structurée.
    
  • Chaque entrée peut être enrichie avec des champs standardisés (comme name, address, phone, etc.) du CRM utilisé (ici HubSpot) , ce qui facilitera leur intégration.