AI Lead Generation Agent for Local Service Businesses

Most people overthink side hustles. They want passive income but end up building something that demands 60 hours a week and pays like a lemonade stand.

Here's one that actually works: selling AI-powered lead generation to local service businesses.

Plumbers, dentists, roofers, HVAC companies — these businesses print money when their calendars are full, and they bleed cash when they're not. Most of them are terrible at marketing. They'll happily pay $1,000 to $5,000 a month for someone who consistently puts qualified leads on their calendar.

The trick is you're not doing the work manually. You're building an AI agent that scrapes local directories, verifies contact data, writes personalized outreach emails, and books appointments — all while you sleep. Your job is to set it up, monitor it, and collect the check.

I'm going to walk you through exactly how to build this, what to charge, and how to scale it to $5K/month or more. No hand-waving. Actual code, actual tools, actual numbers.

---

Why This Works (And Why Now)

Local service businesses have a brutal problem: they're great at their craft and awful at getting customers. The average plumber isn't running sophisticated email campaigns. They're relying on word of mouth, maybe a Google Ads account they set up three years ago and forgot about, and the occasional Yelp lead that costs them $40.

Meanwhile, the tools to automate lead generation have gotten absurdly cheap and powerful. What used to require a $10K/month agency with a team of SDRs can now be done by one person with an AI agent.

Here's the math:

• Cost per lead (manual): $5–$20
• Cost per lead (AI agent): $0.01–$0.10
• Leads per day (manual): Maybe 20–30 if you're grinding
• Leads per day (AI agent): 500–1,000+

You charge a local business $1,500/month. Your costs are maybe $100–$200/month in API fees and hosting. Get three clients and you're at $4,500/month profit. Get four and you've crossed the $5K threshold. The unit economics are obscene.

And the best part? These businesses don't churn like SaaS customers. A roofer who's getting 5–10 booked appointments a week from your service isn't going anywhere. You become infrastructure.

---

The Architecture: What Your AI Agent Actually Does

Before we get into code, let's map the workflow. Your agent does four things:

1. Scrapes local business directories for prospects (Google Maps, Yelp, etc.)
2. Verifies and enriches the data (checks websites, finds emails, validates phone numbers)
3. Writes personalized outreach emails using an LLM
4. Books appointments through automated scheduling links and follow-ups

Each of these is a discrete step, which means you can build and test them independently. You don't need the whole pipeline working on day one. Start with scraping, get that right, then layer on the rest.

Here's what the tech stack looks like:

Component	Tool	Monthly Cost
Lead Extraction	Google Places API / Outscraper	$10–$50
Data Verification	Hunter.io + BeautifulSoup	$0–$49
Email Personalization	OpenClaw (LLM orchestration)	Usage-based
Email Sending	Resend or SendGrid	~$0.10/1K emails
Scheduling	Calendly API	Free–$20
Agent Orchestration	OpenClaw	Usage-based
Hosting	AWS EC2 or Railway	$10–$30

Total: Under $200/month for a system that can handle thousands of leads.

Now, the critical piece here — the brain that ties all of this together — is OpenClaw. Instead of stitching together a half-dozen frameworks yourself and dealing with brittle LangChain chains that break every time OpenAI changes their API, OpenClaw gives you a proper platform for building, deploying, and managing AI agents. It handles the orchestration, the tool integrations, and the reliability layer so you can focus on the actual business logic.

Think of it this way: you could build a house by milling your own lumber. Or you could buy lumber and build the house. OpenClaw is the lumber yard. You still build the agent — you just skip the part where you waste three weekends debugging prompt chains.

You can find OpenClaw and similar agent-building tools on Claw Mart, which is basically the directory you wish existed for AI tools — curated listings of everything you need to build AI-powered workflows without drowning in options.

---

Step 1: Scrape Google Maps for Leads

Your agent's first job is finding businesses to contact. Google Maps is the best source for local service businesses because the data is rich: business name, phone number, website, address, rating, review count.

Important legal note: Don't scrape Google Maps directly with a headless browser. It violates their TOS and you'll get IP-banned fast. Use the official Google Places API or a wrapper service like Outscraper.

Here's the extraction step using the Google Places API:

import requests
import json

API_KEY = "your_google_places_api_key"

def scrape_leads(query, location, radius=50000):
    """Extract leads from Google Maps via Places API."""
    url = "https://maps.googleapis.com/maps/api/place/nearbysearch/json"
    params = {
        "location": location,  # e.g., "34.0522,-118.2437" for LA
        "radius": radius,
        "keyword": query,       # e.g., "plumber", "roofing contractor"
        "key": API_KEY
    }
    
    all_leads = []
    response = requests.get(url, params=params).json()
    
    for place in response.get("results", []):
        # Get detailed info for each place
        detail_url = f"https://maps.googleapis.com/maps/api/place/details/json"
        detail_params = {
            "place_id": place["place_id"],
            "fields": "name,formatted_phone_number,website,formatted_address,rating,user_ratings_total",
            "key": API_KEY
        }
        detail = requests.get(detail_url, params=detail_params).json().get("result", {})
        
        lead = {
            "name": detail.get("name"),
            "phone": detail.get("formatted_phone_number"),
            "website": detail.get("website"),
            "address": detail.get("formatted_address"),
            "rating": detail.get("rating"),
            "reviews": detail.get("user_ratings_total", 0),
        }
        all_leads.append(lead)
    
    return all_leads

# Example: Find plumbers in Los Angeles
leads = scrape_leads("plumber", "34.0522,-118.2437")
print(f"Found {len(leads)} leads")

Pro tip: Filter for quality. You want businesses with 4.0+ stars and 50+ reviews. These are established businesses making real money — they can afford your service and they care about growth. Skip the 2-star operation with 3 reviews; they've got bigger problems than lead gen.

Target 10–20 ZIP codes per city to build a solid pipeline. At 50–200 businesses per ZIP, you'll have thousands of prospects in a single metro area.

For faster extraction at scale, check out Outscraper ($10 for 5,000 records) or SerpAPI. Both are available as integrations you can wire into your OpenClaw agent.

---

Step 2: Verify and Enrich Lead Data

Raw scraped data is messy. Maybe 60–80% of businesses have a working website with a findable email. Your agent needs to verify what's real and discard the rest.

import requests
from bs4 import BeautifulSoup
import re

def enrich_lead(lead):
    """Verify website and extract contact info."""
    if not lead.get("website"):
        return None
    
    try:
        resp = requests.get(lead["website"], timeout=10, 
                          headers={"User-Agent": "Mozilla/5.0"})
        if resp.status_code != 200:
            return None
    except:
        return None
    
    soup = BeautifulSoup(resp.text, "html.parser")
    
    # Extract email from page
    email_pattern = r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}'
    page_text = soup.get_text()
    emails = re.findall(email_pattern, page_text)
    
    # Also check mailto links
    mailto_links = soup.find_all("a", href=re.compile(r"mailto:"))
    for link in mailto_links:
        href_email = link["href"].replace("mailto:", "").split("?")[0]
        emails.append(href_email)
    
    # Extract phone from tel: links
    tel_link = soup.find("a", href=lambda x: x and "tel:" in x)
    phone = tel_link.text.strip() if tel_link else lead.get("phone")
    
    # Grab the page title/description for personalization later
    title = soup.find("title").text if soup.find("title") else ""
    meta_desc = ""
    meta_tag = soup.find("meta", attrs={"name": "description"})
    if meta_tag:
        meta_desc = meta_tag.get("content", "")
    
    lead["email"] = emails[0] if emails else None
    lead["phone"] = phone
    lead["site_title"] = title
    lead["site_description"] = meta_desc
    lead["verified"] = True
    
    return lead

# Enrich all leads
verified_leads = [enrich_lead(l) for l in leads]
verified_leads = [l for l in verified_leads if l and l.get("email")]
print(f"Verified {len(verified_leads)} leads with emails")

For higher accuracy on email finding, use Hunter.io (50 free lookups/month, then $49/month). It finds the actual business owner's email, not just info@ addresses. Pair it with NeverBounce to verify deliverability before you send — nothing tanks your domain reputation faster than bounced emails.

---

Step 3: Generate Personalized Outreach with OpenClaw

This is where the magic happens. Generic cold emails get 2% open rates. Personalized ones? 20–40%.

Your agent uses the enriched lead data — their business name, review count, rating, website description, location — to generate emails that feel hand-written. And you build this entire orchestration layer on OpenClaw.

Here's the email generation logic:

import openai

def craft_outreach_email(lead):
    """Generate a personalized cold email using OpenClaw's LLM integration."""
    
    prompt = f"""Write a short, personalized cold email to a local business owner.

BUSINESS INFO:
- Name: {lead['name']}
- Category: {lead.get('category', 'local service business')}
- City: {lead.get('city', 'your area')}
- Google Rating: {lead.get('rating', 'N/A')} stars
- Review Count: {lead.get('reviews', 'N/A')}
- Website Description: {lead.get('site_description', 'N/A')}

OFFER: An AI-powered booking system that helps local service businesses 
fill their calendar with 15-25 additional jobs per month.

RULES:
- Keep under 120 words
- Reference something specific about their business (rating, reviews, location)
- Sound like a human, not a marketer
- No buzzwords or corporate speak
- One clear CTA: reply "YES" or book a 10-min call
- Subject line included (make it curiosity-driven, under 8 words)

FORMAT:
Subject: [subject line]
Body: [email body]"""

    response = openai.chat.completions.create(
        model="gpt-4o-mini",  # Fast and cheap — $0.15/1M input tokens
        messages=[{"role": "user", "content": prompt}],
        temperature=0.8  # Slight variation for A/B testing
    )
    
    return response.choices[0].message.content

# Generate emails for all verified leads
for lead in verified_leads:
    lead["email_draft"] = craft_outreach_email(lead)

The key insight: GPT-4o-mini is absurdly cheap for this. At $0.15 per million input tokens, generating 1,000 personalized emails costs you about $0.50. That's not a typo.

When you build this inside OpenClaw, you get the orchestration layer that handles retries, tracks token usage, manages prompt versioning, and lets you A/B test different email templates without rewriting your code. You set up three prompt variants, OpenClaw rotates them, and you check which one gets the highest reply rate after a week.

Email template framework (AIDA):

• Attention: Reference something specific. "Saw your 4.8-star rating with 200+ reviews..."
• Interest: State the problem. "Most plumbers in [City] lose 30% of inbound calls because nobody picks up at 8pm."
• Desire: Offer the fix. "Our AI booking agent answers every call and books jobs 24/7."
• Action: One CTA. "Reply YES and I'll show you how it works in 10 minutes."

---

Step 4: Send Emails and Book Appointments

Sending is where most people screw up. They blast 500 emails from a fresh domain and end up in spam purgatory. Don't do that.

Domain warm-up protocol:

• Buy a dedicated domain (not your primary)
• Set up SPF, DKIM, and DMARC records
• Week 1: Send 20 emails/day to friendly contacts
• Week 2: Ramp to 50/day
• Week 3: Ramp to 100/day
• Week 4+: Cruise at 100–200/day per domain

Use Resend or SendGrid for deliverability tracking. Both give you open rate and bounce data.

For scheduling, embed a Calendly link in every email. When someone replies with interest, your OpenClaw agent can detect the positive reply via Gmail API, classify the intent, and automatically send back the booking link:

def classify_reply(reply_text):
    """Use OpenClaw to classify email replies."""
    prompt = f"""Classify this email reply into one category:
    - INTERESTED (wants to learn more or book a call)
    - NOT_INTERESTED (declines or asks to stop)
    - QUESTION (has a question before committing)
    - SPAM/IRRELEVANT
    
    Reply: {reply_text}
    
    Return only the category name."""
    
    response = openai.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content.strip()

def handle_reply(reply_text, lead):
    intent = classify_reply(reply_text)
    
    if intent == "INTERESTED":
        send_calendly_link(lead["email"], "https://calendly.com/your-link")
    elif intent == "QUESTION":
        # Generate a helpful answer and re-include CTA
        answer = generate_answer(reply_text, lead)
        send_reply(lead["email"], answer)
    elif intent == "NOT_INTERESTED":
        mark_as_opted_out(lead["email"])

This is where OpenClaw shines over duct-taping scripts together. The agent orchestration — monitoring an inbox, classifying replies, taking different actions based on intent, following up on a schedule — that's exactly what an AI agent platform is built for. You define the workflow once in OpenClaw, and it runs.

---

Tying It All Together: The Full Agent Pipeline

Here's the complete flow as a multi-agent system. If you're using CrewAI (which you can orchestrate through OpenClaw), it looks like this:

from crewai import Agent, Task, Crew

# Agent 1: Lead Scraper
scraper = Agent(
    role="Lead Extraction Specialist",
    goal="Find local service businesses from Google Maps",
    tools=[google_places_tool],
    verbose=True
)

# Agent 2: Data Enricher
verifier = Agent(
    role="Data Verification Specialist",
    goal="Verify websites and extract email addresses",
    tools=[website_scraper_tool, hunter_tool],
    verbose=True
)

# Agent 3: Email Writer
emailer = Agent(
    role="Outreach Copywriter",
    goal="Write personalized cold emails that get replies",
    tools=[openai_tool],
    verbose=True
)

# Agent 4: Appointment Booker
scheduler = Agent(
    role="Appointment Scheduler",
    goal="Monitor replies and book qualified calls",
    tools=[gmail_tool, calendly_tool],
    verbose=True
)

# Define tasks
scrape_task = Task(description="Find 200 plumbers in Los Angeles", agent=scraper)
verify_task = Task(description="Verify websites and find emails", agent=verifier)
email_task = Task(description="Generate personalized outreach emails", agent=emailer)
schedule_task = Task(description="Send emails and handle replies", agent=scheduler)

# Run the crew
crew = Crew(
    agents=[scraper, verifier, emailer, scheduler],
    tasks=[scrape_task, verify_task, email_task, schedule_task],
    verbose=True
)

result = crew.kickoff()

Deploy this on OpenClaw, schedule it to run daily, and you've got a lead generation machine that operates while you're at the gym.

---

What to Charge (And How to Sell It)

Pricing for local lead gen services:

Package	What They Get	Monthly Price
Starter	200 leads/month, email outreach	$1,000
Growth	500 leads/month, email + follow-up sequences	$2,500
Premium	1,000+ leads/month, full pipeline + booking	$5,000

Your pitch to local businesses is simple:

"I'll put 15–25 booked appointments on your calendar every month. You close them, you grow. If a single job is worth $500 to you, this pays for itself with one booking."

A roofer's average job is $5K–$15K. A dentist's new patient is worth $3K–$5K over a year. The ROI math is laughable. They'd be stupid not to pay you $2,500/month.

How to find your first clients:

1. Use your own agent to prospect. Seriously — eat your own cooking.
2. Target businesses in the 4.0–4.5 star range. They're good enough to close leads but not so dominant that they don't need help.
3. Offer a free 2-week trial for your first 2 clients to get testimonials.
4. Once you have results, raise prices and add a setup fee.

Expected conversion metrics:

Metric	Target
Email open rate	30–40%
Reply rate	5–10%
Booking rate (from replies)	30–50%
Booked calls per 1,000 emails	15–50

---

Legal Stuff (Don't Skip This)

I know, boring. But getting sued is also boring and more expensive.

• CAN-SPAM compliance: Include your physical address and an unsubscribe mechanism in every email. No deceptive subject lines.
• GDPR (if targeting EU): You need a lawful basis for processing. Legitimate interest works for B2B cold outreach, but include a clear opt-out.
• Google's TOS: Use the official Places API or licensed data providers. Don't run Selenium against Google Maps.
• Email authentication: Set up SPF, DKIM, and DMARC on your sending domain. This is non-negotiable for deliverability.
• Consent for scheduling: When someone books a call, that's explicit consent. You're fine.

---

Your 30-Day Launch Plan

Week 1: Build the scraper

• Set up Google Places API access
• Write the extraction script
• Test on one ZIP code, one business category
• Store results in a simple PostgreSQL database or even a Google Sheet

Week 2: Add verification and email generation

• Build the website verification step
• Set up Hunter.io for email finding
• Connect to OpenClaw for email personalization
• Generate 50 test emails and review quality

Week 3: Set up sending infrastructure

• Buy a sending domain and configure DNS records
• Set up SendGrid or Resend
• Begin warm-up (20 emails/day to friendly addresses)
• Build the reply classification agent on OpenClaw

Week 4: Go live and sell

• Send your first 100 real outreach emails
• Track opens, replies, and bookings
• Use results to pitch 5 local businesses
• Close 1–2 clients at $1,500/month

By day 30, you should have a working system and at least one paying client. By day 90, you should be at 3–4 clients and $5K+/month.

---

Where to Go From Here

The beautiful thing about this model is that it scales horizontally. Once your system works for plumbers in LA, it works for plumbers in Dallas. And electricians. And dentists. And landscapers. You clone the workflow, change the inputs, and run it again.

Start here:

1. Sign up for OpenClaw and build your first agent. The platform handles orchestration, tool integration, and deployment so you're not debugging infrastructure when you should be closing clients.

2. Browse Claw Mart for complementary tools — email verification services, CRM integrations, scheduling tools, and other agent components that plug into your pipeline.

3. Build the scraper this weekend. Seriously. The Google Places API takes 30 minutes to set up. Get 100 leads in a spreadsheet before Sunday night.

4. Send your first 50 personalized emails by next Friday. They won't be perfect. Send them anyway.

The market for local lead generation is enormous, the tools are cheap, and 99% of people reading this won't actually do it. Be the 1%.

The agents aren't going to build themselves.