B2B Lead Generation Suite

An all-in-one lead generation pipeline that turns a list of company websites into fully enriched, scored leads. The B2B Lead Generation Suite orchestrates three specialized sub-actors in sequence -- Website Contact Scraper, Email Pattern Finder, and B2B Lead Qualifier -- so you get contacts, email patterns, and quality scores from a single run instead of managing three separate tools.

Provide one or more company URLs (e.g., stripe.com, https://buffer.com) and receive a unified dataset where every lead includes discovered emails, phone numbers, named contacts, social media links, detected email patterns, generated team emails, a 0-100 quality score, a letter grade, and detailed scoring signals. The entire pipeline runs automatically with no manual intervention between steps.

Why Use B2B Lead Generation Suite?

Running three actors manually means configuring inputs three times, waiting for each run, downloading intermediate datasets, and writing code to merge results. This actor eliminates that overhead entirely. You configure once, click Start, and get a merged dataset ready for your CRM, outreach tool, or spreadsheet.

The orchestrator also handles data flow between steps intelligently:

• Emails discovered by the Contact Scraper are automatically fed into the Pattern Finder as known samples, improving pattern detection accuracy without re-scraping.
• Contact names from website scraping are passed to the Pattern Finder for email generation, so team members without public emails still get predicted addresses.
• The Qualifier receives all upstream data (emails, phones, contacts, social links, detected patterns) via a pipelineData parameter, eliminating redundant extraction work.
• Website scraping is disabled in Step 2 since the Contact Scraper already crawled the sites -- only GitHub commit search runs as an additional email source.
• Error handling is built in -- if the Pattern Finder or Qualifier fails on a particular domain, the pipeline continues with the data it has rather than aborting.

Key Features

• Three-step pipeline in one click -- Contact scraping, email pattern detection, and lead qualification run sequentially without manual handoffs.
• Merged and deduplicated output -- Emails, phones, and social links from multiple steps are combined into a single record per domain with no duplicates.
• Lead scoring and grading -- Every lead gets a 0-100 quality score and letter grade based on five categories: contact reachability, business legitimacy, online presence, website quality, and team transparency.
• Email pattern detection -- Identifies naming conventions like first.last@, flast@, or first@ and generates predicted emails for team members.
• Configurable pipeline -- Skip the Pattern Finder or Lead Qualifier to save time and cost when you only need contact data.
• Minimum score filtering -- Set a threshold to automatically exclude low-quality leads from the output.
• Proxy support -- Pass proxy settings through to all pipeline steps for reliable scraping across many domains.
• Graceful error handling -- If an optional step fails, the pipeline continues and outputs whatever data it successfully gathered.

How to Use

1. Add company URLs -- Enter one or more website URLs or bare domains in the "Website URLs or Domains" field. For example: stripe.com, https://buffer.com, hubspot.com. Each domain produces one enriched lead in the output.

2. Configure crawl depth -- Set "Max pages per domain" for both the contact scraping step and the lead qualification step. Higher values discover more contacts and signals but increase run time and cost. The default of 5 pages per step works well for most company websites.

3. Choose pipeline steps -- By default, all three steps run. Check "Skip email pattern detection" or "Skip lead qualification" if you only need basic contact data. Skipping both optional steps makes the run roughly 3x faster.

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

5. Configure proxy -- For scraping more than a handful of domains, enable Apify Proxy to avoid rate limiting. The proxy settings are forwarded to all sub-actors automatically.

6. Run and export -- Click "Start" and wait for the pipeline to complete. Download the dataset as JSON, CSV, or Excel, or access it via the Apify API for integration into your workflow.

Input Parameters

Input Examples

Full pipeline with quality filter (most common use case):

{
    "urls": ["stripe.com", "hubspot.com", "notion.so", "linear.app", "cal.com"],
    "maxPagesPerDomain": 8,
    "maxQualifierPagesPerDomain": 5,
    "minScore": 50
}

Contact scraping only (fastest, cheapest):

{
    "urls": ["https://example.com", "https://acme.co"],
    "maxPagesPerDomain": 10,
    "skipEmailPatternFinder": true,
    "skipLeadQualifier": true
}

Contacts + patterns, no scoring:

{
    "urls": ["buffer.com", "zapier.com"],
    "skipLeadQualifier": true
}

Input Tips

• Bare domains like stripe.com and full URLs like https://stripe.com both work -- the actor normalizes them automatically.
• For SaaS prospecting, use 5-8 pages per domain to catch team/about pages where contacts are listed.
• For large enterprise sites, increase maxPagesPerDomain to 15-20 to reach contacts buried in deep navigation.
• Set minScore to 60+ when feeding results to outreach tools -- this removes placeholder sites and parked domains.
• Enable proxy when processing more than 10 domains in a single run to avoid rate limiting.

Output Example

Each domain produces one enriched lead record. Here is a representative example with all pipeline steps enabled:

{
    "domain": "apify.com",
    "url": "https://apify.com",
    "emails": ["[email protected]", "[email protected]", "[email protected]"],
    "phones": ["+420 255 000 222"],
    "contacts": [
        { "name": "Jan Curn", "title": "CEO & Co-founder", "email": "[email protected]" },
        { "name": "Ondra Urban", "title": "CTO & Co-founder" }
    ],
    "socialLinks": {
        "twitter": "https://twitter.com/apify",
        "linkedin": "https://www.linkedin.com/company/apifytech",
        "github": "https://github.com/apify",
        "youtube": "https://www.youtube.com/c/Apify"
    },
    "emailPattern": "[email protected]",
    "emailPatternConfidence": 0.85,
    "generatedEmails": [
        { "name": "Ondra Urban", "email": "[email protected]" }
    ],
    "score": 88,
    "grade": "A",
    "scoreBreakdown": {
        "contactReachability": 22,
        "businessLegitimacy": 20,
        "onlinePresence": 18,
        "websiteQuality": 16,
        "teamTransparency": 12
    },
    "signals": [
        { "signal": "Multiple email addresses found", "category": "contactReachability", "points": 10, "detail": "3 emails discovered" },
        { "signal": "Phone number present", "category": "contactReachability", "points": 8, "detail": "+420 255 000 222" },
        { "signal": "Social media profiles found", "category": "onlinePresence", "points": 8, "detail": "4 platforms linked" },
        { "signal": "Team members listed", "category": "teamTransparency", "points": 10, "detail": "2 named contacts with titles" }
    ],
    "address": "Vodickova 704/36, 110 00 Prague, Czech Republic",
    "cmsDetected": "Next.js",
    "techSignals": ["React", "Next.js", "Google Analytics", "Intercom"],
    "pipelineSteps": ["contact-scraper", "email-pattern-finder", "lead-qualifier"],
    "processedAt": "2025-06-15T14:30:00.000Z"
}

Output Fields

Programmatic Access (API)

Python

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("ryanclinton/b2b-lead-gen-suite").call(run_input={
    "urls": ["stripe.com", "hubspot.com", "notion.so"],
    "maxPagesPerDomain": 8,
    "minScore": 50,
})

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

JavaScript

import { ApifyClient } from "apify-client";

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

const run = await client.actor("ryanclinton/b2b-lead-gen-suite").call({
    urls: ["stripe.com", "hubspot.com", "notion.so"],
    maxPagesPerDomain: 8,
    minScore: 50,
});

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

cURL

# Start a run
curl -X POST "https://api.apify.com/v2/acts/ryanclinton~b2b-lead-gen-suite/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "urls": ["stripe.com", "hubspot.com"],
    "maxPagesPerDomain": 8,
    "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

The B2B Lead Generation Suite runs a three-step sequential pipeline. Each step calls a dedicated Apify actor via Actor.call() and waits for it to complete before starting the next step.

                    ┌──────────────────────────────────────┐
                    │  B2B Lead Generation Suite            │
                    │  (Orchestrator)                       │
                    └──────────┬───────────────────────────┘
                               │
                    ┌──────────▼───────────────────────────┐
  Step 1 (Required) │  Website Contact Scraper              │
                    │  • Crawls company websites             │
                    │  • Extracts emails, phones, contacts   │
                    │  • Discovers social media links         │
                    └──────────┬───────────────────────────┘
                               │ emails + contact names
                    ┌──────────▼───────────────────────────┐
  Step 2 (Optional) │  Email Pattern Finder                 │
                    │  • Receives emails as known samples    │
                    │  • Website scraping DISABLED (already  │
                    │    scraped in Step 1)                   │
                    │  • GitHub commit search ENABLED         │
                    │  • Detects naming convention            │
                    │  • Generates predicted emails           │
                    └──────────┬───────────────────────────┘
                               │ all upstream data
                    ┌──────────▼───────────────────────────┐
  Step 3 (Optional) │  B2B Lead Qualifier                   │
                    │  • Receives emails, phones, contacts,  │
                    │    social links, and pattern data via   │
                    │    pipelineData parameter               │
                    │  • Crawls website for quality signals   │
                    │  • Scores 0-100 across 5 categories    │
                    │  • Assigns letter grade A-F             │
                    └──────────┬───────────────────────────┘
                               │
                    ┌──────────▼───────────────────────────┐
                    │  Merge + Deduplicate + Sort + Filter   │
                    │  • Union emails/phones across steps     │
                    │  • Merge social links (Step 1 priority) │
                    │  • Sort by score (highest first)        │
                    │  • Remove leads below minScore          │
                    └──────────────────────────────────────┘

Data Flow Between Steps

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

• Scraped emails are passed as knownEmails with matched contact names for attribution.
• Contact names are passed as names for email address generation.
• Website scraping is disabled (searchWebsite: false) to avoid redundant crawling.
• GitHub commit search stays enabled as an additional email discovery source.

Steps 1+2 → Step 3 (Both → Lead Qualifier):

• All upstream data is packaged into a pipelineData array indexed by domain.
• Each entry includes: emails, phones, contacts, social links, detected pattern, and pattern confidence.
• The qualifier uses this to enrich its scoring without re-extracting data that was already found.

Merge Phase:

• Emails from Steps 1 and 3 are unioned via a Set for deduplication.
• Phones from Steps 1 and 3 are unioned via a Set for deduplication.
• Social links from Step 1 take priority; Step 3 links fill in missing platforms only.
• Pattern data and scoring data are attached from their respective steps (null if skipped).
• Results are sorted by score descending, then filtered by minScore.

Scoring Reference

When Step 3 (Lead Qualifier) runs, each lead is scored across five categories with point caps:

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

How Much Does It Cost?

The B2B Lead Generation Suite is an orchestrator that calls three sub-actors, so the total cost depends on which pipeline steps are enabled and how many pages are crawled per domain.

The orchestrator itself uses only 256 MB of memory and minimal compute. Most of the cost comes from the sub-actor runs, which each consume their own compute resources. Processing 100 leads through the full pipeline typically costs $1-3 in total platform credits.

Apify's free tier includes $5 of monthly platform credits, which is enough to process approximately 150-500 leads depending on configuration.

Tips

1. Start with a small batch when testing a new set of domains. Run 3-5 URLs through the full pipeline first to verify the output quality before processing hundreds.

2. Use the minimum score filter to focus on high-quality leads. Setting minScore to 50 or higher eliminates domains with thin contact information or low business legitimacy signals, saving you time reviewing junk leads.

3. Skip the qualifier for speed when you already know the companies are legitimate (e.g., a curated list from LinkedIn Sales Navigator). The contact scraper and pattern finder alone give you actionable email data much faster.

4. Increase pages per domain for large enterprise websites where contacts may be buried deep. Setting maxPagesPerDomain to 10-15 finds more email addresses on sites with complex navigation structures.

5. Combine with the HubSpot Lead Pusher to automatically push enriched leads into your CRM. Run this actor first, then feed the dataset into HubSpot Lead Pusher to create contacts and companies in HubSpot without manual data entry.

6. Schedule weekly runs with the Apify Scheduler to continuously enrich new batches of prospect domains as they come in from your marketing or sales pipeline.

Limitations

• HTML-only crawling. All pipeline steps use CheerioCrawler (HTML parsing without a browser). Websites that require JavaScript rendering to display contact information may return incomplete results.
• No email verification. Discovered and generated emails are not validated for deliverability. Generated emails are predictions based on the detected naming pattern and may not exist. Use Bulk Email Verifier to verify before outreach.
• Sequential pipeline. Steps run one after another, not in parallel. The full three-step pipeline takes 30-90 seconds per domain. Large batches (500+ domains) may approach timeout limits.
• Sub-actor dependency. This actor calls three Apify actors by name. If any sub-actor is temporarily unavailable or returns unexpected output, that step may fail (optional steps fail gracefully; the Contact Scraper is required).
• Pattern detection needs samples. Email pattern detection accuracy depends on how many sample emails are found in Step 1. Domains with zero or one discovered email produce low-confidence or no pattern results.
• Scoring is deterministic. Lead scores are based on observable website signals (presence of emails, social links, team pages, etc.), not AI analysis. The score reflects data availability, not company quality.

Responsible Use

This actor collects publicly visible information from company websites. 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 does not constitute consent to receive marketing communications.
• Respect robots.txt and rate limits. The actor uses CheerioCrawler with configurable concurrency and rate limiting. Default settings are conservative, but consider lowering crawl depth for websites that explicitly restrict scraping.
• 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.
• Do not scrape sensitive sites. Avoid using this tool on government agencies, healthcare providers, educational institutions, or other organizations where automated data collection may violate terms of service or regulations.

FAQ

How long does the full pipeline take per domain? With default settings (5 pages per step), the full three-step pipeline typically completes in 30-90 seconds per domain. The exact time depends on website complexity and response speed. Processing runs sequentially through all three steps, so skipping optional steps reduces run time proportionally.

Can I process hundreds of domains in one run? Yes. The actor passes the full list of URLs to each sub-actor, which processes them in parallel internally. However, very large batches (500+ domains) may approach the default 2-hour timeout. For extremely large lists, consider splitting into batches of 100-200 domains.

What happens if one sub-actor fails? The Contact Scraper is required and will abort the run if it fails entirely. The Email Pattern Finder and Lead Qualifier are optional -- if either fails, the pipeline continues and outputs the data from the steps that succeeded. Individual domain failures within a step do not block other domains.

Is the email pattern detection accurate? The Email Pattern Finder analyzes discovered emails to reverse-engineer the naming convention. Confidence scores above 0.7 are generally reliable. The accuracy depends on how many sample emails were found -- more samples mean higher confidence. Generated emails are predictions, not verified addresses.

What do the lead scores and grades mean? Scores range from 0 to 100 across five categories: contact reachability (are emails and phones available?), business legitimacy (is this a real operating business?), online presence (social media activity), website quality (modern CMS, SSL, fast loading), and team transparency (named people with titles). Grades map to score ranges: A (90-100), B (75-89), C (60-74), D (40-59), F (0-39).

What data is passed between pipeline steps? The orchestrator feeds forward data intelligently. Step 1 emails become "known samples" for Step 2 pattern detection. Contact names from Step 1 become candidates for Step 2 email generation. All upstream data (emails, phones, contacts, social links, patterns) feeds into Step 3 via a pipelineData parameter so the qualifier does not re-extract data already found.

Can I run just the contact scraper without the other steps? Yes. Set skipEmailPatternFinder: true and skipLeadQualifier: true. This gives you email, phone, and contact data only, at roughly one-third the cost and time of the full pipeline. Alternatively, use Website Contact Scraper directly.

Integrations

The B2B Lead Generation Suite works with the full Apify platform ecosystem:

• Apify API -- Trigger pipeline runs programmatically and retrieve enriched leads as JSON via https://api.apify.com/v2/acts/ryanclinton~b2b-lead-gen-suite/runs. Build automated prospecting workflows that enrich new domains nightly.

• Zapier -- Connect to 5,000+ apps. Trigger a lead enrichment run when a new company is added to your CRM, then push the scored results back into Salesforce, HubSpot, or Pipedrive automatically.

• Make (Integromat) -- Build multi-step workflows that take prospect lists from Google Sheets, run them through the pipeline, filter by score, and route qualified leads into outreach sequences.

• Google Sheets -- Export the enriched dataset directly to Google Sheets. Key fields like domain, emails, score, grade, and contacts map cleanly into spreadsheet columns for team review and collaboration.

• Webhooks -- Configure a webhook URL to receive enriched leads as soon as the pipeline completes, enabling real-time lead routing into custom applications.

• Scheduled Runs -- Set up daily or weekly schedules to process new batches of prospect domains automatically. Combine with the Apify dataset API to stream results into your data warehouse.

Related Actors

Build a complete B2B sales intelligence stack by combining this actor with other tools from ryanclinton on the Apify Store: