# Twitter Phone Number Scraper (`scraperoka/twitter-phone-number-scraper`) Actor

📱 Twitter Phone Number Scraper extracts verified phone numbers from Twitter profiles with precision and speed. 🚀 Great for B2B lead gen, outreach, and market research—helping you connect faster with the right prospects. 🔎

- **URL**: https://apify.com/scraperoka/twitter-phone-number-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 Phone Number Scraper 🎯 — Extract Phone Numbers from Twitter Bios & Posts

Manually hunting for phone numbers across hundreds of Twitter profiles wastes hours you don’t have. **Twitter Phone Number Scraper** helps you automatically scrape phone numbers from publicly available Twitter bios, profiles, and posts using your keywords and a country dial code—so ideal for marketers, recruiters, and growth teams looking to build lead lists quickly. This Twitter phone number scraper turns search terms into a structured dataset you can analyze or export, often producing results at scale in a single run.

***

### What You Get: Sample Output

Here's a sample record from a single run:

```json
{
  "platform": "Twitter",
  "keyword": "marketing",
  "title": "Marketing lead • DMs open",
  "description": "🚀 Growth | Contact +44 7700 900123 | DM for partnerships",
  "url": "https://x.com/example_profile",
  "phone_number": "+447700900123",
  "country": "United Kingdom",
  "dial_code": "+44",
  "proxyGroups": [
    "legacy"
  ]
}
```

| Field | Type | What It Tells You |
|---|---|---|
| `platform` | string | Confirms the source platform is Twitter for easy pipeline routing |
| `keyword` | string | Which keyword produced the match, so you can track lead quality by theme |
| `title` | string | The result title/text captured from the source page for context |
| `description` | string | The source text where the phone number was detected (useful for auditing) |
| `url` | string | Direct link to the Twitter page where the phone number appeared |
| `phone_number` | string | The normalized phone number (E.164 format) you can deduplicate and import |
| `country` | string | The target country used for validation and regional consistency |
| `dial_code` | string | Dial code used to guide targeting during the run |
| `proxyGroups` | array | The proxy configuration set associated with the run (helpful for debugging/repro) |
| `error_message` / `status` | (not included in pushed row) | If you don’t see these fields in your dataset, that’s expected—this actor pushes the `row` shown above |

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

***

### Why Twitter Phone Number Scraper?

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

#### Keyword and phone targeting in one run

You provide `keywords` plus a `country` (with a dial code), and the actor focuses on phone numbers it finds in Twitter bios, profiles, and posts related to your input. This makes the Twitter contact scraper workflow more about lead intent than random harvesting.

#### Clean, structured output for lead lists

For each discovered match, the actor pushes a consistent record with fields like `phone_number`, `url`, `keyword`, and the surrounding `description`. That’s exactly what you want from a Twitter phone number finder when you’re building a usable list, not a pile of raw HTML.

#### Deduplication + max results control

The actor tracks `seen_numbers` to avoid collecting the same phone number repeatedly during the run. It also respects `maxPhoneNumbers`, stopping once the cap is reached—so you can test quickly or scale deliberately.

#### Resilience for real-world runs

The actor includes fallback and retry behavior to keep scraping moving when pages fail or return empty results. If you’re doing a bulk Twitter phone number scraper job, that resilience matters when you’re collecting at scale.

***

### Configuring Your Run

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

```json
{
  "keywords": ["marketing", "founder"],
  "platform": "Twitter",
  "country": "United Kingdom (+44)",
  "maxPhoneNumbers": 20,
  "engine": "legacy",
  "proxyConfiguration": {}
}
```

| Parameter | Required | What It Does |
|---|---|---|
| `keywords` | ✅ | A list of keywords to search for (for example: business terms, roles, or names you care about) |
| `platform` | ⬜ | Select platform. Available option is `Twitter` |
| `country` | ✅ | Select a country to scrape related phone numbers for (the dial code is used as part of targeting/validation) |
| `maxPhoneNumbers` | ⬜ | Sets the maximum number of phone numbers to collect; the scraper stops when this limit is reached |
| `engine` | ⬜ | Choose scraping engine: `cost-effective` (new) or `legacy` |
| `proxyConfiguration` | ⬜ | Configure proxies for this Actor run |

***

### Core Capabilities

#### Finds phone numbers from public Twitter content

Twitter Phone Number Scraper extracts phone numbers from Twitter bios, profiles, and posts that relate to your provided `keywords` and `country`. This supports workflows like a Twitter phone number list scraper or a Twitter lead phone number scraper when you need real-world contact signals.

#### Output that’s ready to analyze and import

Each discovered match is pushed to your dataset as a structured JSON row including `phone_number` (E.164), the source `url`, and the matched text in `description`. That makes the Twitter phone number data tool output straightforward for deduping, enrichment, and reporting.

#### Deduplication built in

The actor keeps track of phone numbers it has already collected (via `seen_numbers`) during the run, which reduces noise for Twitter phone number harvesting tasks and improves dataset cleanliness.

#### Controlled scale with `maxPhoneNumbers`

You can stop runs at a specific volume using `maxPhoneNumbers` (up to 10000). This is ideal when you’re running multiple keyword batches as a bulk Twitter phone number scraper.

#### Retries and fallbacks for stability

When pages fail or results come back empty, the actor performs retry logic to recover. If you’re running Twitter user phone number lookup at scale, these resilience behaviors help keep the pipeline producing data.

***

### Who Gets the Most Out of This

Here's how different teams put Twitter Phone Number Scraper to work:

**Outreach and lead generation teams** use Twitter phone number extraction to quickly turn keyword themes (like “marketing” or “founder”) into a structured phone dataset, then import it into their CRM for follow-up.

**Recruiters and staffing coordinators** leverage the Twitter contact scraper output to identify phone-based reachability signals tied to specific roles and interests, shortening the time from sourcing to contacting candidates.

**Growth analysts and data researchers** benefit from the consistent fields (`phone_number`, `keyword`, `url`, and `description`) to measure lead coverage and compare which keyword sets yield the most usable contacts.

**Automation specialists and developers** can integrate the results into downstream workflows by reading the dataset output and pushing enriched records into their own systems using the Apify run artifacts.

**Business owners running targeted campaigns** can use Twitter phone number finder workflows to compile region-specific phone lists by selecting a `country` dial code and then re-running with broader or refined keywords as needed.

***

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

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

1. **Open the actor on Apify** — go to [console.apify.com](https://console.apify.com) and open Twitter Phone Number Scraper.
2. **Enter your inputs** — set `keywords` and `country` (required), and optionally tune `maxPhoneNumbers`, `engine`, and `proxyConfiguration`.
3. **Configure proxy settings** — use `proxyConfiguration` if you want to control how the actor routes requests for reliability.
4. **Hit Run and watch the live log** — monitor progress as results are collected and pushed.
5. **View results in the dataset tab** — the actor writes each phone match to your dataset as it goes.
6. **Export as JSON, CSV, or Excel** — download directly from the Apify dataset tab when you’re satisfied with coverage.

The whole process takes under 5 minutes to set up.

***

### Integrations & Export Options

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

You can export results as **JSON, CSV, or Excel** from the Apify dataset tab for quick importing into spreadsheets and analytics tools.

For automation, you can connect your Apify runs to your systems using **Apify API access**, **webhooks**, and no-code platforms like **Zapier** or **Make**. If you need recurring lead refreshes, you can also schedule runs via Apify (refer to Apify documentation for details): https://apify.com/docs/api

***

### Pricing & Free Trial

Twitter Phone Number Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started.

Free tier credit is intended for testing and smaller scraping jobs, while larger projects run on Apify’s pay-as-you-go model based on platform compute (see Apify pricing for the latest details). Start for free at [apify.com](https://apify.com) and scale when you’re ready.

***

### Reliability & Performance

| What We Handle | How |
|---|---|
| Rate-limit and page failures | Includes fallback and retry logic to improve run stability |
| Duplicate phone numbers | Deduplicates using a `seen_numbers` set to reduce repeated results |
| Output completeness during long runs | Streams results into your dataset as they are found |
| Scale control | Stops at your `maxPhoneNumbers` limit so runs don’t run away |

**Limitations:** This actor only works with phone numbers it finds in publicly available Twitter bios, profiles, and posts related to your keywords. Private or login-gated content is out of scope, and not every profile will contain a phone number.

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

***

### Frequently Asked Questions

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

Yes. Apify offers a free tier for new users, so you can run Twitter phone number scraping tests before committing to larger workloads.

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

No. Twitter Phone Number Scraper is designed to work with publicly available Twitter content, without requiring a Twitter login.

#### How accurate is the data from this Twitter phone number finder?

The accuracy depends on what’s actually published on the target Twitter bios, profiles, and posts. The actor extracts phone numbers present in the source text and validates them using the selected country context.

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

You control the maximum with `maxPhoneNumbers`. The actor will stop collecting once it reaches that limit, even if more matches might exist.

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

Data freshness depends on when you run the actor. Each run scrapes publicly available content at that time, so you’ll get the latest results for that run window.

#### Is it legal to use this for GDPR / CCPA use cases?

Use of extracted phone numbers must comply with applicable laws and regulations and the platform’s Terms of Service. Twitter Phone Number Scraper pulls **publicly available data**, and it’s your responsibility to ensure your use is lawful for your jurisdiction and purpose.

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

Yes. You can export your dataset as JSON, CSV, or Excel from the Apify dashboard, which can then be imported into Google Sheets or your spreadsheet/CRM tool of choice.

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

Yes. You can schedule Actor runs in Apify to refresh your Twitter lead phone number scraper lists automatically—see Apify scheduling documentation for setup details.

#### Can I access Twitter Phone Number Scraper via API?

Yes. You can trigger runs programmatically and retrieve outputs using the Apify API (see https://apify.com/docs/api).

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

The actor includes retry/fallback behavior to keep scraping stable. If errors persist for a specific portion of the run, you’ll still get whatever results were successfully pushed to the dataset up to that point.

***

### Need Help or Have a Request?

Got a question about Twitter Phone Number Scraper or want a new feature added? Reach out at <dataforleads@gmail.com> — we respond quickly and actively maintain this actor based on user feedback. If you want improvements like webhook notifications on completion or additional filtering options, let us know what outcome you’re aiming for.

***

### Disclaimer & Responsible Use

*Twitter Phone Number Scraper is the fastest, most reliable way to build keyword-based Twitter phone number lists — start your free run today.*

This actor collects **publicly available data** from Twitter bios, profiles, and posts. It does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, platform Terms of Service, and any other applicable 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 to search for. (Example: John, marketing, etc.)

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

Select platform.

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

Select a country to scrape related phone numbers.

## `maxPhoneNumbers` (type: `integer`):

Maximum number of phone numbers 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": [
    "marketing",
    "founder"
  ],
  "platform": "Twitter",
  "country": "United Kingdom (+44)",
  "maxPhoneNumbers": 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": [
        "marketing",
        "founder"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/twitter-phone-number-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": [
        "marketing",
        "founder",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("scraperoka/twitter-phone-number-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": [
    "marketing",
    "founder"
  ]
}' |
apify call scraperoka/twitter-phone-number-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Ik4XYmrlAqUQhoVfo/builds/7Uef399FBhOnWVtHS/openapi.json