Google Maps Lead Enricher

Turn a Google Maps search query into a fully enriched, scored lead list. Google Maps Lead Enricher is a four-step orchestrator that searches Google Maps for businesses matching your query, visits every business website to extract emails, phone numbers, named contacts, and social links, detects email naming patterns to predict team member addresses, and scores each lead from 0 to 100.

Enter a query like "marketing agencies in Chicago" or "dentists in Los Angeles" and get back a flat, merged dataset where every business includes Google Maps metadata (name, address, rating, reviews, category), website-extracted contact data, predicted emails, and a quality score with letter grade -- all from a single run.

Why Use Google Maps Lead Enricher?

Manually building a lead list from Google Maps is tedious. You search for businesses, open each listing, copy the website URL, visit the site, hunt for a contact page, and repeat hundreds of times. This actor automates the entire workflow end-to-end.

Running on Apify gives you cloud-scale execution without managing infrastructure. The actor handles proxy rotation, parallelized sub-actor calls, and automatic dataset storage. Key advantages:

• Discovery + Enrichment in one run. Unlike the B2B Lead Gen Suite (which starts from URLs you already have), this actor discovers businesses via Google Maps search, then enriches them automatically.
• Multi-query support. Search for "plumbers in Austin TX" and "electricians in Dallas TX" in the same run to build a cross-category prospect list.
• Domain deduplication. When multiple Maps listings share the same website domain, the enrichment pipeline runs once per domain and attaches the results to every matching listing.
• Include businesses without websites. Optionally output Google Maps-only data for businesses that have no website, so you still get their phone numbers, addresses, and ratings.
• Graceful degradation. If any pipeline step fails, the actor continues with whatever data it has rather than aborting the entire run.

Key Features

• End-to-end automation -- From search query to scored, enriched lead list in one actor run.
• Multi-query support -- Search for multiple business types or locations in a single run.
• Deep contact extraction -- Crawls up to 20 pages per business website to find emails, phone numbers, named contacts with job titles, and social media profiles.
• Email pattern detection -- Identifies naming conventions like [email protected] and generates predicted emails for contacts found by name but not email.
• Lead scoring and grading -- Scores leads 0-100 across five dimensions and assigns A-F grades.
• Flexible pipeline -- Skip email pattern detection or lead qualification to save time and cost.
• Score filtering -- Set a minimum lead score threshold to automatically exclude low-quality leads.
• Domain deduplication -- Groups multiple Google Maps listings sharing the same website domain and merges enrichment data efficiently.
• Configurable depth -- Control how many businesses per query and how many pages per website to crawl.

How to Use

1. Set your search queries -- Enter one or more Google Maps search queries in the "Google Maps search queries" field. Use natural-language queries like you would type into Google Maps, such as "marketing agencies in Chicago" or "dentists near me in London".

2. Configure the pipeline -- Decide how many businesses per query to scrape (default: 100), how many pages per website to crawl for contacts (default: 5), and whether to include businesses that have no website.

3. Choose optional steps -- By default all four pipeline steps run. Toggle "Skip email pattern detection" or "Skip lead qualification" if you want faster, cheaper runs with fewer data fields.

4. Set score filtering -- If lead qualification is enabled, set a minimum lead score (0-100) to filter out low-quality leads automatically.

5. Run the actor -- Click "Start" and wait for the pipeline to complete. Progress is logged step-by-step in the actor log.

6. Export your leads -- Once finished, download the dataset as CSV, JSON, or Excel. Or connect to Google Sheets, Zapier, Make, or your CRM for automated delivery.

Input Parameters

Input Examples

Local service business prospecting (most common use case):

{
    "searchStringsArray": ["plumbers in Austin TX", "electricians in Austin TX"],
    "maxCrawledPlacesPerQuery": 50,
    "maxPagesPerDomain": 5,
    "minScore": 50
}

Quick discovery with contact data only (skip scoring):

{
    "searchStringsArray": ["marketing agencies in Chicago"],
    "maxCrawledPlacesPerQuery": 20,
    "skipEmailPatternFinder": true,
    "skipLeadQualifier": true
}

Comprehensive list including businesses without websites:

{
    "searchStringsArray": ["dentists in Los Angeles"],
    "maxCrawledPlacesPerQuery": 100,
    "includeBusinessesWithoutWebsite": true,
    "maxPagesPerDomain": 8
}

International search in a different language:

{
    "searchStringsArray": ["Rechtsanwälte in Berlin"],
    "language": "de",
    "maxCrawledPlacesPerQuery": 30,
    "minScore": 40
}

Input Tips

• Use specific, location-based queries -- "plumbers in Austin TX" returns better results than just "plumbers".
• Include city, state/province, or ZIP code for targeted local results.
• Set maxCrawledPlacesPerQuery to 3-5 for your first run to verify output quality and cost before scaling up.
• Set minScore to 50+ to filter out leads with thin contact information or low business legitimacy signals.
• Enable proxy (proxyConfiguration) when scraping more than 20 businesses to avoid rate limiting.

Output Example

Each lead in the dataset contains merged data from all pipeline steps:

{
    "businessName": "Acme Web Solutions",
    "searchQuery": "web development agencies in San Francisco",
    "googleMapsCategory": "Web designer",
    "googleMapsAddress": "123 Market St, San Francisco, CA 94105",
    "googleMapsPhone": "+1-415-555-0123",
    "googleMapsRating": 4.8,
    "googleMapsReviewsCount": 47,
    "googleMapsPlaceId": "ChIJ...",
    "googleMapsUrl": "https://www.google.com/maps/place/...",
    "domain": "acmewebsolutions.com",
    "url": "https://acmewebsolutions.com",
    "emails": ["[email protected]", "[email protected]"],
    "phones": ["+1-415-555-0123", "+1-415-555-0456"],
    "contacts": [
        { "name": "John Smith", "title": "CEO", "email": "[email protected]" },
        { "name": "Jane Doe", "title": "CTO" }
    ],
    "socialLinks": {
        "linkedin": "https://linkedin.com/company/acmewebsolutions",
        "twitter": "https://twitter.com/acmeweb"
    },
    "emailPattern": "{first}@{domain}",
    "emailPatternConfidence": 0.85,
    "generatedEmails": [
        { "name": "Jane Doe", "email": "[email protected]" }
    ],
    "score": 82,
    "grade": "A",
    "scoreBreakdown": {
        "contactReachability": 22,
        "businessLegitimacy": 18,
        "onlinePresence": 16,
        "websiteQuality": 14,
        "teamTransparency": 12
    },
    "signals": [
        { "signal": "Multiple emails found", "category": "contactReachability", "points": 10, "detail": "2 emails" },
        { "signal": "Named contacts with titles", "category": "teamTransparency", "points": 8, "detail": "2 contacts" }
    ],
    "address": "123 Market St, San Francisco, CA 94105",
    "cmsDetected": "WordPress",
    "techSignals": ["WordPress", "Google Analytics", "SSL"],
    "pipelineSteps": ["google-maps", "contact-scraper", "email-pattern-finder", "lead-qualifier"],
    "processedAt": "2025-01-15T14:30:00.000Z"
}

Output Fields

Programmatic Access (API)

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("ryanclinton/google-maps-lead-enricher").call(run_input={
    "searchStringsArray": ["plumbers in Austin TX", "electricians in Austin TX"],
    "maxCrawledPlacesPerQuery": 50,
    "minScore": 50,
})

for lead in client.dataset(run["defaultDatasetId"]).iterate_items():
    score = lead.get("score", "N/A")
    grade = lead.get("grade", "N/A")
    emails = ", ".join(lead.get("emails", []))
    print(f'{lead["businessName"]} [{grade} {score}] — {emails}')

JavaScript

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: "YOUR_API_TOKEN" });

const run = await client.actor("ryanclinton/google-maps-lead-enricher").call({
    searchStringsArray: ["plumbers in Austin TX", "electricians in Austin TX"],
    maxCrawledPlacesPerQuery: 50,
    minScore: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const lead of items) {
    console.log(`${lead.businessName} [${lead.grade} ${lead.score}] — ${lead.emails.join(", ")}`);
}

cURL

# Start a run
curl -X POST "https://api.apify.com/v2/acts/ryanclinton~google-maps-lead-enricher/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchStringsArray": ["plumbers in Austin TX"],
    "maxCrawledPlacesPerQuery": 50,
    "minScore": 50
  }'

# Fetch results (use defaultDatasetId from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_API_TOKEN&format=json"

How It Works — Pipeline Architecture

Google Maps Lead Enricher runs a four-step sequential pipeline. Each step calls a dedicated Apify actor via Actor.call() and passes transformed data to the next step.

                    ┌──────────────────────────────────────┐
                    │  Google Maps Lead Enricher            │
                    │  (Orchestrator)                       │
                    └──────────┬───────────────────────────┘
                               │
                    ┌──────────▼───────────────────────────┐
  Step 1 (Required) │  Google Maps Scraper                  │
                    │  (compass/crawler-google-places)       │
                    │  • Searches Maps for businesses         │
                    │  • Extracts name, address, phone,       │
                    │    rating, reviews, category, website   │
                    │  • Images & reviews DISABLED for speed  │
                    └──────────┬───────────────────────────┘
                               │ unique website URLs
                    ┌──────────▼───────────────────────────┐
  Step 2 (Graceful) │  Website Contact Scraper              │
                    │  • Crawls business websites             │
                    │  • Extracts emails, phones, contacts    │
                    │  • Discovers social media links          │
                    │  • Failure = continue with Maps data    │
                    └──────────┬───────────────────────────┘
                               │ emails + contact names
                    ┌──────────▼───────────────────────────┐
  Step 3 (Optional) │  Email Pattern Finder                 │
                    │  • Receives emails as known samples     │
                    │  • Website scraping DISABLED             │
                    │  • GitHub commit search ENABLED          │
                    │  • Detects naming convention             │
                    │  • Generates predicted emails            │
                    └──────────┬───────────────────────────┘
                               │ all upstream data
                    ┌──────────▼───────────────────────────┐
  Step 4 (Optional) │  B2B Lead Qualifier                   │
                    │  • Receives all upstream data via       │
                    │    pipelineData parameter               │
                    │  • Crawls website for quality signals    │
                    │  • Scores 0-100 across 5 categories     │
                    │  • Assigns letter grade A-F              │
                    └──────────┬───────────────────────────┘
                               │
                    ┌──────────▼───────────────────────────┐
                    │  Merge + Deduplicate + Sort + Filter   │
                    │  • One output row per Maps listing      │
                    │  • Union emails/phones across all steps  │
                    │  • Maps phone merged into phone set      │
                    │  • Sort by score (highest first)         │
                    │  • Remove leads below minScore           │
                    │  • Optionally include no-website entries │
                    └──────────────────────────────────────┘

Data Flow Details

Step 1 → Step 2 (Maps → Contact Scraper):

• extractWebsitesFromMaps() groups Maps results by domain and deduplicates, so the Contact Scraper crawls each website only once even if multiple businesses share it.
• Google Maps scraper runs with maxImages: 0, maxReviews: 0, scrapeContacts: false for maximum speed.

Step 2 → Step 3 (Contact Scraper → Pattern Finder):

• Same data flow as the B2B Lead Gen Suite: scraped emails passed as knownEmails, contact names passed as names, website scraping disabled (searchWebsite: false), GitHub search enabled.

Steps 2+3 → Step 4 (All → Lead Qualifier):

• All upstream data packaged into pipelineData array indexed by domain.
• Qualifier crawls each website independently for scoring signals.

Merge Phase:

• Creates one output row per Google Maps listing (not per domain). Multiple listings sharing a domain each get the same enrichment data.
• Emails from Steps 2 + 4 are unioned via Set.
• Phones from Maps + Steps 2 + 4 are all merged and deduplicated.
• Social links from Step 2 take priority; Step 4 fills missing platforms.
• Address uses qualifier-detected address if available, falls back to Maps address.
• Businesses without websites are optionally included with Maps-only data.

Scoring Reference

When Step 4 (Lead Qualifier) runs, each lead is scored across five categories:

Grade scale: A (90-100), B (75-89), C (60-74), D (40-59), F (0-39)

How Much Does It Cost?

This actor orchestrates multiple sub-actors, so cost depends on the pipeline configuration:

The Google Maps step and contact scraping step account for most of the cost. The Pattern Finder adds minimal overhead, and the Lead Qualifier adds moderate cost from website re-crawling.

To minimize cost: reduce maxCrawledPlacesPerQuery, lower maxPagesPerDomain, and skip optional pipeline steps when you only need basic contact data.

Apify's free tier includes $5 of monthly platform credits, enough to process approximately 100-300 businesses depending on configuration.

Tips

1. Use specific, location-based queries -- "plumbers in Austin TX" works better than just "plumbers". Include city, state, or ZIP code for targeted results.

2. Start small -- Set maxCrawledPlacesPerQuery to 3-5 for your first run to verify the output format and cost before scaling up.

3. Use score filtering strategically -- Set minScore to 50+ to focus on leads that have verified contact information, legitimate websites, and visible team members.

4. Combine multiple queries -- Search for related business types in the same run (e.g., "web designers", "digital marketing agencies", "SEO companies") to build a comprehensive prospect list.

5. Enable proxies -- Use Apify Proxy for runs with many businesses to avoid rate limiting during the contact scraping step.

6. Export to Google Sheets -- Use Apify's built-in Google Sheets integration to automatically push leads into a shared spreadsheet for your sales team.

7. Schedule recurring runs -- Set up weekly or monthly runs with the Apify Scheduler to continuously discover new businesses and keep your lead database fresh.

Limitations

• Google Maps coverage varies. Search results depend on Google Maps data for the given location and category. Some areas or niche industries may return fewer results than expected.
• HTML-only website crawling. The Contact Scraper and Lead Qualifier use CheerioCrawler (HTML parsing without a browser). Websites requiring JavaScript rendering may return incomplete contact data.
• No email verification. Discovered and generated emails are not validated for deliverability. Generated emails are pattern-based predictions. Use Bulk Email Verifier to validate before outreach.
• Sequential pipeline. Steps run one after another. The full four-step pipeline takes 3-8 minutes for 10 businesses, 20-60 minutes for 100+ businesses.
• Sub-actor dependency. The Google Maps step uses a third-party actor (compass/crawler-google-places). If it is unavailable or its output format changes, the run will fail.
• Shared domain enrichment. Multiple businesses sharing the same website domain (e.g., franchises) receive identical enrichment data. The actor does not differentiate between business locations on the same domain.
• Pattern detection needs samples. Email patterns require multiple discovered emails to be reliable. Businesses with only one email address produce low-confidence or no pattern results.

Responsible Use

This actor combines Google Maps data with website-scraped information. Follow these guidelines:

• Comply with applicable laws. Check GDPR, CAN-SPAM, CCPA, and local regulations before using collected data for outreach. Presence of contact information on a website or Google Maps listing does not constitute consent to receive marketing communications.
• Respect Google Maps Terms of Service. This actor uses the compass/crawler-google-places scraper to search Google Maps. Review Google's Terms of Service and applicable data usage policies for your jurisdiction.
• Generated emails are predictions. Emails produced by the Pattern Finder are algorithmic guesses based on detected naming conventions. They should be verified before use and should never be used for bulk unsolicited messaging.
• Use reasonable query volumes. Avoid scraping thousands of businesses in rapid succession. Use the Apify Scheduler to spread large prospecting efforts over multiple scheduled runs.

FAQ

How long does a full pipeline run take? A run with 10 businesses and the full 4-step pipeline typically completes in 3-8 minutes. Larger runs with 100+ businesses can take 20-60 minutes depending on website complexity and proxy speed. The Google Maps scraping step is usually the fastest; the contact scraping step takes the longest.

Can I use this actor for any country or language? Yes. Google Maps search queries work globally. Set the language parameter to match your target market (e.g., "de" for German, "ja" for Japanese). The contact scraper and pattern finder work with any website language, though email extraction is most effective on Latin-alphabet websites.

What happens if a sub-actor step fails? The Google Maps step is required -- if it fails, the run exits because there is no business data to enrich. All other steps (Contact Scraper, Email Pattern Finder, Lead Qualifier) fail gracefully. If any of them fails, the pipeline continues with whatever data it has already collected, and partial failures are logged as warnings.

How is the lead score calculated? The B2B Lead Qualifier scores each business from 0 to 100 across five weighted categories: Contact Reachability (max 30 pts), Business Legitimacy (max 25 pts), Online Presence (max 20 pts), Website Quality (max 15 pts), and Team Transparency (max 10 pts). Each category awards points based on specific signals detected on the website.

What is the difference between this actor and the B2B Lead Gen Suite? The B2B Lead Gen Suite starts from a list of website URLs you already have. Google Maps Lead Enricher starts from a Google Maps search query and discovers businesses and their websites automatically. If you already have URLs, use the Lead Gen Suite. If you want to find businesses in a specific area and industry, use this actor.

What happens when multiple businesses share the same website domain? The enrichment pipeline runs once per unique domain. When merging, each Google Maps listing that shares that domain receives the same enrichment data (emails, contacts, scores). This is common with franchise businesses or multi-location companies sharing a corporate website.

Can I get businesses that have no website? Yes. Set includeBusinessesWithoutWebsite to true. These businesses will appear in the output with Google Maps data (name, address, phone, rating, category) but no enrichment data (no emails, contacts, patterns, or scores). Their pipelineSteps field will show only ["google-maps"].

Integrations

Google Maps Lead Enricher produces standard Apify dataset output, so you can connect it to any platform that integrates with Apify:

• Apify API -- Fetch results programmatically via the Apify API. Use the dataset ID from the run to retrieve leads in JSON, CSV, XML, or Excel format.
• Google Sheets -- Automatically export leads to a spreadsheet using the Apify Google Sheets integration.
• Zapier -- Trigger workflows when new leads are found. Push leads to your CRM, send Slack notifications, or create tasks in project management tools.
• Make (Integromat) -- Build advanced automation scenarios with lead data as input.
• Webhooks -- Configure Apify webhooks to POST results to your own API endpoint when the run completes.
• Scheduled Runs -- Set up daily or weekly schedules to process new batches of businesses automatically.

Related Actors

Build a complete local lead generation stack by combining this actor with other tools from ryanclinton on the Apify Store: