# X (Twitter) Email Lookup & Profile Finder (`arjun_code/x-twitter-email-lookup`) Actor

Find email associations for X / Twitter usernames or reverse-search email addresses for matching public profiles. Export associated emails and current profile details without supplying X login cookies, API keys, or proxy settings. Process up to 100 unique inputs per run.

- **URL**: https://apify.com/arjun_code/x-twitter-email-lookup.md
- **Developed by:** [Arjun AI](https://apify.com/arjun_code) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 matched x profile results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

Find email associations for **X / Twitter usernames**, or reverse-search an email address to discover matching public X profiles. The Actor combines association matching with a current X profile check, so saved profile results contain up-to-date public account details instead of an unverified username alone.

Enter usernames, email addresses, or both. No X login, cookies, API key, or proxy configuration is required. Results can be exported as JSON, CSV, Excel, XML, or RSS and used through the Apify API, schedules, webhooks, and integrations.

### What can this X email lookup do?

- Find email addresses associated with an X username, `@handle`, or profile URL.
- Reverse-search an email address for associated X accounts.
- Confirm that a matched X account is currently available before saving its profile.
- Return public profile data such as the display name, bio, location, follower counts, verification status, profile image, and account creation date.
- Normalize and deduplicate equivalent usernames and case-insensitive email addresses.
- Process up to 100 valid, unique usernames and email addresses in one run.
- Save clear status rows when an input has no match or its associated X account is unavailable.

### How to use

1. Add one or more values under **X usernames** or **Email addresses**.
2. You may fill in either section or use both in the same run.
3. Select **Start**.
4. Open the Dataset **Overview** to review matched profiles.
5. Open **Status rows** to understand inputs that did not produce an available profile.
6. Export the Dataset or connect the Actor to an API, schedule, webhook, Make, Zapier, Google Sheets, or another Apify integration.

### Input

| Field | What to enter |
| --- | --- |
| `usernames` | X usernames such as `apify`, handles such as `@apify`, or profile URLs such as `https://x.com/apify` |
| `emails` | Complete email addresses. Matching is case-insensitive, so `Name@Example.com` and `name@example.com` are treated as the same input |

The combined limit is 100 valid, unique values per run. Blank or malformed values are ignored. Equivalent usernames and repeated email addresses are queried only once. If the normalized batch exceeds the limit, the Actor returns a friendly `invalid_input` status row instead of silently truncating the request.

```json
{
  "usernames": [
    "apify",
    "https://x.com/example_account"
  ],
  "emails": [
    "contact@example.com"
  ]
}
```

### Output

Each successful Dataset item represents one unique, currently available X account. The associated email addresses are grouped with the current public profile data.

The following JSON is an illustrative structure. Actual values are returned only when an association exists and the X profile is available.

```json
{
  "status": "success",
  "user_id": "123456789",
  "screen_name": "example_account",
  "name": "Example Account",
  "emails": [
    "contact@example.com"
  ],
  "profile_url": "https://x.com/example_account",
  "description": "Example public profile bio",
  "location": "San Francisco",
  "created_at": "2020-01-15T10:30:00Z",
  "website_url": "https://example.com",
  "profile_image_url": "https://pbs.twimg.com/profile_images/example_normal.jpg",
  "followers_count": 12500,
  "following_count": 420,
  "tweets_count": 3100,
  "verified": false,
  "is_blue_verified": true,
  "protected": false
}
```

Depending on what X returns for an account, results can also contain profile banner, media count, likes given, list count, verification type, professional categories, creator subscriptions, sensitivity status, and account labels.

#### Status rows

Inputs without a saved profile remain visible as lightweight diagnostic records:

| Status | Meaning |
| --- | --- |
| `not_found` | No association was found for the supplied username or email address |
| `account_unavailable` | An association exists, but the X account is unavailable, suspended, or no longer exists |
| `lookup_failed` | The association or current profile could not be checked; retry the input later |
| `invalid_input` | No valid input was supplied or the 100-input limit was exceeded |

Status rows do not contain fabricated profile details.

### Pricing

The Actor uses pay-per-event pricing. One `email-profile-result` event is charged for each unique, currently available X profile saved with at least one email association. Diagnostic rows such as `not_found`, `account_unavailable`, `lookup_failed`, and `invalid_input` are not charged as successful results.

| Apify plan | Per successful profile | Per 1,000 successful profiles |
| --- | ---: | ---: |
| Free | $0.0035 | $3.50 |
| Bronze | $0.0030 | $3.00 |
| Silver | $0.0027 | $2.70 |
| Gold | $0.0025 | $2.50 |
| Platinum | $0.0025 | $2.50 |
| Diamond | $0.0025 | $2.50 |

An `apify-actor-start` event costs $0.00005 per run. Platform usage is included in the configured event prices. Use **Maximum cost per run** in Apify Run options when you need a fixed spending limit. The Pricing tab is the source of truth if prices change later.

### API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/arjun_code~x-twitter-email-lookup/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"usernames":["apify"]}'
```

The run's output links to the default Dataset, where results can be downloaded in multiple formats.

### Data coverage, privacy, and responsible use

An email association means that the address and X username are linked in the available association data. It does **not** prove that the mailbox is currently deliverable, that the account owner still controls it, or that the owner has publicly disclosed it. Association data can be incomplete, historical, or outdated. Public X profile fields are refreshed only after a match is found.

Lookup inputs are transmitted over HTTPS to a creator-operated matching service so the requested association can be checked. Only submit personal data that you are authorized and legally permitted to process. Do not use the Actor for spam, harassment, impersonation, unlawful surveillance, or other activity that violates applicable law, X's terms, or Apify's Acceptable Use Policy.

For a correction, removal request, or support question, open an issue on the Actor page and identify the affected association without posting additional sensitive information publicly.

This Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by X Corp.

### FAQ

#### Why did my input return `not_found`?

The available association data did not contain a match. This does not prove that no email address or X account exists.

#### Why was a matched account not saved?

The associated X account may be suspended, deleted, renamed, temporarily unavailable, or inaccessible during the current check. Review the Status rows view for the exact outcome.

#### Are the returned emails verified?

No. They are association records, not live mailbox-verification results. Verify suitability, accuracy, and permission before using them.

#### Can I automate recurring lookups?

Yes. Save the input as an Apify Task, run it on a schedule, or connect the Dataset to webhooks and integrations.

# Actor input Schema

## `usernames` (type: `array`):

Enter one X username per line. You can use a username, @handle, or full x.com/twitter.com profile URL. Duplicate accounts are queried only once. Usernames and email addresses together may contain up to 100 valid, unique inputs.

## `emails` (type: `array`):

Enter one email address per line. Email matching is case-insensitive, and duplicate addresses are queried only once. Email addresses and usernames together may contain up to 100 valid, unique inputs.

## Actor input object example

```json
{
  "usernames": [
    "apify"
  ]
}
```

# Actor output Schema

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

Matched profiles plus clear status rows for inputs with no available result.

# 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 = {
    "usernames": [
        "apify"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("arjun_code/x-twitter-email-lookup").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 = { "usernames": ["apify"] }

# Run the Actor and wait for it to finish
run = client.actor("arjun_code/x-twitter-email-lookup").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 '{
  "usernames": [
    "apify"
  ]
}' |
apify call arjun_code/x-twitter-email-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arjun_code/x-twitter-email-lookup"
        }
    }
}
```

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/5AqOxRbkZV9a7WMnw/builds/wpARnhToERGbv2cJU/openapi.json