# Twitter X B2b Lead Generator Email Scraper (`scrapers-hub/twitter-x-b2b-lead-generator-email-scraper`) Actor

Twitter X B2B Lead Generator Email Scraper turns search terms into B2B contacts - email, email domain, profile title, description, URL and country. 📩 Scale outbound prospecting, partner sourcing and CRM enrichment from X.

- **URL**: https://apify.com/scrapers-hub/twitter-x-b2b-lead-generator-email-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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/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 X B2B Lead Generator Email Scraper – Extract Business Emails & Sales Leads

The **Twitter X B2B Lead Generator Email Scraper** finds publicly indexed business email addresses connected to X (formerly Twitter) profiles and posts, and returns them as structured, deduplicated lead records. You describe the audience you want with search terms — a job title, a market, a technology — and the actor runs targeted searches scoped to X URL patterns, extracts the business email addresses exposed in the indexed content, and writes one dataset item per unique contact.

X remains one of the most contact-rich public networks in B2B. Founders publish their address in a bio, agencies put a booking email in a pinned post, and operators drop a contact line under a thread that goes wide. This X email scraper systematises that: instead of manually reading bios, you get a lead list with the email, its domain, the source URL, the page title and description, and the exact search term that produced each result — everything a sales development rep needs to qualify a prospect before writing a single line of outreach.

***

### 📊 What Data Can You Extract with This Twitter X Email Scraper?

Every dataset item is one discovered contact, described by these field groups.

| Category | Fields | What you get |
|---|---|---|
| 📧 Contact data | `email`, `email_domain` | The business email found, plus its domain isolated for company matching and filtering |
| 🔗 Source attribution | `url`, `scrape_from` | The X URL the email was discovered on and the source domain it came from |
| 🏷️ Profile context | `title`, `description` | The indexed page title and surrounding snippet text — usually the account name, bio or post body |
| 🎯 Search provenance | `keyword` | The exact search term from your input that produced this lead |
| 🌍 Geography | `country` | The country locale the search was executed against |

The most valuable combination for lead qualification is `email_domain` alongside `description`. The domain tells you whether you are looking at a corporate address or a free consumer mailbox, and the indexed snippet usually carries the account's bio — which is where people state their role, their company and what they actually do.

***

### 🌟 Key Features of the Twitter X B2B Lead Scraper

| Feature | Description |
|---|---|
| 🎯 Search-term targeting | Supply any number of terms — roles, niches, technologies — and each one is searched independently |
| 🧭 Source scoping | `sourceRegion` restricts the search to X profiles, X posts, or sweeps both |
| 🏢 B2B-oriented extraction | Search patterns are tuned towards business domains rather than generic consumer mailboxes |
| 🌍 Country targeting | Set `country` to run against a specific national locale for geographically relevant leads |
| 🚫 Global deduplication | Addresses are tracked across the entire run, so each unique email appears exactly once in the dataset |
| 🔢 Hard result cap | `maxEmails` ends the run as soon as your target number of unique contacts is reached |
| ⚡ Two engine modes | `cost-effective` issues concurrent asynchronous requests; `legacy` runs searches sequentially |
| 🧠 Adaptive stopping | The scraper abandons a search branch after consecutive pages that yield nothing new instead of paginating into dead results |
| 🔄 Automatic proxy rotation | Proxy selection and rotation are managed inside the actor — no proxy setup is required from you |

***

### 🚀 Why Choose This Twitter X Email Scraper?

**Leads arrive with context, not just addresses.** A naked email list is impossible to qualify. Each record carries the `url` it came from, the `title` and `description` of that page, and the `keyword` that surfaced it, so you can judge fit before the contact reaches your CRM.

**Profiles and posts are different hunting grounds.** Bios and pinned content expose contact details in very different ways from thread replies and long posts. `sourceRegion` lets you target whichever fits your motion, or search both when you want maximum coverage.

**Deduplication happens during the run.** With several search terms across multiple X surfaces, the same address will surface repeatedly. The actor keeps a global set of seen emails for the whole run, so the dataset you export is already clean.

**It knows when to stop.** Rather than grinding through pagination that has stopped producing results, the scraper detects consecutive empty pages and ends that branch — shorter runs, less waste, and a clearer signal that a search term is exhausted.

***

### 📥 Input

```json
{
  "searchTerms": ["saas founder", "crypto"],
  "country": "United States",
  "sourceRegion": "All",
  "maxEmails": 100,
  "engine": "cost-effective"
}
```

#### 🔧 Twitter X Email Scraper Input Fields

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `searchTerms` | array | No | `["saas founder", "crypto"]` | Search terms describing the audience to find business emails for. Each term is searched independently. |
| `country` | string | No | `United States` | Country name used to set the search locale; it is mapped to a country code internally and returned in the `country` output field. |
| `sourceRegion` | string | No | `All` | Which X surface to search: `All`, `Profiles` or `Posts`. `All` searches each surface in turn. |
| `maxEmails` | integer | No | `100` | Maximum number of unique email addresses to collect before the run stops. |
| `engine` | string | No | `cost-effective` | Scraping engine: `cost-effective` runs concurrent asynchronous requests, `legacy` runs sequentially. |

#### 💡 Input Examples

Find founders and technical leaders from X profiles:

```json
{
  "searchTerms": ["saas founder", "cto startup"],
  "sourceRegion": "Profiles",
  "maxEmails": 200
}
```

Mine posts in a specific vertical and market:

```json
{
  "searchTerms": ["ecommerce agency", "shopify consultant"],
  "country": "United Kingdom",
  "sourceRegion": "Posts",
  "maxEmails": 150
}
```

Run a broad sweep across both X surfaces:

```json
{
  "searchTerms": ["web3 developer", "defi"],
  "sourceRegion": "All",
  "maxEmails": 100,
  "engine": "cost-effective"
}
```

***

### 📤 Output

```json
{
  "keyword": "saas founder",
  "title": "Marcus Reid (@marcusbuilds) on X",
  "url": "https://x.com/example-account",
  "description": "Founder at Loopwork. Building B2B scheduling software. Partnerships: marcus@loopwork.io",
  "email": "marcus@loopwork.io",
  "email_domain": "loopwork.io",
  "country": "us",
  "scrape_from": "x.com"
}
```

#### 🧾 Twitter X B2B Lead Output Fields

| Field | Type | Description |
|---|---|---|
| `keyword` | string | null | Keyword that produced this item. |
| `title` | string | null | Title of the indexed X page the email was found on. |
| `url` | string | null | Canonical URL of the scraped item. |
| `description` | string | null | Long-form description text surrounding the match, typically the bio or post snippet. |
| `email` | string | null | Email address found for the item. |
| `email_domain` | string | null | Email domain of the item. |
| `country` | string | null | Country locale the search was run against. |
| `scrape_from` | string | null | The source domain the result was scraped from. |

***

### 💻 How to Use the Twitter X B2B Lead Generator (Step by Step)

#### Step 1: Write search terms that describe your ideal customer

Everything hinges on `searchTerms`. Use the vocabulary your prospects use about themselves in their bios — "fractional CMO", "shopify agency", "solo founder", "devrel" — rather than internal category names. Each term is searched independently, so three or four sharp terms consistently outperform one broad one, which tends to return popular accounts that expose no contact details.

#### Step 2: Choose which X surface to search

`sourceRegion` controls where the X email scraper looks. `Profiles` targets account pages, where bios frequently carry a business address. `Posts` targets individual posts and threads, which is where agencies and freelancers often publish a booking or enquiry email. `All` covers both in sequence, finding more contacts at the cost of a longer run.

#### Step 3: Set the country locale

`country` takes a country name such as "United States" or "United Kingdom" and maps it to a search locale internally. Because search results are localised, this materially changes which accounts surface — targeting a European market while leaving the default in place will skew your list towards the wrong region. The resolved code is echoed back in each record's `country` field.

#### Step 4: Cap the run with maxEmails

`maxEmails` is a hard ceiling on unique addresses, and the run ends the moment it is hit regardless of how many search terms remain. Run a small test first — 50 emails is usually enough to judge whether the terms are pulling the right kind of account — then raise the cap once the quality looks right.

#### Step 5: Pick an engine

Leave `engine` on `cost-effective` for most jobs; it issues several concurrent requests and finishes faster. The `legacy` engine processes searches one at a time using a different proxy strategy, and is worth trying when the default returns unusually thin results for a specific market or niche.

#### Step 6: Run the scraper and read the log

Start the run and follow the log output. It reports each search term and surface combination, how many new emails each page produced, and when it abandons a branch because consecutive pages yielded nothing new. A term reporting zeros across several pages is telling you it is either too broad or too obscure — better to fix it and rerun than to wait it out.

#### Step 7: Qualify, verify and export the leads

When the run completes, open the Dataset tab. Group by `email_domain` to see which companies you have hit, read `title` and `description` to confirm role and relevance, and drop any free-mail domains if you only want corporate contacts. Export as CSV or JSON, or pull the items through the API into your CRM or sequencing tool — after running them through email verification.

***

### 🔌 API Access & Integrations

Run the X B2B lead scraper and receive the leads synchronously:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers-hub~twitter-x-b2b-lead-generator-email-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchTerms": ["saas founder"],
    "country": "United States",
    "sourceRegion": "Profiles",
    "maxEmails": 100
  }'
```

The same job from Python with the official client:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")

run = client.actor("scrapers-hub/twitter-x-b2b-lead-generator-email-scraper").call(
    run_input={
        "searchTerms": ["ecommerce agency", "shopify consultant"],
        "country": "United Kingdom",
        "sourceRegion": "Posts",
        "maxEmails": 150,
    }
)

for lead in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(lead["email"], "|", lead["email_domain"], "|", lead["title"])
```

Leads land in a standard Apify dataset, so they connect directly to Zapier, Make, Google Sheets or Slack, and a webhook can push each finished run's contacts into your CRM automatically.

***

### 💡 Best Use Cases for Twitter X B2B Lead Data

#### 🎯 Outbound sales prospecting

Run several role-based search terms with `sourceRegion` set to `Profiles`, then filter on `email_domain` to keep corporate addresses. The `description` field almost always carries the account bio, which gives you a specific, personal hook for the first line of an outreach email.

#### 🚀 Startup and founder sourcing

Founders are unusually visible on X and frequently publish a direct contact address. Searching founder-flavoured terms and reading the `title` and `description` of each result produces a list of decision makers who can be reached without navigating a gatekeeper.

#### 🤝 Agency and freelancer discovery

Service businesses treat X as a shopfront and publish booking emails deliberately. Targeting `Posts` with service-category terms surfaces exactly those addresses, and `url` links straight back to the post so you can see what they offer before reaching out.

#### 💹 Crypto, web3 and niche community mapping

Communities that live on X are hard to reach through conventional B2B databases. Running a set of niche terms and grouping the results by `email_domain` gives you a map of the projects and companies active in a space, alongside a way to contact them.

#### 📰 Creator, influencer and PR outreach

People publishing regularly on a topic are the natural targets for partnerships and press. Searching topic terms across `Posts` finds active voices, and the `keyword` field tells you which topic each contact was matched on so you can segment your pitches.

#### 🔍 CRM enrichment for existing accounts

Where your CRM holds company records with no contact address, run the company or brand names as search terms and match results back on `email_domain`. It is a practical way to close gaps in an existing database instead of building a list from nothing.

#### 📊 Market research and competitive landscape

Running the same term set across several `country` values and comparing the resulting `email_domain` distributions shows which companies dominate a conversation in each market — a cheap, fast sketch of a competitive landscape.

***

### ⚙️ Tips for Better Twitter X Lead Scraping Results

- **Prefer several specific terms over one broad one.** "Fractional CMO" beats "marketing" every time, because broad terms return large accounts that publish no contact address.
- **Set `country` to the market you actually sell into.** Search results are localised, and the default will quietly bias a European or Asian campaign towards the wrong accounts.
- **Test with a small `maxEmails` first.** Fifty results is enough to tell whether your terms are pulling founders or noise, and it is far cheaper than discovering the problem at five hundred.
- **Filter free-mail domains after the run.** Check `email_domain` against the common consumer providers and down-rank or drop them when you need corporate contacts only.
- **Run `Profiles` and `Posts` as separate jobs.** Targeted runs per surface produce cleaner, more interpretable lists and reveal which surface is actually productive for your niche.
- **Always verify before sending.** Addresses harvested from public content should be checked for deliverability first — bounces from an unverified list damage sender reputation quickly.

***

### 🛠️ Troubleshooting

**The run produced very few leads.**
This is nearly always a search-term problem. Extremely broad terms return accounts with no published contact details; extremely narrow ones return almost nothing. Try three to five mid-specificity terms and check that `sourceRegion` is not restricting you to a surface your audience does not use.

**The scraper stopped before hitting `maxEmails`.**
That is intentional. When consecutive pages return no new unique addresses, the scraper ends that search branch rather than paginating into exhausted results. Add more search terms if you need a longer list.

**I am getting consumer email domains in my results.**
Extraction is oriented towards business domains, but publicly posted contact details sometimes use free providers. Filter on `email_domain` after the run to enforce a corporate-only list.

**Results are sparse for a non-English market.**
Set `country` to the target market and write your search terms in that market's language. Searching English terms against a localised index is the most common cause of thin results.

**The same domain appears many times.**
Expected when an organisation publishes several addresses across accounts and posts. Deduplicate on `email_domain` rather than `email` if you want one contact per company.

***

### ❓ Frequently Asked Questions About Twitter X Email Scraping

**What does this Twitter X B2B email scraper collect?**
It collects business email addresses published in publicly indexed X content — profiles and posts — along with the page title, description snippet, source URL, email domain and the search term that produced each lead.

**Does the scraper log into X or use the X API?**
No. It works from publicly indexed content and does not authenticate, use an X account, or access anything behind a login.

**How do I target a specific job title or industry?**
Put the title or industry into `searchTerms`. Each term is searched separately, so you can combine several roles and verticals in a single run.

**Can I search only X profiles and skip posts?**
Yes. Set `sourceRegion` to `Profiles`. The alternatives are `Posts` and `All`.

**How many leads can I get in one run?**
Up to the value of `maxEmails`, which defaults to 100. The run ends as soon as that many unique addresses have been collected.

**Are duplicate emails removed automatically?**
Yes. The actor keeps a global set of addresses already emitted, so each unique email appears once no matter how many terms or surfaces produced it.

**What is the difference between the cost-effective and legacy engines?**
`cost-effective` is the default and issues concurrent asynchronous requests. `legacy` processes searches sequentially with a different proxy strategy. Most runs should stay on the default.

**Can I target leads in a specific country?**
Yes. `country` accepts a country name and sets the search locale; the resolved code is returned in each record's `country` field.

**Do I need to set up proxies for this X scraper?**
No. Proxy rotation is handled automatically inside the actor and there is no proxy input to configure.

**Are the scraped emails verified as deliverable?**
No. The scraper reports addresses exactly as it finds them in public content. Run them through an email verification step before any live campaign.

**What does the `scrape_from` field mean?**
It records the source domain each lead was scraped from, which is useful when you search several surfaces in one run and want to know where a contact originated.

**Can I use these X leads for cold email outreach?**
Only where the law allows. B2B email rules vary widely — GDPR and PECR in Europe, CAN-SPAM in the United States, CASL in Canada — and compliance is your responsibility.

**Why is the `description` field empty on some leads?**
Not every indexed page exposes a snippet. When none is available the field is null, while the email, URL and title are still returned.

**How do I export the X leads into my CRM?**
Export the dataset as CSV, Excel or JSON, or pull it through the Apify API. Webhooks, Zapier, Make and Google Sheets all work with the standard dataset.

**Can I schedule the Twitter X lead generator to run regularly?**
Yes. Apify's scheduler runs it on any cadence you choose, which suits teams that prefer a steady flow of new leads over one large batch.

***

### 🆘 Support & Feedback

If the Twitter X email scraper behaves oddly for a particular set of search terms or market, open a report on the actor's **Issues** tab and include the input you used — reproducibility is what makes a fix quick.

For custom work — extra enrichment fields, a different targeting approach, or an integration into your sales stack — email **scraperhubapi@gmail.com**.

If the actor helps your pipeline, please leave a review on the actor page. Honest ratings help other teams find tools that work.

***

### ⚖️ Disclaimer

This Twitter X B2B email scraper collects only publicly available, indexed information. It does not log into X, access private or protected accounts, or bypass any authentication or access control.

Email addresses and profile details constitute personal data under GDPR, the UK GDPR, CCPA and comparable regimes. You are responsible for establishing a lawful basis before processing them, for honouring opt-out and erasure requests, and for complying with anti-spam legislation including CAN-SPAM, CASL and PECR before contacting anyone on a scraped list. Finding an address is not the same as having permission to email it.

Use of this actor must also comply with X's terms of service, the terms of any search service involved, and Apify's platform terms. Output is provided as-is, with no warranty of accuracy or deliverability.

If you believe personal data collected through this actor should be removed, contact **scraperhubapi@gmail.com** and the request will be handled.

# Actor input Schema

## `searchTerms` (type: `array`):

Topics, hashtags, or job titles to search on X (Twitter).

## `country` (type: `string`):

Select the country for localized lead searching.

## `sourceRegion` (type: `string`):

Select content type: Profiles or Posts (Tweets).

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

Select your preferred scraping method. ⚡ Performance (New): Faster, cheaper, uses residential proxies. 🛡️ Standard: Reliable, uses GOOGLE\_SERP proxy, but slower.

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

Limit the number of emails to collect.

## Actor input object example

```json
{
  "searchTerms": [
    "saas founder",
    "crypto",
    "marketing"
  ],
  "country": "United States",
  "sourceRegion": "All",
  "engine": "legacy",
  "maxEmails": 20
}
```

# Actor output Schema

## `results` (type: `string`):

Records scraped by Twitter X B2b Lead Generator Email Scraper, stored in the run's default dataset.

# 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 = {
    "searchTerms": [
        "saas founder",
        "crypto",
        "marketing"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers-hub/twitter-x-b2b-lead-generator-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 = { "searchTerms": [
        "saas founder",
        "crypto",
        "marketing",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scrapers-hub/twitter-x-b2b-lead-generator-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 '{
  "searchTerms": [
    "saas founder",
    "crypto",
    "marketing"
  ]
}' |
apify call scrapers-hub/twitter-x-b2b-lead-generator-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers-hub/twitter-x-b2b-lead-generator-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/L3riPDPgfPWBPsk8H/builds/nkUNfT0BNTNkyAskQ/openapi.json