I ran this against the SaaStr Annual attendee list last spring — 4,200 names scraped from the public speaker page, exhibitor directory, and LinkedIn event RSVPs. After the enrichment waterfall, 1,847 had verified work emails. Of those, 312 matched our ICP exactly. Our SDR team sent 287 sequences (25 bounced on manual review). We booked 41 meetings in the 10 days before the event.
That's a 14.3% meeting rate on a conference we didn't even attend.
Here's every step.
The Data Is Already Public — Most SDRs Just Don't Know Where to Look
Conference organizers publish more than they realize. A typical mid-size industry conference exposes:
- Speaker page: Name, company, job title, sometimes LinkedIn URL
- Exhibitor/sponsor directory: Company name, booth number, website
- Agenda page: Speaker bios, often richer than the main speaker page
- LinkedIn event page: "Attending" list (partially public depending on privacy settings)
- Mobile event apps like Whova, Bizzabo, Hopin: These often expose attendee lists via their APIs with minimal auth
Speaker and exhibitor data is the cleanest. These people opted in to being listed. LinkedIn event RSVPs are grayer — scraping those requires Phantombuster's LinkedIn event actors or a custom Playwright script running behind your own LinkedIn session. I'd stop there; event apps behind paywalled logins are a different compliance conversation.
The 48-hour window in the title is real but tight. You need the extraction done 5–7 days pre-event, the enrichment waterfall run the same day, ICP scoring done the next morning, and sequences live within 48 hours of extraction. Miss that window and reply rates drop sharply.
Extracting the List Before It Disappears
Conference websites restructure pages post-event and speaker pages sometimes vanish within days. I always extract 3–4 weeks out.
For public pages, I use Apify's pre-built conference scraper actors. They handle pagination, lazy-load JavaScript, and nested speaker grids well. For custom conference sites that aren't covered, a 40-line Playwright script usually handles it:
from playwright.sync_api import sync_playwright
import json
results = []
with sync_playwright() as p:
browser = p.chromium.launch()
page = browser.new_page()
page.goto("https://conference-site.com/speakers")
page.wait_for_selector(".speaker-card")
cards = page.query_selector_all(".speaker-card")
for card in cards:
name = card.query_selector(".name").inner_text()
company = card.query_selector(".company").inner_text()
title = card.query_selector(".title").inner_text()
results.append({"name": name, "company": company, "title": title})
browser.close()
with open("speakers.json", "w") as f:
json.dump(results, f)
Output: name, company, title, sometimes LinkedIn URL or headshot URL. That's your seed data.
For exhibitor lists, the structure is usually a grid with company name and website. Extract those, then normalize company domains (strip www., handle redirects). You now have a list of target companies; finding contacts within them is a separate enrichment step below.
The Enrichment Waterfall (Not a Single API Call)
This is what the generic blog posts skip. No single data provider covers everyone. Running one API and calling it done means missing 30–40% of valid contacts.
Here's the waterfall I've settled on after testing it on ~12 conference lists:
| Step | Provider | What you're enriching | Hit rate (approx.) | Cost per record |
|---|---|---|---|---|
| 1 |
PDL /person/enrich
|
Name + company → full profile | 55–65% | $0.04 |
| 2 | Apollo bulk enrichment | Missed records from PDL | +15–20% cumulative | $0.10 |
| 3 | Hunter.io domain search | Missed records, email-only | +5–8% cumulative | $0.012 |
| 4 | RocketReach | Still-missing high-value targets | +3–5% cumulative | $0.25 |
| 5 | Manual LinkedIn lookup | C-suite / must-have accounts | 100% on effort | ~$2–5 time cost |
Rate limiting matters here. PDL's /person/enrich endpoint allows 1,000 requests/minute on standard plans. If you're batching a 3,000-person list, naively fire-hosing it will hit 429s and corrupt your match confidence scores. I implement a token bucket at 900 req/min with exponential backoff: start retry at 2 seconds, double each time, cap at 60 seconds. That alone recovered an 18% data loss I was seeing in early runs.
Apollo's bulk enrichment is less of a rate-limit concern since it's async batch, but the CSV upload has a 10,000-row limit per job. For large conferences, split the file.
After enrichment, run ZeroBounce on everything before any sequence import. A 3% bounce rate tanks sender reputation on a cold domain. Conference-sourced lists typically run 6–9% invalid without validation — higher than standard purchased lists because job-change lag isn't captured well in most enrichment databases.
ICP Scoring Before You Write a Single Email
Raw enriched data still needs filtering or your SDRs waste sequences on irrelevant contacts. I run a simple scoring function against the enriched output:
Score each record 0–100:
- Job title contains VP / Director / Head / C-suite: +40
- Seniority level = "senior" or above (PDL field): +20
- Company employee count 50–5,000: +20
- Industry matches target list: +15
- Has verified email (not catch-all): +5
Anything above 60 goes to Tier 1 sequences. 40–59 gets a lighter Tier 2 (2 touches, more generic). Below 40: skip or push to a nurture list.
For exhibitors specifically, Grata is worth a separate lookup. Exhibitors are often mid-market private companies that don't show clean employee counts or funding signals in PDL or Apollo. Grata's private company data fills that gap reliably.
Vendelux is worth knowing if you're running conference-sourced prospecting across multiple events per year. It aggregates attendee and exhibitor signals across 160k+ events and surfaces which target accounts are likely at which shows before registration opens — useful for planning extraction runs in advance rather than scrambling 4 weeks out.
Pre-Event vs. Post-Event: The Timing Window That Changes Reply Rates
Based on tests across five conference cycles:
| Outreach timing | Reply rate | Meeting rate | Notes |
|---|---|---|---|
| 3–4 weeks pre-event | 8–11% | 3–4% | Too early, low urgency |
| 5–7 days pre-event | 18–24% | 10–14% | Best window — people finalizing schedules |
| Same week (event running) | 6–9% | 4–6% | Inboxes buried; "Are you at [event]?" helps |
| 1–3 days post-event | 14–18% | 8–11% | "Caught your talk" framing works here |
| 2+ weeks post-event | 4–7% | 2–3% | Context fades fast |
The 5–7 days before window is consistently the highest performer. Subject lines that reference the specific conference ("Heading to [Event] next week?") outperform generic cold subject lines by roughly 30% in my tests.
Post-event sequences work best when they're personalized — referencing a session the prospect spoke at, a panel they were on, or a topic from the conference hashtag feed. Generic "hope you had a great show" emails perform no better than standard cold outreach.
ROI Math: What a $400 Conference Prep Sprint Actually Buys
For a 2,000-person conference list:
| Line item | Cost |
|---|---|
| Apify scraping (3–4 actor runs) | $12 |
| PDL enrichment (1,200 hits × $0.04) | $48 |
| Apollo enrichment (400 hits × $0.10) | $40 |
| Hunter.io domain search (200 hits × $0.012) | $2.40 |
| ZeroBounce validation (1,800 emails × $0.008) | $14.40 |
| SDR time (3 hrs ICP scoring + list setup @ $50/hr) | $150 |
| Total | ~$267 |
At an average deal size of $25,000 and 10% close rate on meetings, 2 closed deals from 41 meetings = $50,000 revenue. That's a 187x return on the prep spend.
This math degrades fast if your enrichment is sloppy (high bounce rates, low ICP match) or if your timing is off. The quality of extraction and precision of ICP scoring are where most teams leave money behind — not the outreach copy.
What I Actually Use
For the full workflow:
- Extraction: Apify for covered conferences, Playwright for custom sites
- Company intelligence on exhibitors: Grata for private/mid-market accounts, Apollo for public companies
- Enrichment waterfall: PDL first (best programmatic API, highest coverage), Apollo fallback, Hunter.io for domain-based email finding
- Email validation: ZeroBounce — tested NeverBounce too and they're comparable; ZeroBounce wins on bulk pricing at high volume
- ICP scoring + SDR review: Custom Python script feeding into a Clay table before sequence import
- Multi-event planning: Vendelux if you're running this across 5+ conferences per year
For social profile enrichment specifically — when a speaker has only their Twitter or Facebook handle listed, not a company domain — Ziwa has been faster for me than PDL's direct API for matching those social handles back to a verified business email. Worth knowing if you work events where speakers promote primarily on social rather than LinkedIn.
The full pipeline takes 3–4 hours to set up the first time per conference. After that, 45 minutes to run it again for the next event on your calendar.
Top comments (0)