NexGenData

Posted on May 21

Google Maps Scraping for Agency Prospecting: Find Businesses Without Websites

#webscraping #python #tutorial #automation

Digital agencies have a perennial challenge: finding qualified prospects. You know your ideal customer—a local business with no website, bad reviews, sparse social media, existing customers complaining online. They're drowning in opportunity cost but don't know it yet.

The problem is finding them at scale before your competitors do.

Most agencies rely on cold calling lists, LinkedIn, or referrals. All viable, but slow. What if you could identify hundreds of qualified prospects in an afternoon using data that's already public?

Google Maps is your goldmine. Every business is there. Every review is visible. Every gap in their digital presence is quantifiable.

Why Google Maps is the Perfect Prospect Source

Every local business exists on Google Maps. No exceptions:

Plumbers, electricians, HVAC contractors
Dental offices, salons, gyms
Restaurants, coffee shops, retail
Home services, contractors, consultants

And Google Maps tells you everything you need to know about their digital maturity:

Review count and recency - Active businesses get reviews. Abandoned or neglected ones don't.
Rating quality - Well-managed businesses maintain high ratings. Struggling ones have scattered reviews with customer complaints.
Review sentiment - Natural language patterns in reviews reveal operational problems: "no website," "couldn't find them online," "outdated info."
Website presence - Many small businesses have no website listed, or an outdated/broken one.
Response rate - Engaged owners reply to reviews. Absent ones ignore complaints.

A business with 40 reviews, 3.8 rating, complaints about outdated information, and no website? That's a $5k-15k web design project walking around in need of a savior.

And you can find 500 of them in a single ZIP code.

The Filtering Framework: Opportunity Scoring

Not every business on Google Maps is a prospect. You need to filter ruthlessly.

Here's a scoring system that works:

def score_prospect(business):
    """
    Calculate lead quality score (0-100).
    Higher = more urgent need for web/SEO services.
    """
    score = 0

    # Review activity (0-25 points)
    # Active businesses get regular reviews
    days_since_last_review = business.get('days_since_last_review', 999)
    if days_since_last_review < 30:
        score += 25
    elif days_since_last_review < 90:
        score += 15
    elif days_since_last_review < 180:
        score += 8
    # else: no recent activity

    # Rating concerns (0-20 points)
    # Low ratings + negative reviews = pain + budget
    rating = business.get('rating', 0)
    review_count = business.get('reviewCount', 0)

    if rating < 3.5 and review_count > 10:
        score += 20  # They have a problem they need solved
    elif rating < 4.0 and review_count > 5:
        score += 12

    # Website status (0-30 points)
    has_website = business.get('website') is not None
    website_quality = business.get('website_quality', 'none')

    if not has_website:
        score += 30  # Most valuable: zero web presence
    elif website_quality == 'outdated':
        score += 20
    elif website_quality == 'poor':
        score += 15

    # Review sentiment analysis (0-15 points)
    # Complaints about being hard to find, outdated info, no online booking
    negative_keywords = [
        'no website', 'hard to find', 'outdated',
        'no online ordering', 'no appointment booking',
        'no phone number', 'outdated website'
    ]
    negative_mentions = sum(
        1 for review in business.get('recent_reviews', [])
        if any(kw in review.lower() for kw in negative_keywords)
    )

    if negative_mentions >= 3:
        score += 15
    elif negative_mentions >= 1:
        score += 8

    # Engagement pattern (0-10 points)
    owner_response_rate = business.get('owner_response_rate', 0)
    if owner_response_rate < 0.3:
        score += 10  # They're absent. Perfect time to pitch.
    elif owner_response_rate < 0.6:
        score += 5

    return min(score, 100)


# Example usage
prospects = [
    {
        'name': 'Joe\'s Plumbing',
        'rating': 3.2,
        'reviewCount': 18,
        'days_since_last_review': 5,
        'website': None,
        'website_quality': 'none',
        'recent_reviews': [
            'Good work but hard to find online',
            'No website, had to call directory',
            'Outdated Google info'
        ],
        'owner_response_rate': 0.11
    },
    {
        'name': 'Sarah\'s Salon',
        'rating': 4.8,
        'reviewCount': 120,
        'days_since_last_review': 1,
        'website': 'https://sarahs-salon.com',
        'website_quality': 'good',
        'recent_reviews': [],
        'owner_response_rate': 0.95
    }
]

for p in prospects:
    print(f"{p['name']}: Score {score_prospect(p)}")
    # Output:
    # Joe's Plumbing: Score 88
    # Sarah's Salon: Score 12

Joe's Plumbing scores 88. Sarah's Salon scores 12. Notice the difference? Sarah's established, responsive, polished. She doesn't need you. Joe's drowning and doesn't know it yet.

Your outreach targets score 70+.

Getting the Data: The Apify Advantage

Google Maps data isn't trivial to scrape—Google detects and blocks bot traffic aggressively. But the Apify Google Maps Lead Generator handles this entirely, giving you clean, structured output with no detection risk.

Here's what the raw data looks like:

{
  "businesses": [
    {
      "id": "0x880e8d13a8d4e4d3:0x12345",
      "name": "Joe's Plumbing & Heating",
      "address": "1234 Main St, Springfield, IL 62701",
      "phone": "(217) 555-0198",
      "website": null,
      "rating": 3.2,
      "reviewCount": 18,
      "reviewsUrl": "https://www.google.com/maps/place/...",
      "categories": ["Plumbing", "Water Heater Installation"],
      "hours": "Mo-Su 7AM-8PM",
      "timezone": "America/Chicago",
      "gMapsUrl": "https://www.google.com/maps/place/Joe's+Plumbing",
      "lastReviewDate": "2026-04-02",
      "topReviews": [
        {
          "author": "Mike T",
          "rating": 2,
          "date": "2026-04-02",
          "text": "Good work but their website info is outdated and hard to find them online"
        }
      ]
    }
  ],
  "pagination": {
    "hasNextPage": true,
    "cursor": "next_page_token_xyz"
  }
}

Perfect. Now you filter and score.

The End-to-End Workflow

Search by location and industry
- "HVAC contractors in Austin, TX"
- "Dental offices in Denver, CO"
- Define your ideal service area and category
Get structured output
- 100-500 businesses depending on market size
- Full contact info, ratings, reviews, website status
- Recent review dates and sentiment
Apply filtering logic
- Remove high-scorers (they don't need you)
- Extract score 70+ businesses
- Remove established agencies/chains
- Filter for phone-callable hours
Enrich before outreach
- Pull LinkedIn if they have a company page
- Check their social media presence
- Validate phone numbers are active
- Review their top complaints
Personalized outreach
- Reference specific review complaints
- Quantify the opportunity cost
- Show competitors who have fixed these problems
- Offer a free audit

Real Example: A/C Repair in Phoenix

Phoenix's hot climate means every building needs HVAC maintenance. The market's huge and fragmented. Here's a real scoring scenario:

Phoenix search: "HVAC repair Phoenix AZ"
Results: 284 businesses found
Score 70+: 47 qualified prospects
Score 80+: 18 high-priority leads
Score 90+: 3 emergency-level opportunities

One of those 90-score businesses:

Rating: 2.8 (among the worst in the area)
22 reviews, most recent 3 days ago
No website whatsoever
Top complaints: "can't find them online," "outdated address," "no way to book online"
Owner response rate: 15%

This is a $10k-25k project. The owner doesn't know their digital presence is costing them business. You do now.

Running the Query

Using the Apify Google Maps Lead Generator:

import requests
import json

actor_id = "yaVwNMJVMMJ3kk3ue"
api_token = "your_token"

# Search parameters
payload = {
    "searchString": "HVAC repair Phoenix AZ",
    "resultsLimit": 500,
    "language": "en",
    "countryCodes": ["US"]
}

# Start the run
response = requests.post(
    f"https://api.apify.com/v2/acts/{actor_id}/runs",
    json=payload,
    auth=("", api_token)
)

run_id = response.json()["data"]["id"]

# Wait for completion and fetch results
# (then apply your scoring logic)

The data comes back. You apply your scoring function. You get a filtered list of 47 Phoenix HVAC businesses that are ripe for web design + SEO services.

Now your outreach is surgical, not spray-and-pray.

Why This Works Better Than Cold Lists

Traditional lead lists give you names and phone numbers. That's friction. You still have to research each one, guess whether they need your services, and hope they answer.

Google Maps gives you their entire operational story:

How they're perceived (reviews)
How they're found (website/map ranking)
What their customers are complaining about (exact pain points)
Whether they're paying attention (owner responsiveness)

You already know why they need you before you call. That changes everything about conversion rates.

The Numbers

Time to qualify 50 prospects:

Manual research: 15-20 hours
Using scoring + Apify data: 2 hours

Cost per qualified lead:

Manual: ~$30-50 in labor
Using Apify: ~$5-10 in API costs

That's not just efficiency. That's a different business model.

Next Steps

Pick your target market (city + industry)
Run the Google Maps scraper
Apply scoring to the output
Manually spot-check the top 5-10 for verification
Build an outreach sequence for the 70+ scorers
Track which score ranges convert best (you'll find patterns)

Your ideal customers are already on Google Maps, waiting to be found. The tools now exist to find them automatically.

The agencies that figure this out first will own their local markets.

Do you currently prospect in local markets? What's your biggest prospecting bottleneck? Let me know in the comments.

DEV Community