# Threads Email Scraper (`scraperoka/threads-email-scraper`) Actor

📧 Threads Email Scraper extracts emails from Threads profiles and exports results for outreach. 🚀 Fast, efficient, and ideal for B2B prospecting, lead generation & marketing lists. 💼 Save time, reach more prospects—start scraping today!

- **URL**: https://apify.com/scraperoka/threads-email-scraper.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

### Threads Email Scraper 🎯

Manually hunting down contact emails across Threads profiles wastes hours you don’t have. **Threads Email Scraper** pulls email addresses at scale from Threads using your chosen keywords and filters. This Threads Email Scraper is ideal for marketers, recruiters, and growth teams who need leads fast—potentially thousands of extracted records in a single run.

***

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "network": "threads.com",
  "keyword": "founder",
  "title": "Marketing founder and community builder",
  "description": "Contact: hello@gmail.com — DM for collaborations",
  "url": "https://threads.com/some-profile",
  "email": "hello@gmail.com",
  "proxyGroups": ["GOOGLE_SERP"]
}
```

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network for your dataset (shown as `threads.com`). |
| `keyword` | string | The keyword that helped surface the email candidate for this record. |
| `title` | string | The result title text associated with the email discovery. |
| `description` | string | The surrounding publicly visible text where the email was found (useful for validation). |
| `url` | string | The public page URL where the email was identified. |
| `email` | string | The extracted email address you can use for outreach or enrichment. |
| `proxyGroups` | array | Shows which proxy configuration group(s) were used for the run. |
| `error_message` | string | Not part of the pushed dataset rows shown in this actor’s `push_data` output. Use run logs to diagnose issues if no rows appear. |

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

***

### Why Threads Email Scraper?

There are a lot of ways to pull contact data from Threads — here’s what sets Threads Email Scraper apart.

#### Keyword-driven extraction from public profile content

Threads Email Scraper finds emails from Threads bios and posts related to your keywords, helping you focus on the audience you actually care about (so you can run a Threads contact scraper workflow without guessing).

#### Domain targeting for better lead relevance

Use `customDomains` to filter for email addresses matching domains you care about (for example, `@gmail.com`)—a practical way to improve results for Threads outreach email list building.

#### Built-in deduplication to keep results clean

Emails are tracked as `seen_emails` so duplicates are skipped, which makes the output more usable for downstream enrichment and CRM imports.

#### Resilient scraping with fallbacks

If results are sparse or fetching is interrupted, the actor includes retry and fallback logic to keep going and capture what it can—useful for bulk email harvesting tool runs.

***

### Configuring Your Run

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

```json
{
  "keywords": ["founder", "marketing"],
  "location": "",
  "platform": "Threads",
  "customDomains": ["@gmail.com"],
  "maxEmails": 20,
  "engine": "cost-effective",
  "proxyConfiguration": {}
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords to search for. The actor uses these to find relevant Threads bios and posts. |
| `location` | ⬜ | Filters results by location (leave blank for no location filtering). |
| `platform` | ⬜ | Selects the platform to scrape. This actor supports `Threads`. |
| `customDomains` | ⬜ | Filters extracted emails to the domains you specify (for example, `@gmail.com`). |
| `maxEmails` | ⬜ | Caps the maximum number of emails to collect; the actor stops once the limit is reached. Higher limits may take longer. |
| `engine` | ⬜ | Chooses the scraping engine. `cost-effective` uses a residential-proxy approach; `legacy` uses a different proxy approach that prioritizes reliability. |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor run. |

***

### Core Capabilities

#### Targeted Threads email harvesting with keyword control

Threads Email Scraper uses your `keywords` to locate email candidates from Threads bios and posts that match your topic. This makes it a practical Threads email finder for prospecting email lists and lead research.

#### Email domain filtering for cleaner lead lists

With `customDomains`, you can narrow extracted emails to the domains you want. This helps when you’re building a Threads leads email scraper dataset where relevance matters more than volume.

#### Deduplicated results for easier CRM imports

The actor keeps a `seen_emails` set so it doesn’t push the same email address repeatedly. That reduces cleanup work and makes Threads contact information scraper outputs more immediately usable.

#### Pagination with stop conditions to manage scale

The run respects your `maxEmails` limit and stops when reached. It also includes logic for stopping when it detects that continuing is unlikely to yield more results.

#### Real-time dataset writing

Every time an email is found, the actor pushes a row immediately (via `Actor.push_data`). You can monitor progress live and start exporting without waiting for the full run to finish.

#### High-level proxy support for reliability

It supports proxy configuration through `proxyConfiguration`, and the `engine` input lets you choose between two scraping approaches designed for different tradeoffs. This helps improve consistency for bulk extraction jobs.

***

### Who Gets the Most Out of This

Here's how different teams put Threads Email Scraper to work:

**Marketing teams building outbound lists** — Use keywords like “marketing” and domain filters in `customDomains` to generate a ready-to-import Threads outreach email list, reducing manual research time.

**Recruiters sourcing founders and operators** — Combine founder-focused keywords with targeted domains to capture contact emails from publicly available Threads bios, then enrich the results for faster outreach.

**Sales development teams qualifying prospects** — Run Threads prospecting email scraper jobs on niche keywords, set `maxEmails` to control runtime, and use the pushed dataset rows to jump straight into CRM workflows.

**Influencer marketers finding collaboration contacts** — Use a Threads influencer email scraper approach with multiple keywords, then review `description` alongside `url` for context before messaging.

**Data analysts and researchers** — Export the dataset and analyze how different keyword themes correlate with email availability, since each row includes `keyword`, `email`, and the associated `url` context.

**Automation specialists** — Integrate the results into downstream pipelines (CRM, enrichment, or outreach) by pulling the dataset programmatically via Apify API workflows and scheduling recurring runs.

***

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

No coding needed. Here's how to run Threads Email Scraper from start to finish:

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and find Threads Email Scraper.
2. **Enter your inputs** — fill in `keywords` (required), and optionally `customDomains`, `location`, `maxEmails`, `engine`, and `proxyConfiguration`.
3. **Configure proxy settings** — if you need more reliability for larger batches, set up `proxyConfiguration` and choose the preferred `engine`.
4. **Hit Run and watch the live log** — monitor progress as emails are found and pushed to the dataset.
5. **View results in the dataset tab** — each pushed record includes `email`, `url`, `keyword`, `description`, and more.
6. **Export as JSON, CSV, or Excel** — download your results directly from the Apify dashboard for analysis or outreach.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

Once your data is collected, Threads Email Scraper plugs directly into your existing workflow.

You can export from the Apify dataset tab in common formats like JSON, CSV, and Excel, which makes it easy to move results into spreadsheets, BI tools, or CRMs. For no-code pipelines, you can connect results using Zapier or Make, or automate downstream steps with webhooks when a run completes.

For developers, you can pull results programmatically via the Apify API (see: https://apify.com/docs/api) and build scheduled workflows so your Threads email harvesting tool runs automatically on a cadence.

***

### Pricing & Free Trial

Threads Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. Free tier credit is typically enough for several test runs, so you can validate keyword and `customDomains` targeting before scaling up.

Ongoing usage is pay-as-you-go based on Apify platform compute (CU), and you’ll choose the plan level based on how frequently and how large your runs are. Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Proxy reliability | Built-in proxy support via `proxyConfiguration` and `engine` choice to improve consistency. |
| Retries and fallbacks | Includes fallback logic so runs keep trying when results are sparse. |
| Data usefulness | Each output row includes context like `url` and `description` alongside the `email`. |
| Run limits | Respects `maxEmails` so you can control runtime and cost. |
| Scalable execution | Designed for bulk runs where you want many results quickly, not one-off lookups. |
| Error visibility | If pushing data fails, the actor logs errors so you can diagnose issues from run logs. |

Limitations: This actor works on publicly accessible content only. If many profiles don’t include emails in publicly visible bios/posts (or if your `customDomains` are too narrow), you may see lower yield and should broaden keywords or domains.

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

***

### Frequently Asked Questions

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

Yes. Apify provides a free tier so you can test Threads Email Scraper with smaller jobs before scaling. Use a small `maxEmails` value and a couple of keywords first.

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

No. This actor is designed to scrape emails from publicly available sources (Threads bios and posts). Login-gated content isn’t part of the expected workflow.

#### How accurate is the data?

The actor extracts emails that appear in the publicly visible `description` text associated with the record and pushes them into the dataset as `email`. Accuracy depends on what the account owner publishes.

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

You control this using `maxEmails`, which caps how many emails the actor will collect before stopping. Larger values can take longer and don’t guarantee you’ll reach the limit.

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

Freshness depends on when you run the actor. Each run scrapes publicly available content at runtime and stores results in your dataset immediately as records are found.

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

This actor accesses **publicly available data** only. It’s your responsibility to comply with GDPR, CCPA, platform Terms of Service, and any applicable local regulations for collecting and using outreach data.

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

Yes. You can export from the Apify dashboard in formats like JSON, CSV, or Excel. If you want Google Sheets specifically, use Apify integrations or your preferred workflow tooling.

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

Yes. You can schedule actor runs so Threads Email Scraper runs automatically on a cadence that fits your pipeline. This is ideal for ongoing prospecting email scraper workflows.

#### Can I access this via API?

Yes. You can trigger the actor and retrieve results programmatically using Apify API (refer to https://apify.com/docs/api).

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

If fetching or pushing data fails, the actor logs details so you can inspect run logs and retry as needed. Results already pushed to your dataset remain available, which helps with interrupted runs.

***

### Need Help or Have a Request?

Got a question about Threads Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We welcome requests like batch CSV upload and webhook notifications on completion, and we actively maintain the actor based on feedback.

# Actor input Schema

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

A list of keywords to search for.

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

Location to filter search results.

## `platform` (type: `string`):

Select platform.

## `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.

## `engine` (type: `string`):

Choose scraping engine. 🚀 Cost Effective (New): Uses residential proxies with async requests for faster, cheaper scraping. 🔧 Legacy: Uses GOOGLE\_SERP proxy with traditional selectors - more reliable but slower and more expensive.

## `proxyConfiguration` (type: `object`):

Configure proxies for this Actor.

## Actor input object example

```json
{
  "keywords": [
    "founder",
    "marketing"
  ],
  "location": "",
  "platform": "Threads",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "cost-effective"
}
```

# 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": [
        "founder",
        "marketing"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/threads-email-scraper").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": [
        "founder",
        "marketing",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/threads-email-scraper").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": [
    "founder",
    "marketing"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ]
}' |
apify call scraperoka/threads-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scraperoka/threads-email-scraper"
        }
    }
}

```

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/TzePVd26ZZ6ljB8yH/builds/58yo1F77yJWuXOpYk/openapi.json