# Linktree Email Scraper Fast Advanced And Cheapest (`solid-scraper/linktree-email-scraper-fast-advanced-and-cheapest`) Actor

🚀 Extract targeted emails from Linktree fast with advanced filtering. Get the cheapest, high-quality leads for sales, agencies, and growth teams—ready instantly for outreach. 📧⚡ Save time and boost conversions with Linktree Email Scraper!

- **URL**: https://apify.com/solid-scraper/linktree-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [SolidScraper](https://apify.com/solid-scraper) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

### Linktree Email Scraper - Fast, Advanced and Cheapest 📬

**Linktree Email Scraper - Fast, Advanced and Cheapest** is an Apify actor that extracts email addresses from Linktree based on the keywords (and optional filters) you specify. If you’re looking for a **Linktree email scraper** to build a **Linktree email list builder** or run **automated Linktree email scraper** lead sourcing, this tool helps you find relevant contacts faster—using keyword-focused searching and **custom email-domain filters** like `@gmail.com` to improve relevance—saving you hours of manual work.

Whether you’re a marketer, researcher, or data analyst, this Linktree scraper tool is designed to help you **extract emails from Linktree** at scale and keep your results organized as you iterate on keyword and domain strategies.

***

### Why choose Linktree Email Scraper - Fast, Advanced and Cheapest?

| Feature | Benefit |
| --- | --- |
| ✅ Keyword-based email discovery | Helps you target outreach by searching for emails using the keywords you provide |
| ✅ Custom email-domain filters | Produces cleaner lead lists by restricting results to domains you care about (e.g. `@gmail.com`) |
| ✅ Structured dataset output | Saves results with consistent fields like `keyword`, `title`, `url`, and `email` for easy export |
| ✅ Resilient runs with resume support | Continues from saved progress instead of restarting from scratch |
| ✅ Max-results control | Lets you cap scraping with `maxEmails` to control runtime and costs |
| ✅ Built-in proxy support | Improves reliability by supporting proxy-based scraping (with fallbacks if needed) |

***

### Key features

- 🔎 **Targeted Linktree email harvesting**: Extracts emails from publicly available sources using your provided `keywords`
- 🧩 **Domain-filtered results**: Uses your `customDomains` list to focus on the email providers and domains you want (e.g. `@yahoo.com`)
- ♻️ **Resume-enabled scraping**: Saves progress continuously so you can pick up where the actor left off
- 🛡️ **Resilience for real-world scraping**: Includes retries/fallback logic to keep runs moving when results are sparse or pages fail
- 📊 **Structured output for analysis**: Pushes rows containing `network`, `keyword`, `title`, `description`, `url`, and `email` into the dataset
- 💾 **Incremental dataset writes**: Each found email is pushed immediately, reducing the chance of losing data during long runs
- 🎯 **Cost-aware limits**: Stops once it reaches your `maxEmails` limit (when provided)

***

### Input

Provide input via an `input.json` file. Example structure:

```json
{
  "keywords": ["manager", "founder"],
  "location": "United States",
  "customDomains": ["@gmail.com", "@yahoo.com"],
  "maxEmails": 50
}
```

#### Input Fields

| Field | Required | Description |
| --- | --- | --- |
| `keywords` | Yes | A list of keywords or queries used to find relevant Linktree leads and extract email addresses |
| `location` | No | Optional location filter to narrow results (leave empty for no location constraint) |
| `customDomains` | No | List of email domains to focus on (for example `@gmail.com` or `@yahoo.com`) |
| `maxEmails` | No | Maximum number of emails to collect; the actor stops once this limit is reached (doesn’t guarantee the exact number, but helps control runtime) |

***

### Output

The actor saves each found lead’s contact data into the dataset in JSON format.

Example output row:

```json
{
  "network": "Linktree.com",
  "keyword": "manager",
  "title": "No title",
  "description": "No data",
  "url": "No URL",
  "email": "example@gmail.com"
}
```

#### Output Fields

| Field | Type | Description |
| --- | --- | --- |
| `network` | string | The source network label used for every row (`Linktree.com`) |
| `keyword` | string | The keyword that produced the result |
| `title` | string | The result title text (or `No title` if missing) |
| `description` | string | Extracted text/description from the result (or `No data` if missing) |
| `url` | string | The result URL (or `No URL` if missing) |
| `email` | string | The extracted email address |

Note: the dataset view is configured to display the fields `keyword`, `title`, `description`, `url`, and `email`.

***

### How to use Linktree Email Scraper - Fast, Advanced and Cheapest (via Apify Console)

1. **Open Apify Console**: Log in at https://console.apify.com and open the Actors section.
2. **Find your actor**: Search for **Linktree Email Scraper - Fast, Advanced and Cheapest** and open its actor page.
3. **Go to the INPUT tab**: You’ll see the built-in form. You can also paste a JSON input.
4. **Set your `keywords`**: Enter the job titles/queries you want (for example `manager`, `founder`). `keywords` is required.
5. **Optionally refine results**:
   - Add `location` if you want location-filtered scraping.
   - Add `customDomains` (like `@gmail.com`) to improve lead relevance.
6. **Control runtime with `maxEmails`**: Set `maxEmails` to cap how many unique emails you want to collect. Bigger limits can take longer.
7. **Run the actor**: Start the run and monitor logs. The actor writes results incrementally to the dataset as it finds emails and will resume from saved progress if interrupted.
8. **Export your results**: When finished, open the dataset and export as JSON/CSV from the dataset UI.

No coding required—get accurate results in minutes with this SEO-optimized **Linktree email scraper**.

***

### Advanced features & SEO optimization

- 🧠 **Engineered for Linktree email list building**: Designed to excel at **Linktree leads scraper** workflows by combining `keywords` with `customDomains` filtering (e.g., `@gmail.com`) for cleaner **Linktree contact email finder** outputs
- 🔁 **Resume and progress persistence**: Keeps a saved cursor and `seen_emails` list, so you don’t waste time repeating work across runs
- 🕒 **Timeout-friendly scaling**: You can extend the timeout via **Run Options** (default: 3600 seconds / 1 hour) for larger jobs
- 📋 **Stop conditions that protect performance**: The actor stops when it reaches `maxEmails`, when result pages yield no new emails for a while, or when it detects low-yield conditions
- 💡 **Input strategy guidance**: If you get limited results, the actor behavior and logs suggest widening keywords, adding similar terms, and expanding domains—helpful for any **fast Linktree email scraper** campaign iteration

***

### Best use cases

- 📈 **Lead generation for niche audiences**: Use `keywords` like titles/roles to extract emails from Linktree and quickly build a targeted outreach list
- 🧾 **B2B enrichment for sales teams**: Filter by company-leaning domains using `customDomains` to improve deliverability-focused **Linktree email harvesting**
- 🔎 **Research and competitive intel**: Collect contact signals from public Linktree pages to analyze who is accessible and how they present contact info
- 🎯 **Marketing segmentation**: Build multiple email lists by running the **Linktree scraper tool** with different keyword sets and domain filters
- 🧑‍💻 **Automated pipelines**: Feed scraped results into downstream workflows (CRM import, spreadsheet enrichment, or analytics)
- 📊 **Data analysts’ email dataset creation**: Combine structured rows (`keyword`, `title`, `url`, `email`) for further cleaning and analysis

***

### Technical specifications

**Supported Input Formats**

- ✅ `keywords` (array of strings)
- ✅ `location` (string)
- ✅ `customDomains` (array of strings)
- ✅ `maxEmails` (integer; minimum 1, maximum 10000)

**Proxy Support**

- ✅ Includes built-in proxy support for reliable scraping

**Retry Mechanism**

- ✅ Includes retries/fallback logic for resilience when results are limited or pages fail

**Dataset Structure**

- ✅ Dataset title: **Linktree Emails Dataset**
- ✅ Each pushed row contains: `keyword`, `title`, `description`, `url`, `email` (plus `network`)

**Rate Limits & Performance**

- ⏱️ Performance depends on how quickly new emails are found and how many pages are needed
- 🎯 The actor stops when it reaches `maxEmails` (when provided), which helps manage runtime

**Limitations**

- ❌ Results depend on publicly available email addresses and what’s discoverable using your provided inputs
- ❌ If you request too narrow a set of keywords or domains, the actor may return fewer emails than your target

***

### FAQ

#### How many emails can I extract with Linktree Email Scraper - Fast, Advanced and Cheapest?

If you’re running as a free user on Apify, the actor enforces a maximum of **100 emails**. If you set `maxEmails` above that limit (or leave it unlimited), it will cap results to 100. Paid users can run without that restriction.

#### Do I need to provide keywords?

Yes. The input field `keywords` is required. The actor uses your keyword list to search for relevant Linktree leads and extract email addresses.

#### What does `customDomains` do?

`customDomains` lets you restrict extracted emails to the domains you choose (for example `@gmail.com` and `@yahoo.com`). This is a key part of making your **Linktree email scraper** results more relevant.

#### Can I resume a run if it gets interrupted?

✅ Yes. The actor saves progress continuously and keeps track of previously seen emails and a cursor, so reruns can continue instead of starting from zero.

#### Is an API available?

This actor is designed for Apify dataset consumption and can be run and automated from Apify workflows. The output is written incrementally into the dataset as rows, which you can export afterward.

#### What fields will I receive in the dataset?

Each dataset row includes `keyword`, `title`, `description`, `url`, and `email`. The row also includes `network` set to `Linktree.com`.

#### Where does the actor store results?

Results are pushed incrementally to the dataset named **Linktree Emails Dataset**. You can open it in the Apify Console after the run finishes and export the data as JSON/CSV.

#### Is it okay to use the extracted emails for outreach?

✅ The actor collects information only from **publicly available sources**. You are responsible for complying with applicable laws and regulations (including spam/anti-spam rules) and each website’s terms while using the data.

***

### Support & feature requests

Want to improve your **Linktree email scraper** workflow? Share feedback or request enhancements with the team behind Linktree Email Scraper - Fast, Advanced and Cheapest.

- 💡 **Feature Requests**: Examples include more output options (extra fields), better export formats, additional filtering controls, or CRM-friendly transformations
- 📧 **Contact**: Email <dataforleads@gmail.com>

Your feedback helps shape what we build next for this **Linktree leads scraper**.

***

*If you want the most comprehensive and SEO-optimized **Linktree Email Scraper - Fast, Advanced and Cheapest**, run it with targeted `keywords` and `customDomains` for the best results.*

***

### Disclaimer

**This tool accesses only publicly available sources.** It does not access private profiles, authenticated data, or password-protected content.

You are responsible for ensuring your use complies with applicable laws and regulations (for example, GDPR/CCPA where relevant), spam and marketing regulations, and the target platform’s terms of service.

For data removal requests, contact <dataforleads@gmail.com>. Please use this tool responsibly, ethically, and for legitimate purposes only.

# Actor input Schema

## `keywords` (type: `array`):

A list of keywords or queries to search for.

## `location` (type: `string`):

Location to filter search results.

## `customDomains` (type: `array`):

List of custom email domains

## `maxEmails` (type: `integer`):

Maximum number of emails to collect. The scraper will stop once this limit is reached. Setting a higher limit allows for more potential results but doesn't guarantee reaching that number. This helps save costs by controlling scraping time.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ],
  "maxEmails": 20
}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "keywords": [
        "manager",
        "founder"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("solid-scraper/linktree-email-scraper-fast-advanced-and-cheapest").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": [
        "manager",
        "founder",
    ],
    "location": "",
    "customDomains": [
        "@gmail.com",
        "@yahoo.com",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("solid-scraper/linktree-email-scraper-fast-advanced-and-cheapest").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "manager",
    "founder"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com",
    "@yahoo.com"
  ]
}' |
apify call solid-scraper/linktree-email-scraper-fast-advanced-and-cheapest --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,solid-scraper/linktree-email-scraper-fast-advanced-and-cheapest"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/m6oJjYIvEnMQDS7zc/builds/B8TrMsSc0u1CdddrD/openapi.json