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

📧 Extract email addresses fast with Linktree Email Scraper—Fast, Advanced & affordable. Automate lead mining from Linktree links to grow outreach lists quickly. ✅ Great for sales, marketing & recruitment. 🚀🔍

- **URL**: https://apify.com/scraperoka/linktree-email-scraper-fast-advanced-and-cheapest.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (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 🎯

Manually visiting Linktree pages to copy emails wastes hours you don’t have. **Linktree Email Scraper - Fast, Advanced and Cheapest** finds and extracts email addresses from Linktree using your keywords and email-domain filters. This Linktree email scraper (Linktree email extractor tool, Linktree contacts scraper) is ideal for marketers, recruiters, and growth teams that need leads at speed—often thousands of records in minutes.

***

### What You Get: Sample Output

Here's a sample record from a single run:

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

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network (`Linktree.com`) for every row in your dataset |
| `keyword` | string | The keyword you used to generate that match, so you can segment outreach |
| `title` | string | The result title text captured alongside the email candidate |
| `description` | string | The surrounding text where the email was extracted from (useful for validation/notes) |
| `url` | string | The URL associated with the extracted contact record |
| `email` | string | The extracted email address you can use for lead outreach |
| `error_message` | string | If something goes wrong, logs show failures around data pushing (see FAQ for error behavior) |
| `status` | string | Indirectly reflected via run logs (the actor stops when it reaches limits or runs out of results) |
| `maxEmails` | integer | Your run’s cap on how many unique emails to collect (helps control cost and time) |
| `customDomains` | array | The email domains you filtered for (e.g. `@gmail.com`, `@yahoo.com`) |
| `location` | string | Optional location filter input you provide to refine what gets returned |
| `keyword` / `email` uniqueness | behavior | Emails are deduplicated during the run via a `seen_emails` set |

Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.

***

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

There are a lot of ways to pull data from publicly available web pages—here’s what sets Linktree Email Scraper - Fast, Advanced and Cheapest apart.

#### Keyword and domain filtering for targeted leads

You control what gets collected by providing `keywords` and `customDomains` (like `@gmail.com`). That means this Linktree email scraper can focus on the contacts that match your outreach criteria instead of returning everything indiscriminately.

#### Clear output you can use immediately

Every pushed row includes `keyword`, `title`, `description`, `url`, and `email`, written to the dataset as results are found. This makes Linktree email extractor tool outputs easy to filter, deduplicate, and import into your workflow.

#### Built-in resume and progress saving

If a run is interrupted, the actor maintains progress so you can continue later without starting from zero. That’s especially helpful for bulk email extraction from Linktree and long-running searches.

#### Controlled cost with a max email cap

You can set `maxEmails` to cap how many unique emails to collect. The actor will stop once this limit is reached, helping you manage run duration and cost while testing different keyword/domain combinations.

***

### Configuring Your Run

Drop this into your `input.json` to get started:

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

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords used to find relevant Linktree leads for email extraction |
| ↳ (array item) | ✅ | Each item in the list is treated as a keyword for matching |
| `location` | ⬜ | Optional location text to filter the results you want to target |
| `customDomains` | ⬜ | Email domains the actor should look for (for example, `@gmail.com`, `@yahoo.com`) |
| ↳ (array item) | ⬜ | Each item is a domain filter used when extracting emails |
| `maxEmails` | ⬜ | Maximum number of unique emails to collect; helps you control run time and cost |

***

### Core Capabilities

#### Email extraction from Linktree pages

Linktree Email Scraper - Fast, Advanced and Cheapest extracts email addresses from Linktree using your provided `keywords` and `customDomains`. If you want a Linktree email harvesting software that focuses on specific providers (like Gmail or Yahoo), this setup is a direct fit.

#### Flexible targeting with keywords, location, and domains

You can refine results by mixing multiple `keywords`, adding a `location` filter, and specifying one or more `customDomains`. This approach supports both broad exploration and tighter targeting when building a Linktree email list builder.

#### Resilient execution with run recovery

The actor saves progress as it goes, so it can resume later based on saved cursor state and already-seen emails. This resilience helps keep bulk runs efficient and reduces wasted time when you iterate.

#### Incremental dataset writing as results arrive

Rows are pushed to the dataset as emails are found, including contextual fields like `keyword`, `title`, `description`, and `url`. That means you can start working with partial outputs immediately instead of waiting for the end of the run.

#### Scale control with a max unique email limit

Use `maxEmails` to stop after collecting enough unique emails. This keeps your Linktree contacts scraper runs predictable, which is especially useful for testing outreach segments before scaling up.

Overall, this advanced email scraper tool is designed to deliver usable Linktree lead generation output quickly and in a format you can act on right away.

***

### Who Gets the Most Out of This

Here’s how different teams put Linktree Email Scraper - Fast, Advanced and Cheapest to work:

**Outreach and growth marketers**\
They run bulk email extraction from Linktree using role-focused `keywords` (like manager or founder) and domain filters (like `@gmail.com`). The result is a segmented list of emails tied to the originating keyword, which speeds up campaign setup and reduces manual lead hunting.

**Recruiters and talent sourcers**\
They use targeted keywords and customDomains to find relevant contacts while ignoring unwanted providers. This helps recruiters quickly assemble a Linktree email list builder for candidate outreach and relationship-building.

**Lead generation specialists**\
They iterate on `keywords`, optional `location`, and `customDomains` to improve relevance over multiple runs. With `maxEmails` caps, they can run faster tests, compare results, and keep only the best-performing segments.

**Data analysts and researchers**\
They treat the dataset as structured records with consistent fields (`keyword`, `title`, `description`, `url`, `email`) for downstream cleaning and analysis. This Linktree email extractor tool supports repeatable experiments—vary keywords/domains and measure which segments yield the highest contact density.

**Automation and engineering teams**\
They trigger Linktree email harvesting software runs and pipe dataset exports into internal pipelines. Because results include contextual fields and a clear email field, it’s easier to connect this to CRM enrichment and outreach workflows without heavy post-processing.

***

### Step-by-Step: How to Use It

No coding needed. Here's how to run Linktree Email Scraper - Fast, Advanced and Cheapest from start to finish:

1. **Open the actor on Apify** — visit [console.apify.com](https://console.apify.com) and open the actor page for **Linktree Email Scraper - Fast, Advanced and Cheapest**.
2. **Enter your inputs** — set `keywords` (required), then optionally add `location`, `customDomains`, and `maxEmails`.
3. **Configure proxy settings** — choose your preferred proxy configuration in Run Options for reliable scraping at scale.
4. **Hit Run and watch the live log** — monitor progress while the actor collects unique emails up to your limit.
5. **View results in the dataset tab** — check the “Scraped Leads” dataset as records are pushed incrementally.
6. **Export as JSON, CSV, or Excel** — download the dataset from the Apify dashboard for your next step.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Linktree Email Scraper - Fast, Advanced and Cheapest plugs directly into your existing workflow.

You can export results from the Apify dataset tab as **JSON**, **CSV**, or **Excel**. That makes it straightforward to import into lead databases, spreadsheets, or BI tools.

For deeper automation, you can use Apify’s API capabilities to pull results programmatically and connect run completions to downstream steps like CRM updates and notifications. If you use no-code automation tools such as Zapier or Make, you can also push dataset exports into your tools via their integrations.

For the most up-to-date guidance on exports, API usage, and automation options, see Apify’s documentation at https://apify.com/docs/api.

***

### Pricing & Free Trial

Linktree Email Scraper - Fast, Advanced and Cheapest runs on the Apify platform, which offers a **free tier** — no credit card required to get started.

Free tier usage includes limited testing capacity, and you can run additional jobs after upgrading based on your needs. For exact current costs and plan limits, check the Apify pricing page on https://apify.com.

Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limiting pressure | Uses built-in proxy support for more reliable scraping |
| Long searches | Lets you control runtime impact via `maxEmails` and generous run timeout options |
| Partial completion | Saves progress so you can resume without losing already found emails |
| Deduplication | Prevents duplicate emails during a run using a `seen_emails` set |
| Dataset usability | Pushes consistent records with `keyword`, `title`, `description`, `url`, and `email` |

**Limitations:** This actor works with **publicly available data** and does not access login-gated content. Results depend on what email addresses are published on Linktree pages and on your keyword/domain targeting.

For enterprise-scale runs, contact us to discuss custom configurations.

***

### Frequently Asked Questions

#### Is there a free plan or trial?

Yes. Apify offers a free tier so you can test runs before scaling up. If you need more than the free limits, you’ll want a paid Apify plan.

#### Do I need to log in to Linktree to use this?

No. Linktree Email Scraper - Fast, Advanced and Cheapest extracts from publicly available data on Linktree pages, so you don’t need login credentials.

#### How accurate is the data?

Accuracy depends on what’s actually published on the target pages. The actor extracts email addresses found in the available page content and filters them based on the domains you provide in `customDomains`.

#### How many results can I get per run?

You control this with `maxEmails`, which sets the maximum number of unique emails to collect before stopping. Setting a higher limit increases potential coverage, but there’s no guarantee the target pages contain enough matching emails.

#### How often is the data updated / how fresh is it?

Freshness depends on when you run the actor. Each run captures what is publicly available at that moment, so rerunning at a later time can surface newly published emails.

#### Is this legal? Does it comply with GDPR / CCPA?

The actor works with **publicly available data**, but compliance depends on how you store and use the results. You’re responsible for GDPR, CCPA, platform Terms of Service, and any applicable local regulations.

#### Can I export results to Google Sheets or Excel?

Yes. You can export your dataset as JSON, CSV, or Excel directly from the Apify dashboard, and then import into tools like spreadsheets.

#### Can I run this on a schedule automatically?

Yes. You can set up scheduled runs using Apify’s scheduling options so the actor runs automatically on a defined schedule.

#### Can I access this via API?

Yes. You can trigger the actor and retrieve dataset results using Apify’s API. Full API documentation is available at https://apify.com/docs/api.

#### What happens if the actor hits an error?

If issues occur, the actor logs errors related to request handling and dataset pushing. Because it saves progress, you can often resume later rather than redoing the entire run from scratch.

***

### Need Help or Have a Request?

Got a question about Linktree Email Scraper - Fast, Advanced and Cheapest or want a new feature added? Reach out at <dataforleads@gmail.com>. We’re happy to help with setup questions, and we actively maintain the actor based on user feedback, including ideas like webhook notifications on completion or batch workflow improvements.

***

### Disclaimer & Responsible Use

*Linktree Email Scraper - Fast, Advanced and Cheapest is the fastest, most reliable way to extract Linktree contact emails — start your free run today.*

This actor collects **publicly available data** and does not access private accounts, login-gated content, or password-protected pages. It’s your responsibility to ensure compliance with GDPR, CCPA, platform ToS, and any applicable local regulations. For data removal requests, contact <dataforleads@gmail.com>. Use responsibly, ethically, and only for lawful purposes.

# 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("scraperoka/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("scraperoka/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("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 scraperoka/linktree-email-scraper-fast-advanced-and-cheapest --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scraperoka/linktree-email-scraper-fast-advanced-and-cheapest",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/PFMMdWyY0t6rAUc9k/builds/EccZa2r9pFFQ84bKa/openapi.json