# Twitter Email Scraper - Keyword & Location Targeting (`scrapido/twitter-email-scraper`) Actor

🐦 Twitter Email Scraper extracts public profile and brand emails by keyword and location. 🔓 Custom domain filters, hidden-address decoding and dedup. 📤 Export Twitter leads to CSV, JSON or Excel for PR outreach.

- **URL**: https://apify.com/scrapido/twitter-email-scraper.md
- **Developed by:** [Scrapido](https://apify.com/scrapido) (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 $2.50 / 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/actors/running/actors-in-store.md#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

**Twitter Email Scraper** is an Apify actor that automates email extraction from Twitter using the keywords and filters you choose—solving the biggest problem in lead research: finding contact emails at scale without spending days manually browsing. It’s also a practical **social media email scraper** and **Twitter contact scraper** for marketers, recruiters, and data teams who want fast ROI.

***

### What is Twitter Email Scraper? 🔍

Twitter Email Scraper is an automated web scraping actor on Apify that extracts email addresses from Twitter based on specified keywords and email-domain filters. This **Twitter email extractor** / **Twitter contact scraper** helps you replace manual research with repeatable, keyword-driven **lead generation tool** workflows—especially when you need thousands of contacts quickly. Whether you’re a marketer building campaigns, a recruiter sourcing talent, a sales team validating prospect lists, or an analyst enriching datasets, Twitter Email Scraper turns public contact info into structured results you can export and use. Use it to streamline **Twitter email extraction** and speed up **automated email discovery** in a consistent pipeline.

***

### What Data Does a Twitter Email Scraper Collect? 📊

This Twitter Email Scraper captures contact and profile context from Twitter results: the extracted `email`, identity fields like `title`, the supporting `description`, and navigation via `url`. It also keeps track of which `keyword` surfaced each result.

| Data Category | Fields Extracted | Description |
|---|---|---|
| Contact | `email` | Public email address associated with the Twitter profile |
| Identity | `title` | Profile title or business/person name shown in the result |
| Context | `description` | Profile bio or summary text captured from the result |
| Discovery | `keyword` | Keyword that helped surface this specific contact |
| Navigation | `url` | Direct link to the Twitter profile page |
| Location | `description` | Location context is captured within the profile text (as part of `description`) |

> Note: While the actor accepts a `location` input filter, the dataset schema includes profile text in `description` (not a separate dedicated location field).

***

### What Do Results from Twitter Email Scraper Look Like? 👀

Each result is a structured JSON record saved to your Apify dataset. Here's a real example:

```json
{
  "keyword": "founder",
  "title": "Jamie Chen",
  "description": "Founder & CEO • Building B2B SaaS teams | Contact: jamie.chen@companymail.com",
  "url": "https://x.com/jamiechen",
  "email": "jamie.chen@companymail.com"
}
```

Export formats: JSON (default) and CSV (via Apify Console). You can use these records directly for **OSINT email scraping**, **contact information extraction**, and CRM enrichment workflows that depend on **twitter contact scraping** outputs.

***

#### Core Features: Twitter Email Scraper ⚡

| Feature | Benefit |
|---|---|
| ✅ **Keyword-Driven Targeting** | Uses your chosen keywords/queries to guide Twitter email extraction |
| ✅ **Location Filter** | Helps narrow results by the `location` value you enter |
| ✅ **Custom Domain Filter** | Limits extracted emails to the domains you specify in `customDomains` (e.g., `@gmail.com`) |
| ✅ **Configurable Result Cap** | Control scraping time with `maxEmails` so your run stays cost-efficient |
| ✅ **Built-in Proxy Support** | Designed for reliable large-scale scraping runs with proxy support |
| ✅ **Real-Time Data Saving** | Incremental saving to your dataset as results are discovered |
| ✅ **Structured Dataset Output** | Clean dataset fields ready for downstream automation and analysis |
| ✅ **No Login Required** | Extracts from publicly available Twitter data only |

***

### Getting Started with Twitter Email Scraper 🚀

1. **Open Apify Store** — Go to [apify.com/store](https://apify.com/store) and search **Twitter Email Scraper**
2. **Click Try for Free** — Sign in or create a free Apify account
3. **Open the Input Tab** — Configure `keywords` and optional filters
4. **Add Keywords** — Enter targeted roles and phrases (for example, “manager”, “founder”)
5. **Set Optional Filters** — Add `location` and/or `customDomains` to focus your **twitter contact scraping**
6. **Cap Your Results** — Set `maxEmails` to control run size and cost
7. **Click Start** — Launch the run and monitor progress
8. **Access Your Data** — Open the Dataset tab to export or preview results

First results are typically visible quickly, and the dataset grows as the actor pushes items incrementally.

***

### Ways to Use Twitter Email Scraper 💡

- 🎯 **Lead generation from twitter** — Build segmented outreach lists by keyword and email domain
- 📣 **Email harvesting tools** — Collect publicly listed emails to power campaigns and follow-ups
- 🔬 **Data mining twitter profiles** — Support research on audiences, roles, and niches
- 🤝 **CRM enrichment** — Add extracted contacts to your existing database for better targeting
- 📊 **Automated email discovery** — Refresh lead data on a schedule using Apify workflows
- ⚙️ **OSINT email scraping** — Standardize collection for analysts and investigators working with public web data

***

#### Input Parameters — Twitter Email Scraper

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

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `keywords` | Array | ✅ Yes | — | A list of keywords or queries used to find relevant Twitter profiles for **Twitter email extraction** |
| `location` | String | No | `""` | Optional location filter (e.g., city/region/country) to narrow the results |
| `customDomains` | Array | No | `["@gmail.com","@yahoo.com"]` | Email domains to restrict extraction (helps focus on the inbox types you want) |
| `maxEmails` | Integer | No | `20` | Maximum number of emails to collect. Higher values may take longer; it also helps control scraping time |

***

#### Output Parameters — Twitter Email Scraper

```json
{
  "keyword": "creative director",
  "title": "Alex Rivera",
  "description": "Creative Director at Studio Co. | Available for freelance | Contact: alex@studioco.com",
  "url": "https://x.com/alexrivera",
  "email": "alex@studioco.com"
}
```

| Field | Label | Format | Description |
|---|---|---|---|
| `keyword` | Keyword | text | The keyword that surfaced this result |
| `title` | Title | text | Profile name or business/person title captured in the result |
| `description` | Description | text | Profile bio/summary text captured from the result |
| `url` | Url | link | Direct link to the Twitter profile |
| `email` | Email | text | Extracted public email address |

***

### Why Choose This Twitter Email Scraper? 🏆

Twitter Email Scraper is built for practical, export-ready **Twitter email extraction**: structured dataset output, keyword-driven discovery, domain filtering, and a configurable `maxEmails` cap to keep runs predictable. Compared with manual prospecting, it’s faster to scale and easier to analyze. With proxy support and real-time saving, it’s designed for smoother large-batch scraping and better operational reliability. If you need help integrating **scraping tools and APIs** into your lead generation workflow, reach out to support at <scrapidocontact@gmail.com>.

***

### How Many Results Can You Scrape? 📈

Use `maxEmails` to set a hard cap—from 1 up to 10,000. Actual email yield depends on how many Twitter profiles match your `keywords` and `customDomains`. Runs may take longer with bigger caps. All discovered items are saved to your Apify dataset so you can export whenever you’re ready, even after the run ends early due to limits or availability.

***

### Legal Guidelines for Scraping Twitter ⚖️

Twitter Email Scraper accesses **publicly available data** on Twitter. It does not use logins to access private profiles or authenticated content. You’re responsible for ensuring your usage complies with Twitter’s Terms of Service, data protection laws (including GDPR/CCPA where applicable), and anti-spam regulations. Only use the extracted data for legitimate business purposes. If you have any data removal requests, contact <scrapidocontact@gmail.com>.

***

### FAQ — Twitter Email Scraper ❓

#### How does the Twitter Email Scraper identify data?

The actor uses your `keywords` (and optional `location`) to find relevant publicly available Twitter results, then extracts public email addresses and associated profile text fields into your dataset. It’s designed as a **social media email scraper** workflow for automated **contact information extraction**.

#### What Twitter profile types can I scrape?

You can extract contacts from public Twitter profiles where an email address is available in the publicly visible profile content. Profiles without publicly available email information won’t produce usable results.

#### How did the Twitter Email Scraper perform in our tests?

In typical usage, it returns email addresses when they are present in publicly available Twitter profile data. Email availability varies heavily by niche and how individual profiles present contact information.

#### Why scrape Twitter for contacts?

Twitter hosts a wide range of professionals and creators who sometimes list contact emails publicly. Twitter Email Scraper automates the repetitive parts of **Twitter contact scraping**, so you can spend more time qualifying leads and building outreach rather than searching manually.

#### How much does the Twitter Email Scraper cost?

Pricing is pay-per-result on Apify. You can control spend precisely using `maxEmails`, which limits how many emails the actor collects before stopping. New users may receive free monthly credits depending on current Apify promotions.

#### How does the Twitter Email Scraper help my business?

It helps you move from scattered manual searching to a clean, structured output you can use for CRM enrichment, prospecting, or other outreach workflows—especially for use cases like **lead generation from twitter** and **automated email discovery**.

#### What challenges should I expect when using the Twitter Email Scraper?

Not every Twitter profile includes a public email, so results depend on keyword relevance and the domains you select in `customDomains`. If you’re getting low yield, consider broader or more targeted keywords and add additional email domains that match your ideal lead profile.

#### How do I choose a high-performing Twitter Email Scraper?

Choose input settings that match your ICP: use focused `keywords`, limit output with `customDomains` to relevant domains, and set `maxEmails` to a level that balances coverage with run time. This improves outcome quality for **twitter email extraction** and downstream **data mining twitter profiles**.

***

### Conclusion 🏁

Twitter Email Scraper is a practical way to automate Twitter contact collection—helping marketers, recruiters, and analysts build scalable email lists from publicly available Twitter profile content. If you want speed, structured output, and controllable run size, start your first scrape on Apify today. 🚀

***

### 🆘 Support & Feedback

Have a question or feature request for Twitter Email Scraper?

- ✨ **Custom Solutions & Feature Requests:** Contact our team
- 📧 **Email:** <scrapidocontact@gmail.com>

### Multiple Email Types

**Email Types** replaces the old single Audience Type choice: select as many
kinds of mailbox as you want and the run chases all of them together.

| Type | What it matches |
| --- | --- |
| Personal / free webmail | Gmail, Outlook, Yahoo, iCloud, AOL, Proton, ... |
| Business / corporate | Company domains - free webmail and institutions excluded |
| Education (.edu / .ac) | `.edu`, `.ac.uk`, `.edu.au`, `.ac.in` and other academic suffixes |
| Government (.gov / .mil) | `.gov`, `.mil`, `.gov.uk`, `.gc.ca`, ... |
| Non-profit (.org) | `.org`, `.ngo`, `.org.uk`, ... |

Each selected type contributes its own Google dork patterns *and* its own domain
test, so a result is only kept if it genuinely belongs to the type that found
it. Every row carries an `emailType` field recording which one that was.

Suffixes are matched as real domain suffixes, so `cs.mit.edu` counts as
Education while `notedu.com` does not.

Setting **Custom Email Domains** still overrides everything: an explicit domain
list is a manual override and replaces the type-driven patterns. The legacy
`audienceType` value is still accepted, so saved inputs keep working.

# Actor input Schema

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

A list of keywords or queries to search for.

## `audienceType` (type: `string`):

Business Emails runs contextual discovery patterns tuned for company contact pages ("email us at", "contact@", careers, bookings, ...) and filters out consumer webmail domains. Consumer Emails instead searches gmail.com, yahoo.com, outlook.com, hotmail.com and icloud.com directly.

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

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

Optional manual override — provide specific email domains to search for (e.g. @hubspot.com) instead of using Audience Type. Leave empty to use Audience Type.

## `emailTypes` (type: `array`):

Which kinds of mailbox to hunt for. Pick as many as you like - each type contributes its own set of Google search patterns and its own domain filter, and every result records the type it was found as. Personal = free webmail (Gmail, Outlook, Yahoo, iCloud). Business = company domains, excluding free webmail and institutions. Education = .edu / .ac.uk and friends. Government = .gov / .mil. Non-profit = .org.

## Actor input object example

```json
{
  "keywords": [
    "manager",
    "founder"
  ],
  "audienceType": "Consumer Emails",
  "maxEmails": 20,
  "customDomains": [],
  "emailTypes": [
    "Personal",
    "Business"
  ]
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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"
    ],
    "customDomains": [],
    "emailTypes": [
        "Personal",
        "Business"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapido/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": [
        "manager",
        "founder",
    ],
    "customDomains": [],
    "emailTypes": [
        "Personal",
        "Business",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapido/twitter-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": [
    "manager",
    "founder"
  ],
  "customDomains": [],
  "emailTypes": [
    "Personal",
    "Business"
  ]
}' |
apify call scrapido/twitter-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapido/twitter-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/W3b3iXIGsmBtV7g2O/builds/GzCIgmRLTiOppmPSs/openapi.json