How to Find Emails from Twitter Usernames and Followers

To find emails from Twitter usernames at scale, use two Apify Actors together. The Twitter Followers Scraper collects the audience of a public account. The Twitter Email Scraper then looks up available email matches for those usernames. If you already have a username list, you can go straight to the second step.

You can start with a competitor, a creator, a company or another public Twitter/X account whose followers are accessible. The account can belong to someone else. Choose an audience relevant to your business, collect its handles, then turn the available matches into a contact CSV.

The first Actor answers “Who follows this account?” The second answers “Which of these usernames have an available email match?” Keeping those steps separate lets you choose the audience first and reuse its username list later.

For example, you might collect the followers of an industry newsletter, a software founder or a brand in your niche. The target account supplies the audience. The usernames of its followers are the inputs for email lookup.

Open the Twitter Followers Scraper on Apify and click Try for free to open it in Apify Console. Sign in to Apify if prompted, then use the Actor’s Input form. Start with one account so you can check the result before expanding your audience.

1. Enter the target’s username in Twitter Usernames (without @). For https://x.com/nasa, enter nasa. Replace that example with the account you want to research.
2. Turn Include Followers on. Leave Include Following off for a follower-only list.
3. Set Max Followers To Collect. For a first paid-plan example, use 5,000. Choose a target with enough accessible followers for the size you need.
4. Set Result Format to Usernames. This is the setting that makes the export suitable for the email Actor.
5. Review Apify’s run settings and spending limit, then click Start.
6. When collection finishes, open the run’s Dataset and download it as CSV.

The Actor’s default output mode is numeric IDs. Choose usernames explicitly for this workflow so the next step receives handles such as example_founder.

This example requests up to 5,000 followers of nasa. Replace the target and limit for your own run.

{
  "userNameList": ["nasa"],
  "maxFollowers": 5000,
  "getFollowers": true,
  "getFollowing": false,
  "outputMode": "usernames"
}

A paid Apify plan supports the larger collection limits. On the Free plan, this Actor caps a run at 1,000 total results. You can use a 1,000-result first run to learn the export format, then count the usable handles before continuing to email lookup.

Open the CSV in Google Sheets, Excel or another spreadsheet. Each follower is a separate row. The follower’s handle is in value. Keep query_value as well if you want to remember which target account produced that follower.

1. Keep the rows with status = item, relation = followers and mode = usernames.
2. Copy the value column into a clean sheet. Remove its header, blank lines and duplicate handles.
3. Use plain usernames, with surrounding spaces and a leading @ removed.
4. Count the remaining distinct usernames. The email Actor requires at least 1,000.
5. Copy those cells as one username per line. Keep the original follower CSV for the final match-up.

For a small account that produces fewer than 1,000 handles, combine relevant audiences from other public accounts or add an existing username list. Deduplicate the combined list before running the email lookup.

Open the Twitter Email Scraper on Apify. Click Try for free to open its Input form in Apify Console. This Actor accepts the follower usernames you just prepared, or a username list from another source.

1. In Usernames (minimum 1000 required), paste your complete list, one handle per line.
2. Set Max Results to leave enough room for the matches you want to retrieve. With 5,000 submitted usernames, a value of 5,000 gives the available matches room to fit.
3. Review the run’s price and spending settings, then click Start.
4. Wait for the run to finish and open its Dataset.
5. Download CSV for a spreadsheet, or JSON if you want to use the records in another tool.

Paste the usernames themselves into the textarea. A copied column with one handle on each line is the right shape. Check the current Input tab if you are unsure where the list goes.

The two input limits control different things. The username field needs at least 1,000 handles. max_results is the output ceiling and accepts values from 100 to 1,000,000. For example, submitting 50,000 usernames with a 1,000-result cap can stop the output at 1,000 matches. Set the cap with your intended batch size in mind.

Email lookup uses records associated with the submitted usernames. Your export contains the matches available for that audience. The number of emails depends on the accounts in your list and the data available for them.

Start with the screenname and email columns. They tell you which submitted Twitter username each returned address belongs to. Other available fields can include a name, follower count and account creation date.

This short CSV is a fictional example of the result shape.

screenname,email,name
example_founder,alex@northstar.example,Alex Morgan
example_creator,jamie@formly.example,Jamie Chen

Match screenname back to the original follower CSV’s value column, using the same lowercase, trimmed username in both files. Use the username as the key when looking up an email in a spreadsheet. Keep the original follower rows so you can see who received a match and which target audience each person came from.

If a username appears in several target audiences, look it up once and reuse the result for each source row. If a run reaches its output cap or ends early, keep that status with the batch before interpreting missing matches. For an automated merge, follow the Twitter followers-to-email workflow guide.

The same workflow works for large audiences. The follower Actor supports up to 5,000,000 followers and up to 5,000,000 following accounts per target on paid plans, subject to the accessible source and run limits. The email Actor is designed for bulk username lists and allows up to 1,000,000 returned results per run.

For a list of 1,000,000 usernames, one manageable approach is ten batches of 100,000. Give each batch its own filename and save its Apify run ID and Dataset ID. Set max_results to 100,000 for each batch if you want room for every available match in that batch.

Finish and check each batch before merging the files. Combine a final remainder smaller than 1,000 with another batch so every email input meets the minimum. Deduplicate handles across your audiences before enrichment to avoid paying for the same lookup repeatedly.

The follower Actor streams rows into its Dataset while it works. After a large run, read SUMMARY in its key-value store to check completed jobs, emitted rows and any failed targets. Collection time depends on the target size and current source access. Keep spending caps and the current Pricing tabs in view when increasing the volume.

You can also ask an MCP-compatible AI agent to coordinate both Actors. Connect it to Apify’s hosted MCP server at https://mcp.apify.com and authorize your Apify account using the setup supported by your client. The official Apify MCP setup guide covers the connection. Coding agents can also use the Apify agent integration.

Give the agent both Actor names, the target account, your collection limit and the spending limits you approve. It can inspect the input schemas, run the follower collection, read the usernames, then submit the email batch. Here is a prompt you can adapt.

Use Apify to build a Twitter audience email list.

Target account: [TWITTER_USERNAME]
Follower limit: 5,000
Approved spending cap for the follower run: [AMOUNT]
Approved spending cap for the email run: [AMOUNT]

1. Inspect the current input schemas for
   x_guru/twitter-follower-scraper and
   x_guru/twitter-email-scraper.
2. Collect followers of the target account with
   getFollowers=true, getFollowing=false and
   outputMode="usernames".
3. Wait for the run, read its Dataset, and extract
   distinct nonempty usernames from the value field.
4. If there are at least 1,000 usable usernames,
   run the email Actor with those handles, one per line.
   For a large list, aim for batches of 100,000, with
   at least 1,000 handles in every batch.
   Set max_results to each batch size, within the schema limit.
   If the list is smaller, tell me the count and wait
   for more input before starting email lookup.
5. Read the email Dataset and join screenname back
   to the follower usernames.
6. Save a CSV with target_account, username, email
   and lookup_status. Include all original usernames.
   Report collected handles, submitted handles,
   returned matches, run IDs and Dataset IDs.

Apply each approved spending cap through
callOptions.maxTotalChargeUsd when calling that Actor.
Report any incomplete run before presenting final totals.

With Apify MCP, call-actor starts a run and returns its status and storage IDs. The agent checks a longer run with get-actor-run and reads the output with get-dataset-items. For a large Dataset, it should read successive pages using limit and offset before building the final CSV. Keep the resulting files and run IDs so you can repeat or continue the work in your own tools.

Yes. Choose a public, accessible account and enter its username as the follower collection target. A competitor, creator or brand can be the starting point. Protected, suspended or unavailable accounts can restrict collection, and a result limit can stop a run before the full audience is exported.

Yes. In the first Actor, turn getFollowing on and set getFollowers off for a following-only list. Choose username output and use the returned value column in the same email workflow.

The input forms for these two Actors use target accounts and usernames. You run them through your Apify account, with the Actor’s connection to its data source handled by the service.

For one person, start with the profile’s bio and linked business website or contact page. This email Actor is a bulk tool with a 1,000-username minimum. Keep it for an existing list or collect a relevant audience with the follower Actor first.

Check the output cap, the final run status and how many distinct handles were submitted. Some profiles have an available match and others may have none. Keep the source list, review unusual matches and check deliverability before using a returned email for outreach.

To start, open the Twitter Followers Scraper for your audience, then pass its usernames to the Twitter Email Scraper. For a more detailed follower export, see the Twitter followers CSV guide. For a repeatable API setup, see the Apify run and Dataset export guide.