# X (twitter) User Followers (`datamagnet/x-twitter-user-followers`) Actor

Get a user's latest followers in a clean, readable list.

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

## Pricing

from $3.00 / 1,000 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Latest Followers Scraper

Latest Followers Scraper is an easy-to-use X/Twitter follower data collector that helps you retrieve the newest followers for any username in a clean, readable format. It is ideal for marketers, researchers, creators, and analysts who want to track audience growth, review follower quality, or export follower data for reporting. You can filter the results to show all followers, only verified followers, or only non-verified followers, making it simple to focus on the audience segment that matters most. The actor automatically keeps loading more followers until it reaches your chosen limit, so you get a complete and organized dataset without manual work.

### Key Features
- Extract the latest followers for any X/Twitter username in a simple list.
- Collect follower details such as name, handle, profile image, verification status, and profile link.
- Filter results to include all followers, only verified followers, or only non-verified followers.
- Export clean follower data for spreadsheets, dashboards, CRM tools, or reporting.
- Handle larger follower lists automatically without you needing to load more results yourself.
- Save time by turning follower discovery into a repeatable, one-click workflow.
- Support audience analysis with additional profile details like bio, follower count, and account age when available.

### Use Cases

#### Audience Growth Tracking
Social media managers use this actor to monitor who is following a brand, creator, or public figure over time. By reviewing fields like follower name, handle, verified status, and profile URL, they can quickly understand whether audience growth is coming from credible accounts, niche communities, or general users.

#### Influencer and Creator Research
Agencies and brand teams can study the latest followers of a creator to understand audience composition before partnerships or campaigns. Details such as profile image, bio, follower count, and verification status help them judge whether the audience looks relevant, active, and aligned with the brand.

#### Lead and Prospect Discovery
Sales and partnership teams can use follower data to identify potential leads among people who follow a target account. The follower handle, name, website, location, and profile description can help teams spot decision-makers, creators, founders, or niche professionals worth reaching out to.

#### Competitive Intelligence
Analysts can compare the latest followers of competing accounts to see what kind of audience each brand attracts. Looking at follower names, verification status, and profile details can reveal shifts in audience quality, market interest, or community overlap.

#### Community and Reputation Monitoring
Public relations and community teams can review new followers to better understand who is engaging with a brand or public figure. The actor makes it easier to spot verified accounts, business profiles, and other notable followers that may matter for reputation tracking or relationship management.

### Input

| Field | Type | Required | Description | Example |
|---|---|---:|---|---|
| screenname | String | Yes | The X username you want to look up, without the @ symbol. | elonmusk |
| max_results | Integer | No | The maximum number of followers you want returned. | 10 |
| blue_verified | String | No | Choose whether to show all followers, only verified followers, or only non-verified followers. | 0 |

### Output

| Field | Type | Description |
|---|---|---|
| user_id | String | The unique ID of the follower account. Useful for matching records across exports. |
| screen_name | String | The follower’s X username without the @ symbol. |
| description | String | The bio or profile description shown on the account. Helpful for understanding who the follower is. |
| profile_image | String | Link to the follower’s profile picture. |
| statuses_count | Integer | How many posts the account has made. A useful sign of account activity. |
| followers_count | Integer | How many followers the account has. Helps gauge account size and influence. |
| friends_count | Integer | How many accounts the user follows. Useful for audience and activity analysis. |
| media_count | Integer | How many media posts the account has shared. |
| created_at | String | When the account was created. Helpful for spotting newer or older accounts. |
| can_dm | Boolean | Whether the account can receive direct messages. |
| location | String | Any location listed on the profile. |
| blue_verified | Boolean | Whether the account has blue verification status. |
| verified | Boolean | Whether the account has legacy verification status. |
| website | String | Any website or link listed on the profile. |
| name | String | The display name shown on the profile. |
| affiliates | Object | Extra profile affiliation details, such as linked organizations or labels, when available. |
| business_account | String or Null | Indicates whether the account is marked as a business account, if available. |

### Sample Output
```json
{
  "user_id": "95092020",
  "screen_name": "jordanbpeterson",
  "description": "Best-Selling Author | Clinical Psychologist | #1 Education Podcast | Co-founder of @petersonacademy | Order my new book \"We Who Wrestle With God\" here:",
  "profile_image": "https://pbs.twimg.com/profile_images/1407056014776614923/TKBC60e1_normal.jpg",
  "statuses_count": 51538,
  "followers_count": 6177999,
  "friends_count": 1652,
  "media_count": 7374,
  "created_at": "Sun Dec 06 23:33:02 +0000 2009",
  "can_dm": true,
  "location": "",
  "blue_verified": true,
  "verified": false,
  "website": "http://jordanbpeterson.com/books",
  "name": "Dr Jordan B Peterson",
  "affiliates": {
    "label": {
      "badge": {
        "url": "https://pbs.twimg.com/profile_images/2010195782155350017/0xKKxQJs_bigger.jpg"
      },
      "description": "Peterson Academy",
      "url": {
        "url": "https://twitter.com/petersonacademy",
        "urlType": "DeepLink"
      },
      "userLabelDisplayType": "Badge",
      "userLabelType": "BusinessLabel"
    }
  },
  "business_account": null
}
````

### How It Works

1. Enter the username you want to check.
2. Choose whether you want all followers, only verified followers, or only non-verified followers.
3. Set the maximum number of results you want returned.
4. Start the actor and let it gather the latest followers automatically.
5. Review the finished dataset and export it for analysis, reporting, or sharing.

### Getting Started

Getting started is simple and does not require coding knowledge. Just click **Try for free**, enter the username you want to analyze, choose your filter if needed, and click **Run**. The actor will collect the latest followers and organize them into a clean dataset you can review right away. When the run is finished, you can download the results in **JSON, CSV, or Excel** format.

### Frequently Asked Questions

#### Do I need technical skills to use this actor?

No. This actor is designed for business users, marketers, researchers, and anyone who wants follower data without dealing with complicated setup. You only need to enter a username, choose your options, and run it.

#### How fast does it run?

Speed depends on how many followers you ask for and how large the target account is. Smaller requests usually finish quickly, while larger requests may take longer because the actor keeps gathering more results until it reaches your limit.

#### What format is the output?

Your results are available in formats that are easy to work with, including JSON, CSV, and Excel. That makes it simple to open the data in spreadsheets, share it with teammates, or import it into your reporting workflow.

#### Is it legal to use?

The actor is intended for lawful research, analysis, and business use. You should always make sure your use complies with applicable laws, platform rules, and your own internal policies before collecting or using any data.

#### Can I schedule it to run automatically?

Yes, you can set it up to run on a schedule if you want regular follower updates. This is useful for ongoing monitoring, recurring reports, or tracking audience changes over time without manual effort.

# Actor input Schema

## `screenname` (type: `string`):

The Twitter/X username to look up, without the @ symbol.

## `max_results` (type: `integer`):

Maximum number of followers to return.

## `blue_verified` (type: `string`):

Show only followers with blue verification status. Use 1 for yes or 0 for no.

## Actor input object example

```json
{
  "screenname": "elonmusk",
  "max_results": 10,
  "blue_verified": "0"
}
```

# 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 = {
    "screenname": "elonmusk"
};

// Run the Actor and wait for it to finish
const run = await client.actor("datamagnet/x-twitter-user-followers").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 = { "screenname": "elonmusk" }

# Run the Actor and wait for it to finish
run = client.actor("datamagnet/x-twitter-user-followers").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 '{
  "screenname": "elonmusk"
}' |
apify call datamagnet/x-twitter-user-followers --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=datamagnet/x-twitter-user-followers",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "X (twitter) User Followers",
        "description": "Get a user's latest followers in a clean, readable list.",
        "version": "0.0",
        "x-build-id": "AhJ7bel69MkHcpzzb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datamagnet~x-twitter-user-followers/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datamagnet-x-twitter-user-followers",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/datamagnet~x-twitter-user-followers/runs": {
            "post": {
                "operationId": "runs-sync-datamagnet-x-twitter-user-followers",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/datamagnet~x-twitter-user-followers/run-sync": {
            "post": {
                "operationId": "run-sync-datamagnet-x-twitter-user-followers",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "screenname"
                ],
                "properties": {
                    "screenname": {
                        "title": "Screen name",
                        "type": "string",
                        "description": "The Twitter/X username to look up, without the @ symbol."
                    },
                    "max_results": {
                        "title": "Max results",
                        "type": "integer",
                        "description": "Maximum number of followers to return.",
                        "default": 10
                    },
                    "blue_verified": {
                        "title": "Blue verified",
                        "enum": [
                            "0",
                            "1"
                        ],
                        "type": "string",
                        "description": "Show only followers with blue verification status. Use 1 for yes or 0 for no."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
