Extraire des données de Google Maps avec JavaScript : Guide complet

Google Maps contient 50M+ fiches commerciales. Chaque fiche = adresse, téléphone, avis, horaires, photos, site web. C'est une mine d'or pour la prospection, l'étude de marché, l'analyse concurrentielle.

Mais comment extraire ces données à l'échelle ? Trois approches existent : l'API Google Maps officielle, le web scraping JavaScript custom, ou un outil dédié. Cet article couvre toutes les trois — avec leurs coûts réels, limites, et quand utiliser chacune.

---

Pourquoi extraire des données de Google Maps ?

Avant d'entrer dans la technique, clarifiez votre besoin. Les cas d'usage ne sont pas les mêmes.

Prospection commerciale

Une agence de nettoyage veut trouver 500 restaurants dans un rayon de 10 km. Elle exporte : nom, adresse, téléphone, email. Elle fait du cold calling ciblé.

Besoin : données de base (nom, contact), rapidité, volume moyen.

Analyse concurrentielle

Un restaurateur analyse 50 restaurants concurrents : avis Google, nombre d'avis, horaires, prix (via le site web), photos, technologies utilisées (ils utilisent Uber Eats ? Deliveroo ? Leur propre site ?).

Besoin : données enrichies (avis, tech stack), contexte, volume faible à moyen.

Étude de marché

Un franchiseur analyse 1,000+ coiffeurs en France pour identifier les zones sous-servies. Il extrait : localisation, note Google, nombre d'avis, horaires, fiche claimed ou non.

Besoin : données structurées, filtrage avancé, volume élevé, mise à jour mensuelle.

Détection de leads qualifiés

Une agence SEO cherche des restaurants avec note < 3 étoiles (clients potentiels insatisfaits). Elle exporte ceux avec 50+ avis (taille significative) et site web sans Google Analytics.

Besoin : avis Google (texte + note + date), détection de technologies, filtres complexes, volume moyen.

Chaque cas d'usage implique une approche différente. Voyons les options.

---

Option 1 : L'API Google Maps JavaScript officielle

Google propose une API JavaScript gratuite (avec quotas). Elle fonctionne dans le navigateur ou en Node.js côté serveur.

Fonctionnalités de base

L'API Google Maps JavaScript permet 3 choses principales :

1. Geocoding : convertir une adresse → coordonnées GPS
2. Places API : chercher des lieux (restaurants, plombiers, etc.) autour d'une position
3. Place Details : récupérer les infos détaillées d'un lieu (avis, horaires, photos, URL, etc.)

Étape 1 : Obtenir une clé API

1. Allez sur Google Cloud Console
2. Créez un projet
3. Activez ces APIs : - Maps JavaScript API - Places API - Geocoding API
4. Créez une clé API (type : clé de navigateur ou serveur selon votre usage)
5. Configurez les restrictions (domaines autorisés, quotas)

Important : Google facture au-delà des quotas gratuits. Par défaut : 25,000 appels/jour gratuits pour Places, puis €0.017 par appel.

Étape 2 : Implémenter le Geocoding

Convertir une adresse en latitude/longitude.

const geocoder = new google.maps.Geocoder();

geocoder.geocode(
  { address: '75 Rue de Rivoli, Paris' },
  (results, status) => {
    if (status === 'OK') {
      const lat = results[0].geometry.location.lat();
      const lng = results[0].geometry.location.lng();
      console.log(`Coordonnées : ${lat}, ${lng}`);
    } else {
      console.error(`Erreur : ${status}`);
    }
  }
);

Étape 3 : Chercher des lieux proches (Nearby Search)

Trouver tous les restaurants dans un rayon de 5 km autour de Paris.

const map = new google.maps.Map(document.getElementById('map'), {
  center: { lat: 48.8566, lng: 2.3522 }, // Paris
  zoom: 15
});

const service = new google.maps.places.PlacesService(map);

const request = {
  location: new google.maps.LatLng(48.8566, 2.3522),
  radius: 5000, // 5 km
  type: 'restaurant',
  keyword: 'pizza' // Optionnel : filtrer par mot-clé
};

service.nearbySearch(request, (results, status) => {
  if (status === google.maps.places.PlacesServiceStatus.OK) {
    results.forEach(place => {
      console.log(`${place.name} - ${place.vicinity}`);
    });
  }
});

Limitation importante : nearbySearch() retourne max 60 résultats par requête, avec pagination. Pour avoir 500 restaurants, vous devez faire 9 requêtes.

Étape 4 : Récupérer les détails complets (Place Details)

Chaque lieu retourné par nearbySearch() a un place_id. Utilisez-le pour obtenir les détails complets.

const request = {
  placeId: 'ChIJIQBpAG2ahYAR_6128GltTXQ', // Exemple : Eiffel Tower
  fields: [
    'name',
    'formatted_address',
    'formatted_phone_number',
    'website',
    'opening_hours',
    'reviews',
    'rating',
    'user_ratings_total',
    'photos'
  ]
};

service.getDetails(request, (place, status) => {
  if (status === google.maps.places.PlacesServiceStatus.OK) {
    console.log(`Nom : ${place.name}`);
    console.log(`Adresse : ${place.formatted_address}`);
    console.log(`Téléphone : ${place.formatted_phone_number}`);
    console.log(`Site web : ${place.website}`);
    console.log(`Note : ${place.rating} (${place.user_ratings_total} avis)`);
    console.log(`Horaires :`, place.opening_hours.weekday_text);

    // Avis Google
    place.reviews.forEach(review => {
      console.log(`${review.author_name} : ${review.rating}/5 - "${review.text}"`);
    });
  }
});

Coûts réels de l'API Google Maps

Opération	Quota gratuit	Prix au-delà
Geocoding	25,000/jour	€0.005 par appel
Nearby Search	25,000/jour	€0.032 par appel
Place Details	25,000/jour	€0.017 par appel
Text Search	25,000/jour	€0.032 par appel

Exemple réel : extraire 1,000 restaurants avec détails complets.

• 1,000 Nearby Search = 17 appels (60 résultats/appel max) = €0.54
• 1,000 Place Details = €17

Total : ~€17.50 pour 1,000 restaurants.

Ça semble peu, mais : - Vous devez le refaire chaque mois pour les mises à jour - Vous êtes limité à 60 résultats par requête (lourd à paginer) - Les avis Google retournés sont limités (max 5 par lieu) - Vous n'obtenez pas les technologies détectées (WordPress, Shopify, etc.)

Limites de l'API Google Maps JavaScript

Limitation	Impact
Max 60 résultats par requête	Pagination manuelle complexe
Max 5 avis par lieu	Pas d'analyse complète des avis
Pas de filtrage par note Google	Vous récupérez tous les résultats
Pas de filtrage par nombre d'avis	Pas de ciblage sur les fiches "matures"
Pas de détection de technologies	Vous ne savez pas si le site utilise WordPress, Shopify, etc.
Pas de données SIRET (France)	Pas d'enrichissement juridique/financier
Quotas limités	Coûts qui montent vite à grande échelle

---

Option 2 : Web scraping JavaScript custom avec Puppeteer

Si vous voulez contourner les limites de l'API officielle, vous pouvez scraper directement le site Google Maps avec Puppeteer (une librairie Node.js qui automatise un navigateur Chrome).

Pourquoi Puppeteer ?

Puppeteer lance un navigateur Chrome automatisé, va sur Google Maps, simule des clics/scrolls, et extrait le HTML. Vous pouvez ainsi récupérer plus de 60 résultats, les avis complets, les photos, etc.

Installation

npm install puppeteer

Exemple : Scraper les restaurants de Paris

const puppeteer = require('puppeteer');

(async () => {
  const browser = await puppeteer.launch();
  const page = await browser.newPage();

  // Aller sur Google Maps
  await page.goto('https://www.google.com/maps/search/restaurants+paris', {
    waitUntil: 'networkidle2'
  });

  // Attendre le chargement des résultats
  await page.waitForSelector('[role="listitem"]');

  // Scroller pour charger plus de résultats
  const resultsContainer = await page.$('[role="main"]');
  for (let i = 0; i < 5; i++) {
    await resultsContainer.evaluate(el => {
      el.scrollTop = el.scrollHeight;
    });
    await page.waitForTimeout(1000); // Attendre le chargement
  }

  // Extraire les données
  const restaurants = await page.evaluate(() => {
    const items = document.querySelectorAll('[role="listitem"]');
    return Array.from(items).map(item => {
      const nameEl = item.querySelector('[role="heading"]');
      const ratingEl = item.querySelector('[aria-label*="étoile"]');
      const addressEl = item.querySelector('[data-item-id*="address"]');

      return {
        name: nameEl ? nameEl.textContent : 'N/A',
        rating: ratingEl ? ratingEl.getAttribute('aria-label') : 'N/A',
        address: addressEl ? addressEl.textContent : 'N/A'
      };
    });
  });

  console.log(restaurants);

  await browser.close();
})();

Problèmes avec cette approche

1. Google bloque rapidement : Après 10-20 requêtes, Google détecte le scraping et vous demande de confirmer que vous n'êtes pas un robot (CAPTCHA).

2. Maintenance constante : Google change son HTML régulièrement. Votre code casse tous les 2-3 mois.

3. Lent : Puppeteer doit lancer un navigateur complet pour chaque recherche. Scraper 10,000 restaurants = 10,000 navigateurs lancés = heures d'exécution.

4. Coûteux en ressources : Chaque navigateur consomme 100-200 MB de RAM. Scraper en parallèle = serveur puissant requis.

5. Contre les conditions d'utilisation : Google interdit explicitement le scraping de Maps.

Verdict : Puppeteer fonctionne pour des tests ponctuels (50-100 résultats), pas pour une extraction à l'échelle.

---

Option 3 : Utiliser un outil dédié (pas de code)

C'est la solution la plus pragmatique pour 95% des cas d'usage. Au lieu de coder, vous utilisez un outil qui :

• Gère l'extraction à l'échelle
• Contourne les blocages Google
• Retourne les données structurées (CSV, JSON, API)
• Inclut les avis Google complets
• Détecte les technologies utilisées
• Met à jour les données mensuellement

Pourquoi un outil dédié ?

Critère	API Google	Puppeteer	Outil dédié
Coût pour 10,000 résultats	€170+	Gratuit (mais lent)	€44-99/mois
Temps pour 10,000 résultats	2-3 jours (quotas)	4-6 heures	5 minutes
Avis Google complets	Max 5 par lieu	Oui	Oui
Filtrage par note Google	Non	Non	Oui
Détection technologies	Non	Non	Oui
Maintenance	Élevée (API changes)	Élevée (HTML changes)	Zéro
Blocage Google	Rare	Fréquent	Jamais

---

Cas d'usage pratiques avec JavaScript

Voici 3 scénarios réels et comment les implémenter.

Cas 1 : Chercher 50 plombiers à Lyon avec l'API Google Maps

Besoin : nom, adresse, téléphone, site web, note. Volume faible. Budget limité.

Solution : API Google Maps officielle.

async function findPlumbers(city, limit = 50) {
  const geocoder = new google.maps.Geocoder();

  // Géocoder la ville
  const cityCoords = await new Promise((resolve) => {
    geocoder.geocode({ address: city }, (results) => {
      resolve(results[0].geometry.location);
    });
  });

  const map = new google.maps.Map(document.getElementById('map'), {
    center: cityCoords,
    zoom: 12
  });

  const service = new google.maps.places.PlacesService(map);
  const allResults = [];

  // Faire plusieurs requêtes (max 60 par requête)
  for (let i = 0; i < Math.ceil(limit / 60); i++) {
    const results = await new Promise((resolve) => {
      service.nearbySearch(
        {
          location: cityCoords,
          radius: 15000,
          type: 'plumber',
          pageToken: i === 0 ? null : nextPageToken
        },
        (results, status, pagination) => {
          nextPageToken = pagination.nextPage ? pagination.nextPageToken : null;
          resolve(results || []);
        }
      );
    });

    allResults.push(...results);
    if (allResults.length >= limit) break;
  }

  // Récupérer les détails pour chaque résultat
  const details = await Promise.all(
    allResults.slice(0, limit).map(place => {
      return new Promise((resolve) => {
        service.getDetails(
          {
            placeId: place.place_id,
            fields: ['name', 'formatted_address', 'formatted_phone_number', 'website', 'rating']
          },
          (place) => resolve(place)
        );
      });
    })
  );

  return details.map(p => ({
    name: p.name,
    address: p.formatted_address,
    phone: p.formatted_phone_number,
    website: p.website,
    rating: p.rating
  }));
}

// Utilisation
findPlumbers('Lyon').then(plumbers => {
  console.table(plumbers);
  // Exporter en CSV
  downloadCSV(plumbers);
});

Coût : ~€0.50 (17 requêtes Nearby + 50 Place Details)

Temps : 30 secondes

Limitation : Vous ne savez pas lesquels sont claimed, combien d'avis ils ont, ou s'ils utilisent un site custom/Wix/Squarespace.

---

Cas 2 : Analyser 200 restaurants concurrents (avis, technologies)

Besoin : avis complets, note, nombre d'avis, technologies utilisées. Volume moyen. Budget moyen.

Solution : Outil dédié (l'API Google Maps ne donne que 5 avis max).

Avec un outil, vous exportez en 5 minutes :

Nom,Adresse,Note,Nombre d'avis,Avis (texte),Avis (date),Avis (auteur),Site web,Technologies détectées
Le Jules Verne,5 Rue Eiffel,4.8,1250,"Excellent rapport qualité/prix",2024-01-15,Pierre M.,lejulesverne.fr,"WordPress, WooCommerce, Google Analytics"
Septime,80 Rue Charonne,4.7,890,"Service impeccable",2024-01-14,Marie D.,septimeparis.com,"Custom, Shopify"

Vous pouvez alors : - Identifier les restaurants bien notés (4.5+) avec 500+ avis (taille significative) - Lire les avis négatifs pour identifier les points faibles des concurrents - Voir quels restaurants utilisent Shopify (ils vendent en ligne) vs WordPress (site custom)

---

Cas 3 : Prospection ABM — Trouver 500 restaurants avec site sans Google Analytics

Besoin : restaurants de taille moyenne (50-200 avis), note 3.5+, site web sans Google Analytics (lead potentiel pour agence SEO/analytics).

Solution : Outil dédié avec filtres avancés et détection de technologies.

```javascript // Pseudo-code (l'API Google Maps ne peut pas faire ça) const restaurants = await tool.search({ location: 'France', category: 'restaurant', minRating: 3.5, minReviews: 50, maxReviews: 200, hasWebsite: true, missingTechnology: 'Google Analytics' // EXCLUSIF });

// Résultat : 500 restaurants qualifiés // Vous les contactez avec : "Nous avons vu que votre site n'a