If you've ever built a sales call list by hand, you know the drill. Open Google Maps. Search "roofing companies near me." Click into each listing. Open the website in a new tab. Hunt for a phone number that isn't hidden behind a "Contact Us" form. Copy it into a spreadsheet. Repeat two hundred times. By the time you're done, you've spent an entire day doing work that generates zero revenue and mostly just makes your eyes hurt.
I hit this wall a few months ago while helping a small B2B services team build out their outbound pipeline. They needed a call list of 300+ local businesses in a specific niche, with verified phone numbers and emails, ranked by how "callable" they actually were. Manual research was going to eat a week of someone's time - and even then, the data quality would be inconsistent because humans get tired and start copy-pasting sloppily around hour four.
So I built an automated pipeline instead. It combines three things that, individually, are each pretty useful, but together turn into something genuinely powerful:
Apify for web scraping and business discovery at scale
The Model Context Protocol (MCP) to give an AI model direct, structured access to that data
Claude AI to qualify, rank, and clean the leads into something a sales rep can actually work from
In this post, I'll walk through the entire workflow end to end - how it discovers businesses, extracts contact details, hands that data to Claude, and spits out a prioritized sales call list. I'll also share the architecture, some example output, and honest thoughts on where this approach shines and where it still needs a human in the loop.
The Core Problem With Manual Lead Generation
Before getting into the solution, it's worth being explicit about why manual lead list building is such a bad use of time:
It doesn't scale. Finding 20 leads by hand is fine. Finding 500 is a part-time job.
Data quality is inconsistent. Different people copy data differently - some grab a fax number by mistake, some skip the direct line and grab a generic support number instead.
There's no qualification layer. A raw list of business names and phone numbers isn't a sales call list - it's just contacts. You still need to figure out which ones are worth calling first.
It's demoralizing. Nobody wants to spend their day copy-pasting from browser tabs into a spreadsheet.
Automating discovery and extraction solves the scale and consistency problems. Adding an AI qualification layer solves the "which leads matter" problem. That's the whole pitch.
Meet the Actor: Sales Call List Generator
The engine behind the discovery and extraction stage of this workflow is an Apify actor called the Sales Call List Generator. Its job, in plain terms, is to automatically discover businesses, extract contact information, and generate high-quality sales call lists from websites using AI-powered data extraction. You give it a keyword or niche, and it goes out, finds relevant businesses, crawls their websites, and comes back with structured contact data instead of a pile of raw HTML.
Concretely, the actor can:
Discover businesses matching a search term or industry niche
Crawl company websites to find relevant pages automatically
Find phone numbers, even when they're buried in a footer or a contact page rather than the homepage
Extract email addresses from contact forms, footers, and "about us" pages
Locate contact pages so you have a direct link if a phone number isn't listed
Collect company names in a normalized format
Gather website URLs for every business found
Extract physical addresses when available
Find social media profiles - LinkedIn, Facebook, Instagram, X - when a business has them linked
Produce structured sales lead data in a clean, machine-readable format (typically JSON, which is what makes the next stage of this pipeline possible)
The part that makes this genuinely different from a basic scraper is that AI is doing real work under the hood to clean, organize, and structure the collected information. Instead of you writing regex to guess which ten-digit number on a page is actually the business's main line, the AI layer inside the actor makes that judgment call, and instead of a wall of scraped text, you get tidy fields: business name, phone, email, address, and so on.
If you want to see it in action or plug it into your own workflow, the actor is public on Apify here: Sales Call List Generator. It's worth exploring the actor's input schema directly - you can tune things like the search niche, geographic scope, and how deep it crawls each site.
The Complete Automation Pipeline
Here's the full pipeline, from a cold keyword to a ranked call list sitting in front of a sales rep.
Step 1 - Discover Businesses
Everything starts with a search input. You tell the actor what kind of business you're targeting - this could be an industry ("roofing companies," "dentists," "restaurants," "SaaS companies," "real estate agencies") or something more specific like "boutique law firms in Austin." The actor takes that input and searches for matching businesses, then queues up their websites for crawling.
This is the step that used to take the most manual time. Instead of scrolling through search results and maps listings one at a time, the actor batches this discovery process and hands off a list of business websites to crawl. From there, it visits each site and starts pulling out the contact information that actually matters for a sales call.
Important Note : use this actor is public on Apify here: Sales Call List Generator. It's worth exploring the actor's input schema directly - you can tune things like the search niche, geographic scope, and how deep it crawls each site.
Step 2 - Extract Contact Information
For every business discovered, the actor extracts a consistent set of fields:
Business Name
Website
Phone Number
Email Address
Contact Page (a direct link, useful as a fallback when no phone/email is found)
Physical Address
Industry
Social Profiles
Why does this matter so much? Because the difference between "a list of company names" and "a sales call list" is exactly this extraction step. A rep can't call a company name. They need a phone number, ideally an email as a backup channel, and enough context (industry, address) to open the call with something relevant to say. Automated extraction does this at a speed no human researcher can match - we're talking hundreds of businesses processed while you'd still be finishing your coffee, versus the hours or days it would take to do the same research by hand, one browser tab at a time.
Step 3 - Connect Apify to Claude AI Using MCP
This is where the pipeline goes from "scraper" to "AI-powered workflow," and it's worth slowing down to explain the moving part that makes it work: the Model Context Protocol, or MCP.
In simple terms, MCP is a standard that lets AI models like Claude connect directly to external tools and data sources - APIs, databases, files, or in this case, structured data produced by Apify - without you having to manually copy-paste that data into a chat window or write custom glue code for every integration. Think of it like a universal adapter: instead of Claude only being able to "see" what you type or paste, MCP gives it a defined way to request and receive structured data from a connected source, the same way a plug fits a specific socket regardless of what appliance is on the other end.
In this pipeline, once the Apify actor finishes running and produces its structured dataset (a clean JSON list of businesses with names, phones, emails, addresses, and so on), that dataset is exposed to Claude through an MCP connection. That means Claude isn't just seeing a summary or a small snippet - it can work with the full dataset as structured data, which unlocks a few things:
Read thousands of leads in one working context rather than being limited to whatever fits in a single copy-pasted message
Understand the structured format natively - it knows this row is a phone number, this one's an email, this one's an address, rather than treating everything as an undifferentiated blob of text
Filter bad contacts - malformed phone numbers, obviously fake emails, empty fields
Detect missing information and flag which leads need manual follow-up
Rank businesses based on how complete and "callable" their data is
Generate summaries of the dataset as a whole (e.g., "72% of leads have both phone and email; restaurants had the highest data completeness")
Recommend outreach priorities - which leads to call first, and why
The practical setup usually looks like this: the Apify actor run produces a dataset, an MCP server exposes that dataset (or the Apify API) as a callable resource, and Claude connects to that MCP server as a client. From there, you can literally ask Claude things like "rank these leads by call priority and tell me which ones are missing phone numbers" and get back an answer grounded in the actual dataset, not a hallucinated guess.
Step 4 - AI Lead Qualification
Raw contact data isn't the same thing as a qualified lead. This is the step most automated scraping tools skip entirely, and it's the one that actually saves a sales team the most time.
Once Claude has access to the dataset via MCP, it evaluates each business against a few practical signals:
Which companies appear active - do they have a working website, recent content, a functioning contact page?
Which companies have valid contact information - properly formatted phone numbers and emails, not placeholder text or broken links
Which businesses are worth calling - based on completeness of data and relevance to the target niche
Which businesses should be skipped - dead websites, missing all contact info, obvious duplicates
Which leads should receive the highest priority - typically those with both a direct phone number and email, a real physical address, and clear signs of an active business
This qualification pass is what turns "500 scraped businesses" into "80 leads worth a sales rep's time this week." Doing this manually would mean someone opening every single website again just to sanity-check it - which defeats the entire purpose of automating the first two steps. Having Claude do this reasoning over the structured dataset means the qualification logic scales exactly as well as the scraping does.
Step 5 - Generate the Final Sales Call List
The last step is producing the actual deliverable: a clean, ranked table a sales rep can open and start working immediately. Here's an example of what that output looks like in practice, using realistic sample data for a "dentists" niche search:
Business Website Phone Email Priority Notes Bright Smile Dental Clinic brightsmiledental.com (512) 555–0142 info@brightsmiledental.com High Full contact info, active blog, recent reviews Riverside Family Dentistry riversidefamilydds.com (512) 555–0198 contact@riversidefamilydds.com High Complete profile, LinkedIn active Oakview Orthodontics oakvieworthocenter.com (512) 555–0110 - Medium No email found, has contact form Downtown Dental Group downtowndentalgrp.com - hello@downtowndentalgrp.com Medium Phone missing, email verified Sunrise Dental Studio sunrisedentalstudio.com (512) 555–0176 appointments@sunrisedentalstudio.com High Active social profiles, address confirmed Legacy Dental Partners legacydentalpartners.com - - Low Website appears outdated, no working contact info
Notice how the "Priority" and "Notes" columns aren't things the raw scraper produced - they're Claude's qualification layer at work, reasoning over completeness and business activity to tell a rep exactly where to start. That's the difference between a scraped dataset and an actual sales call list.
Architecture Diagram
Here's the full pipeline laid out visually, from initial search input to the final list landing in a rep's hands:
flowchart LR
A[Search Businesses]
--> B[Apify Sales Call List Generator]
--> C[Extract Contact Information]
--> D[MCP Server]
--> E[Claude AI]
--> F[Lead Qualification]
--> G[Final Sales Call List]
Each box maps directly to a step above: the search kicks off the actor, the actor discovers and extracts, the structured output is exposed over MCP, Claude reads it, qualifies it, and the result is a call list ready for outreach.
Why This Combination Works Better Than Either Tool Alone
It's worth being clear-eyed about why you need both halves of this pipeline, rather than just one or the other.
Apify alone gets you fast, scalable data collection. You can run the Sales Call List Generator actor against any niche and get a structured dataset of businesses back in minutes instead of days. But a scraper, on its own, doesn't know which leads are actually good. It'll happily hand you a business with a dead website right next to one that's clearly thriving, with no distinction between them.
Claude alone, without MCP, would have no way to reliably work with a live, large, structured dataset - you'd be stuck manually pasting chunks of data into a chat window, which breaks down fast once you're past a few dozen rows and loses the benefit of having structured fields in the first place.
Together, via MCP, you get scale from Apify and judgment from Claude, connected without manual data wrangling in between. That combination is really the point of MCP in general: it's not just about connecting AI to any data - it's about connecting AI to structured, live data in a way that preserves the structure, so the model can reason over fields instead of guessing at unstructured text.
Practical Tips If You're Building This Yourself
A few things I learned putting this together that are worth passing on:
Be specific with your niche input. "Dentists" returns a broad, noisy set. "Cosmetic dentists in Austin, TX" returns a tighter, more relevant one. The narrower your search, the less qualification work Claude has to do downstream.
Don't skip the qualification step. It's tempting to just export the raw Apify dataset straight into your CRM. Resist that - an unqualified list buries your best leads next to your worst ones, and your reps will burn goodwill calling dead numbers.
Treat "Low" priority as a queue, not trash. Some low-priority leads just have incomplete data, not zero potential. A quick manual check on those can still turn up real opportunities.
Re-run periodically. Business contact info changes. A call list from six months ago is stale - treat this as a pipeline you re-run on a schedule (weekly or monthly, depending on your outbound volume), not a one-time export.
Keep a human in the loop for edge cases. AI qualification is good at spotting patterns (missing fields, dead sites) but it's not infallible. Spot-check a sample of the "High" priority leads before your team starts dialing.
Wrapping Up
What used to be a multi-day manual research project - searching for businesses, opening dozens of tabs, copy-pasting contact details, and then trying to guess which leads were worth prioritizing - now runs as a repeatable pipeline: Apify discovers and extracts, MCP connects that structured data to Claude, and Claude qualifies and ranks it into a call list a sales rep can start working the same day.
If you're a developer or founder looking to build something similar, the fastest way to get a feel for it is to try the actor directly and see the shape of the data it produces before you build the MCP and qualification layers on top. You can find it on Apify here: Sales Call List Generator.
The bigger takeaway, honestly, isn't really about sales call lists specifically - it's about the pattern. Scraper for scale, MCP for the connective tissue, LLM for judgment. That pattern generalizes to a lot of workflows beyond lead generation, and it's a genuinely useful template to have in your back pocket the next time you're staring down a pile of repetitive manual research.
Top comments (0)