How I Built a Linktree, Beacons & Bio Email Scraper with Apify

1. Introduction

Collecting emails from Linktree, Beacons, and other bio links is often a tedious and time-consuming task. As a developer and freelancer working with lead generation projects, I faced this problem firsthand: manually navigating hundreds of profiles just to extract a few emails is inefficient and error-prone.
To solve this, I built a Linktree, Beacons & Bio Email Scraper Actor using Apify. It automates the process, reliably collects emails from multiple platforms, and provides structured outputs for marketing, data engineering, and business intelligence purposes.
This article details the journey: the challenges I faced, the design of the Actor, lessons learned, and tips for anyone looking to build production-grade scraping solutions.

2. Problem Context & Motivation

Manual email collection from bio links presents several challenges:

• Dynamic pages: Platforms like Linktree often use JavaScript to load content asynchronously. Simple HTML scraping fails here.
• Anti-scraping measures: Repeated requests can trigger rate limits or captchas.
• Scale: For real lead-generation projects, you often need hundreds or thousands of emails daily—manual collection is not an option. I needed a solution that was fast, scalable, and reliable, and that could handle these technical challenges without breaking.

3. Actor Overview

Architecture and Workflow
The Actor is built on Apify and Crawlee, combining headless browser automation with structured data extraction. Here’s a high-level workflow:

1. Input: A list of Linktree, Beacons, or other bio URLs.
2. Navigation: Actor launches a headless browser to visit each URL.
3. Email Extraction: Uses DOM selectors and regex patterns to identify valid email addresses.
4. Anti-blocking: Rotates proxies and applies request throttling to avoid detection.
5. Output: Saves results in JSON or CSV with details: URL, email, timestamp.

Input, Output, and Configuration Options

• Input: List of profile URLs (CSV, JSON, or manually typed).
• Output: JSON, CSV, or Google Sheets integration.
• Configurable Options: Maximum pages per run Timeout per request Proxy rotation (on/off) Output file format This flexibility allows the Actor to handle both small projects and large-scale campaigns.

4. Implementation Details

Handling Dynamic Content
Linktree and Beacons often load content via JavaScript. Initially, I tried simple HTTP requests, but emails were missing in the HTML response. Switching to Crawlee with Playwright solved the issue:

import { PlaywrightCrawler } from 'crawlee';

const crawler = new PlaywrightCrawler({
requestHandler: async ({ page, request, enqueueLinks, log }) => {
await page.goto(request.url);
const emails = await page.$$eval('a[href^="mailto:"]', els => els.map(e => e.href));
console.log(Found emails for ${request.url}: ${emails});
}
});

await crawler.run(['https://linktr.ee/example']);

This approach ensures the Actor captures all visible emails, even on dynamic pages.
Anti-Blocking Strategies
During early tests, some accounts triggered rate limits. To fix this, I added:
Proxy rotation
Randomized delays between requests
Error retries for failed pages
These measures increased the success rate to 99.6% over thousands of URLs.

5. Metrics & Results

To evaluate the Actor in a real-world scenario, I ran it against a dataset of 1,800+ URLs. The results showed strong reliability while keeping the cost of each run predictable:

99.6% success rate
1,816 emails collected
$14.47 total cost per run
$23.76 profit generated per run from the collected leads

These results demonstrated that the Actor could process large batches of URLs reliably while remaining cost-effective for lead-generation workflows.

This shows the Actor is not only technically reliable but also economically valuable for lead-generation workflows.

6. Lessons Learned

Building this Actor taught me several important lessons:
JavaScript rendering matters: Always test pages in a headless browser when dealing with dynamic content.
Anti-blocking is critical: Even simple rotation and throttling drastically improve success rates.
First-person debugging insights: Logging actual page content during development helped identify hidden issues.
Scalable design: Structuring input/output for batch processing makes the Actor production-ready.

7. Who Can Benefit

This Actor is useful for:

• Developers looking to automate repetitive data collection tasks
• Marketers and sales teams needing up-to-date email lists
• Data engineers building pipelines that integrate multiple data sources
• The architecture can also be adapted for other bio link platforms or email collection projects with similar challenges.

8. Conclusion

Automating email extraction from Linktree, Beacons, and bio links is no longer a manual nightmare. By using Apify and Crawlee, I built a reliable, scalable, and cost-effective Actor that delivers real-world results.
If you plan to build your own Actor, remember: focus on handling dynamic content, preventing blocks, and structuring your data pipeline. Sharing these lessons ensures other developers can build production-grade automation with confidence.

9. Next Steps

• Test the Actor on new bio platforms
• Add AI-powered validation to filter incorrect emails
• Explore integrations with CRMs and email marketing tools