# Twitter Email Scraper (`scraperoka/twitter-email-scraper`) Actor

📧 Twitter Email Scraper extracts verified emails from Twitter profiles using smart parsing. ⚡ Save time on prospecting & outreach for sales, marketing, and recruiting. 🔎 Clean, targeted leads—ready for your CRM.

- **URL**: https://apify.com/scraperoka/twitter-email-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Social media, Automation
- **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

### Twitter Email Scraper ⚡

Manually visiting profiles to collect email addresses wastes hours you don’t have. **Twitter Email Scraper** automatically extracts email addresses from Twitter bios and posts related to your keywords—so you can build outreach lists faster. Twitter Email Scraper is ideal for marketers, recruiters, and growth teams who need a bulk twitter email scraper to scrape twitter emails at scale, often reaching thousands of records in minutes.

***

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "network": "Twitter.com",
  "keyword": "marketing",
  "title": "Marketing leader & founder",
  "description": "Building growth teams | Contact: jane.doe@gmail.com | DMs open",
  "url": "https://twitter.com/janedoe",
  "email": "jane.doe@gmail.com",
  "proxyGroups": [
    "cost-effective",
    "legacy"
  ]
}
```

| Field | Type | What It Tells You |
|---|---|---|
| `network` | string | Confirms the source network as `Twitter.com` so you can segment results. |
| `keyword` | string | Which keyword matched the record, so you can attribute leads to specific themes. |
| `title` | string | A relevant result title from the scraped page to help you quickly judge lead relevance. |
| `description` | string | The text snippet the email was found in—useful context for personalization. |
| `url` | string | The profile/page URL associated with the contact details for verification. |
| `email` | string | The extracted email address you can use for outreach and enrichment. |
| `proxyGroups` | array | The engine/proxy selection used during scraping for transparency in your pipeline. |

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

***

### Why Twitter Email Scraper?

There are many ways to pull contact information from Twitter, but Twitter Email Scraper is built specifically to streamline twitter contact email extractor workflows end to end.

#### Keyword-driven extraction that targets real bios and posts

Twitter Email Scraper finds emails from Twitter bios and posts related to your keywords. By using keywords and custom email-domain filters, you can focus on the leads that match your outreach goals, making this a practical twitter email harvesting tool for prospecting.

#### Built for scale with a controllable email cap

You set `maxEmails` to control how many emails to collect. The scraper stops once your limit is reached, which helps you balance discovery volume and run time—ideal for bulk twitter email scraper runs.

#### Clean, deduplicated output using a “seen emails” cache

The actor keeps track of emails it has already collected and skips duplicates within the same run. That means your twitter outreach email scraper results are more integration-ready when you push them into your CRM or spreadsheet.

#### Resilient scraping with progress persistence

The actor saves progress (including a cursor and `seen_emails`) so reruns can avoid repeating already-found addresses. This resilience is especially helpful when you’re scraping twitter emails across larger search runs.

***

### Configuring Your Run

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

```json
{
  "keywords": ["founder", "marketing"],
  "location": "United States",
  "platform": "Twitter",
  "customDomains": ["@gmail.com", "@company.com"],
  "maxEmails": 50,
  "engine": "legacy",
  "proxyConfiguration": {}
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords to search for when identifying relevant Twitter bios and posts. |
| `location` | ⬜ | Filters search results by a specific location value (leave empty for no location filtering). |
| `platform` | ⬜ | Selects the target platform. Available option is `Twitter`. |
| `customDomains` | ⬜ | Filters extracted emails to specific domains (for example, `@gmail.com`). |
| `maxEmails` | ⬜ | Sets the maximum number of emails to collect; the run stops once this limit is reached. |
| `engine` | ⬜ | Chooses the scraping engine: `cost-effective` or `legacy`. |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor run. |

***

### Core Capabilities

#### Keyword-based targeting for faster lead discovery

Twitter Email Scraper uses your chosen `keywords` to focus extraction on Twitter bios and posts related to those terms. This makes it a strong automated twitter email extraction option when you’re building segmented outreach lists.

#### Domain filtering for higher relevance

With `customDomains`, you can restrict results to emails from domains you care about. If you run a twitter contact info scraper for enterprise leads, this helps reduce noise right from the start.

#### Resilient runs with retries and fallbacks

The actor includes resilience mechanisms for pages that return sparse results, including retry behavior. That helps keep twitter user email search runs productive even when results are temporarily limited.

#### Structured dataset rows written as results are found

Each extracted email is pushed as a structured record to your Apify dataset during the run. If you’re running a bulk twitter email scraper, you get usable outputs continuously instead of waiting for the full crawl to finish.

#### Flexible scale control for cost and runtime balance

Large searches or high email limits may take longer, so the actor provides practical controls like `maxEmails`. You can adjust your inputs to find the sweet spot for how many emails you need per run.

***

### Who Gets the Most Out of This

Here’s how different teams put Twitter Email Scraper to work:

**Sales Development Reps** — Use it as a twitter prospecting email scraper to turn a list of relevant keyword themes into a growing outreach dataset with email addresses plus the associated page URL for validation. The result is a faster way to build qualified lead lists without manual profile checking.

**Marketing Teams** — Marketing Email Scraper workflows can use keyword and domain targeting to gather twitter outreach email scraper leads aligned to campaign themes (like “founder” + “marketing”) and preferred email providers. This helps teams move from audience research to outreach readiness quickly.

**Recruiters & Talent Sourcers** — Recruiters can scrape twitter emails tied to specific professional signals in bios and posts, then enrich outreach using the accompanying `description` context. You get a ready-to-import list of contacts for sourcing pipelines.

**Freelance Researchers & Data Analysts** — Researchers can run automated twitter email extraction jobs to collect structured records at scale and then analyze contact distributions by keyword and domain. It’s especially useful when you need repeatable collection runs for reports.

**Automation & Integration Specialists** — If you’re wiring an outreach pipeline, Twitter Email Scraper’s consistent dataset rows make it straightforward to export and feed downstream systems. This supports building a twitter contact email extractor flow that can run in batches and refresh on demand.

***

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

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

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and search for Twitter Email Scraper.
2. **Enter your inputs** — set `keywords` (required), and optionally `location`, `customDomains`, `maxEmails`, `engine`, and `proxyConfiguration` in the input panel.
3. **Configure proxy settings** — if you want, set `proxyConfiguration` so the actor routes requests using your proxy preferences.
4. **Hit Run and watch the live log** — monitor progress while it collects emails up to your `maxEmails` cap.
5. **View results in the dataset tab** — exported records appear in your dataset as they’re found, each including `email`, `url`, and the text context.
6. **Export as JSON, CSV, or Excel** — download from the Apify dataset tab and plug straight into your CRM or spreadsheet.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

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

You can export results from the Apify dataset tab in formats like JSON, CSV, or Excel. That makes it easy to use this twitter email scraper output in spreadsheets, lead lists, and analytics workflows.

For programmatic automation, you can access results via the Apify API and connect them to your tools using common automation approaches like Zapier/Make and scheduled runs. For deeper guidance, check the Apify docs at [apify.com/docs/api](https://apify.com/docs/api).

***

### Pricing & Free Trial

Twitter Email Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. You can use the free allowance for several test runs, then scale based on your needs.

For exact current pricing and plan details, refer to the Apify pricing page on [apify.com](https://apify.com). Start for free at [apify.com](https://apify.com) and scale when you're ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Result completeness | Extracts emails from Twitter bios and posts related to your `keywords`. |
| Relevance targeting | Filters by `customDomains` to focus on the email providers you want. |
| Runtime control | Stops when `maxEmails` is reached to avoid overly long runs. |
| Resilience | Includes retries and fallbacks when results are sparse. |
| Data safety | Progress is persisted during the run to help reduce repeated work on reruns. |

**Limitations:** This actor works with publicly available data, so it cannot extract emails from private or login-gated Twitter content. Email availability depends on what the account owner has published in bios/posts.

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

***

### Frequently Asked Questions

#### Is there a free plan or trial for Twitter Email Scraper?

Apify offers a **free tier** to get started without a credit card. You can use it to run small test jobs and confirm your keyword and domain settings produce the results you expect.

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

No. Twitter Email Scraper extracts emails from publicly available sources, so no Twitter login is required for the actor to run.

#### How accurate is the data?

Accuracy depends on what email addresses are actually present in Twitter bios and posts related to your `keywords`. The actor extracts email addresses that match the provided `customDomains` filtering, so results reflect what is publicly published.

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

You control the cap with `maxEmails`. The scraper will stop once this limit is reached, but keep in mind that setting a high cap doesn’t guarantee reaching that number if fewer matching emails are available.

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

Freshness depends on when Twitter content is updated and when you run the actor. If you want more up-to-date leads, schedule or rerun using the same input settings.

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

The actor only works with **publicly available data** from Twitter bios and posts related to your provided inputs. You are responsible for ensuring your collection, storage, and outreach comply with GDPR, CCPA, platform Terms of Service, and applicable laws in your region.

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

Yes. You can export your dataset from the Apify dashboard, including formats like JSON and CSV/Excel-compatible exports. You can then import into your spreadsheet tool.

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

Yes. You can schedule runs using Apify automation capabilities. This is useful if you want ongoing twitter email harvesting tool refreshes for new leads.

#### Can I access this via API?

Yes. You can trigger the actor and retrieve results programmatically via the Apify API. For details, see [apify.com/docs/api](https://apify.com/docs/api).

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

If errors occur, the actor will still capture whatever data it successfully finds during the run and persist progress to help reduce repeated work on reruns. For help diagnosing a failed run, contact support at <dataforleads@gmail.com>.

***

### Need Help or Have a Request?

Got a question about Twitter Email Scraper or want a new feature added? Reach out at <dataforleads@gmail.com>. We actively maintain this actor and welcome ideas like webhook notifications on completion and batch CSV upload to streamline workflows even more.

# 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": "Twitter",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 20,
  "engine": "legacy"
}
```

# 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/twitter-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/twitter-email-scraper").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": [
    "founder",
    "marketing"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ]
}' |
apify call scraperoka/twitter-email-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/OM17WWnSSejxEdySn/builds/8GZddS3NkC5o22ZZG/openapi.json