# X / Twitter Lists Scraper — Members & Subscribers (`arjun_code/x-twitter-lists-scraper`) Actor

Discover public X / Twitter Lists an account owns, follows, or belongs to. Export List details, owners, members, and subscribers from usernames, user IDs, List IDs, or URLs. Build audience and lead datasets with automatic pagination—no X login, cookies, or API key required.

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

## Pricing

from $0.20 / 1,000 list data results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

Collect public X / Twitter List data without supplying a login, cookies, API key, or proxy. Discover the Lists an account owns, follows, or belongs to, then export detailed List members and subscribers to JSON, CSV, Excel, or an API-ready Dataset.

Use one Actor to:

- Collect owned Lists, followed Lists, List memberships, members, and subscribers.
- Start from usernames, profile URLs, user IDs, List IDs, or full List URLs.
- Follow pagination automatically and control the result limit for every account or List.
- Keep valid targets running when another input is invalid, unavailable, or returns no public results.

Use the results for audience research, influencer discovery, community mapping, recruiting, competitive intelligence, and targeted lead generation.

### What can this X / Twitter Lists scraper collect?

| Operation | Input | Result |
| --- | --- | --- |
| Lists owned or followed by accounts | Username, profile URL, or user ID | Public Lists the account created or follows |
| Lists containing accounts | Username, profile URL, or user ID | Public Lists that include the account as a member |
| Members of Lists | List ID or `x.com/i/lists/...` URL | Visible public profiles that are members of the List |
| Subscribers of Lists | List ID or `x.com/i/lists/...` URL | Visible public profiles that follow the List |

### How to use

1. Choose the data you want: account Lists, List memberships, List members, or List subscribers.
2. Enter up to 50 unique usernames, user IDs, List IDs, or List URLs for the selected operation.
3. Set a result limit, or enter `0` to continue through every result X makes visible.
4. Start the Actor and open the Dataset to review or export the results.

The Console opens with a quick-test input: **Lists owned or followed by accounts**, `https://x.com/TheZvi`, and a limit of `3` Lists per relationship.

#### Start with a ready-made workflow

- [Discover X Lists an account owns or follows](https://apify.com/arjun_code/x-twitter-lists-scraper/examples/discover-x-lists-owned-or-followed)
- [Export members of an X List](https://apify.com/arjun_code/x-twitter-lists-scraper/examples/export-members-of-an-x-list)
- [Export subscribers of an X List](https://apify.com/arjun_code/x-twitter-lists-scraper/examples/export-subscribers-of-an-x-list)

Each example opens with a tested input and a Dataset view tailored to that result type.

#### Input

Use `screenNames` or `userIds` for account-based operations. Use `listIds` only when collecting members or subscribers from specific Lists.

| Parameter | Type | Used by | Default | Description |
| --- | --- | --- | --- | --- |
| `operation` | string | All operations | `account_lists` | Select Account Lists, List memberships, List members, or List subscribers. |
| `screenNames` | string array | Account Lists, List memberships | — | Usernames, `@handles`, or X / Twitter profile URLs. Numeric-only values are automatically treated as user IDs. |
| `userIds` | string array | Account Lists, List memberships | `[]` | Numeric X / Twitter user IDs. Combined with `screenNames`, up to 50 unique account inputs are accepted. |
| `listIds` | string array | List members, List subscribers | `[]` | Numeric List IDs or full List URLs. Up to 50 unique Lists are accepted. |
| `accountListType` | string | Account Lists | `all` | Collect owned Lists, followed Lists, or both. |
| `maxListsPerAccount` | integer | Account Lists, List memberships | `100` | Maximum Lists per account and relationship. Use `0` for every visible result. |
| `maxUsersPerList` | integer | List members, List subscribers | `100` | Maximum users per List. Use `0` for every visible result. |

Inputs are normalized and deduplicated before requests are made. When `accountListType` is `all`, `maxListsPerAccount` applies separately to owned and followed Lists.

The Console is prefilled with `maxListsPerAccount: 3` so a first run stays quick. When the field is omitted from an API input, the schema default is `100`.

Example — collect both owned and followed Lists:

```json
{
  "operation": "account_lists",
  "screenNames": ["https://x.com/TheZvi"],
  "accountListType": "all",
  "maxListsPerAccount": 3
}
```

Example — find Lists containing an account:

```json
{
  "operation": "memberships",
  "userIds": ["745273"],
  "maxListsPerAccount": 0
}
```

Example — export List subscribers:

```json
{
  "operation": "subscribers",
  "listIds": ["https://x.com/i/lists/1597115448146898944"],
  "maxUsersPerList": 100
}
```

Example — export List members:

```json
{
  "operation": "members",
  "listIds": ["https://x.com/i/lists/1455191294725312517"],
  "maxUsersPerList": 100
}
```

#### Pagination and limits

Pagination is automatic and independent for every account, relationship, or List. Up to 50 unique account inputs or 50 unique Lists can be submitted in one run. Result limits apply separately to each account, relationship, or List; enter `0` to continue through every page X makes visible.

When **Both owned and followed** is selected, `maxListsPerAccount` applies separately to owned and followed Lists. Protected, private, suspended, deleted, or otherwise restricted resources may return limited data or a status row.

### Output

Each successful Dataset row represents one List, one visible member, or one visible subscriber. When an input has no visible result or cannot be requested, the Actor stores a status row instead of inventing data.

#### Account Lists Dataset

[![X Twitter Lists Scraper Dataset showing owned and followed Lists](https://raw.githubusercontent.com/arjun-go-go/apify-actor-assets/main/x-twitter-lists-scraper/x-twitter-account-lists-dataset.png)](https://raw.githubusercontent.com/arjun-go-go/apify-actor-assets/main/x-twitter-lists-scraper/x-twitter-account-lists-dataset.png)

*Example Dataset showing Lists owned and followed by an X account, including relationship type, List size, subscriber count, and owner details.*

#### List members Dataset

[![X Twitter List members Dataset with public profile and audience fields](https://raw.githubusercontent.com/arjun-go-go/apify-actor-assets/main/x-twitter-lists-scraper/x-twitter-list-members-dataset.png)](https://raw.githubusercontent.com/arjun-go-go/apify-actor-assets/main/x-twitter-lists-scraper/x-twitter-list-members-dataset.png)

*Example List members Dataset with public profile links, follower and following counts, post counts, and verification fields.*

#### Available fields

List results include:

- List ID, name, URL, description, visibility, and creation time.
- Member and subscriber counts.
- Relationship to the requested account: `owned`, `subscribed`, or `member_of`.
- List owner identity, profile, bio, counts, verification, and avatar.

Member results include:

- User ID, username, name, profile URL, bio, location, and website.
- Account creation time and profile images.
- Follower, following, post, media, and like counts.
- Blue verification, protection, sensitivity, professional, and affiliation fields when X returns them.

Subscriber results include:

- User ID, username, name, profile URL, bio, location, and website.
- Account creation time, profile images, pinned posts, and bio entities.
- Follower, following, post, media, like, and listed counts.
- Additional profile settings such as media tagging, geo, extended profile, custom timelines, and business profile state when X returns them.

#### Example List result

```json
{
  "status": "success",
  "result_type": "list",
  "operation": "account_lists",
  "relationship_type": "owned",
  "source_screen_name": "TheZvi",
  "list_id": "2000911746408567135",
  "list_name": "All",
  "list_url": "https://x.com/i/lists/2000911746408567135",
  "member_count": 463,
  "subscriber_count": 16,
  "owner_screen_name": "TheZvi",
  "owner_name": "Zvi Mowshowitz"
}
```

#### Example List member result

```json
{
  "status": "success",
  "result_type": "user",
  "operation": "members",
  "relationship_type": "member",
  "list_id": "1455191294725312517",
  "user_id": "1851022715043332096",
  "screen_name": "theDCApod",
  "name": "The DCA Pod",
  "profile_url": "https://x.com/theDCApod",
  "followers_count": 5303,
  "following_count": 5,
  "is_blue_verified": true
}
```

#### Example List subscriber result

```json
{
  "status": "success",
  "result_type": "user",
  "operation": "subscribers",
  "relationship_type": "subscriber",
  "list_id": "1455191294725312517",
  "user_id": "1859520867488747521",
  "screen_name": "SinaRPrimeP",
  "name": "Sina",
  "profile_url": "https://x.com/SinaRPrimeP",
  "followers_count": 0,
  "following_count": 3574,
  "verified": false
}
```

Examples are shortened for readability. Counts and public profile details can change between runs.

#### Dataset views and exports

The Dataset provides separate views so unrelated result types do not clutter the table:

- **Overview** shows the most useful List or profile fields.
- **Lists & owners — all fields** contains complete List and creator details.
- **List members — all fields** contains the member profile fields returned by X.
- **List subscribers — all fields** contains the subscriber profile fields returned by X.
- **Status rows** contains `invalid_input`, `no_results`, `not_found`, and request-failure details. Invalid or mismatched inputs are reported here without failing the whole run.

Download the Dataset as JSON, JSONL, CSV, Excel, XML, or RSS, or retrieve it through the Apify API.

### How much does it cost to scrape X Lists?

This Actor uses pay-per-event pricing. Each successfully stored List record, List member profile, or List subscriber profile produces one `list-data-result` event at **$0.0002**, equivalent to **$0.20 per 1,000 results**. Platform usage is included in the event price, and diagnostic, no-result, not-found, and request-failure rows are free.

| Successful results | Estimated price |
| ---: | ---: |
| 100 | `$0.02005` |
| 1,000 | `$0.20005` |
| 10,000 | `$2.00005` |

Estimates include one **$0.00005 Actor Start** event at the default 512 MB memory setting. The number of Actor Start events can increase if more than 1 GB of memory is selected.

Use the result-limit inputs and Apify's **Maximum cost per run** setting to control spending. When that limit is reached, the Actor stops before requesting more pages.

### API, scheduling, and integrations

Start a run with a standard HTTP request:

```bash
curl -X POST "https://api.apify.com/v2/acts/arjun_code~x-twitter-lists-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "operation": "members",
    "screenNames": [],
    "userIds": [],
    "listIds": ["1455191294725312517"],
    "accountListType": "all",
    "maxListsPerAccount": 100,
    "maxUsersPerList": 100
  }'
```

The Actor can also be called with the Apify JavaScript or Python client. Its Output Schema links directly to the run's default Dataset.

- Save an input as an Apify Task for repeatable runs.
- Schedule recurring List or membership collection from Apify Console.
- Trigger downstream workflows with webhooks when a run succeeds or fails.
- Connect results to Make, Zapier, Google Sheets, databases, or your own application through the Dataset API.

### FAQ

#### Do I need an X account, cookies, or an X API key?

No user-supplied X login, cookies, API key, or proxy settings are required.

#### Can I enter both usernames and user IDs?

Yes. Account operations accept usernames, profile URLs, and numeric user IDs. Equivalent inputs are normalized and queried only once.

#### Can I scrape every visible result?

Set the relevant maximum to `0`. The Actor continues until no next page is available. Only public data that X makes visible can be returned.

#### What happens when an account or List does not exist?

The Dataset receives a status row such as `not_found` or `no_results`, including the requested input and a readable message.

#### What happens if I use the wrong input type?

The Actor stores a free `invalid_input` status row with a readable explanation. For example, member and subscriber operations require a List ID or List URL instead of a username. Other valid targets in the same run continue processing.

#### Why might some Lists, members, or subscribers be missing?

X may hide private Lists, protected profiles, deleted or suspended accounts, and other restricted resources. The Actor can only return public data that X makes visible at the time of the run.

#### Does the Actor return List posts or tweets?

No. This Actor focuses on List discovery, List metadata, owners, members, and subscribers. It does not collect List timeline posts.

### Limitations and responsible use

- Only public Lists and profiles visible through X can be collected.
- X may withhold, restrict, delete, or stop returning some Lists or accounts.
- Profile counts and List membership can change after a run completes.
- This independent Actor is not affiliated with or endorsed by X Corp.

Use public data lawfully and follow applicable privacy, data-protection, and platform requirements.

### Related Actors

- [X Followers & Following Scraper — At Scale](https://apify.com/arjun_code/x-twitter-followers-followings-scraper)
- [X (Twitter) People Search Scraper](https://apify.com/arjun_code/x-twitter-people-search-scraper)
- [X (Twitter) Similar Accounts Finder](https://apify.com/arjun_code/x-twitter-similar-accounts-finder)

### Support

If a public input returns unexpected results, open an issue on the Actor page and include the operation, public username or List URL, and run ID. Do not include cookies, tokens, or private credentials.

# Actor input Schema

## `operation` (type: `string`):

Choose one result type. The first two options use account inputs. The last two options use List IDs or URLs.

## `accountListType` (type: `string`):

Only used with Lists owned or followed by accounts. Choose whether to collect Lists created by the account, Lists the account follows, or both. The result limit applies separately to each type when Both is selected.

## `screenNames` (type: `array`):

Use for Lists owned or followed by accounts and Lists containing accounts. Enter one username, @handle, or profile URL per line, for example VitalikButerin, @VitalikButerin, or https://x.com/VitalikButerin. Up to 50 unique account inputs are accepted across both account fields combined.

## `userIds` (type: `array`):

Use for Lists owned or followed by accounts and Lists containing accounts. Enter one numeric X / Twitter user ID per line, for example 295218901. Up to 50 unique account inputs are accepted across both account fields combined.

## `listIds` (type: `array`):

Use for Members of Lists and Subscribers of Lists. Enter one numeric List ID or full List URL per line, for example 1455191294725312517 or https://x.com/i/lists/1455191294725312517. Up to 50 unique Lists are accepted per run.

## `maxListsPerAccount` (type: `integer`):

Used for the first two data options. Sets the maximum number of Lists returned for each account. Enter 0 to collect every visible List. When both owned and followed Lists are selected, this limit applies separately to each type.

## `maxUsersPerList` (type: `integer`):

Used for Members of Lists and Subscribers of Lists. Sets the maximum number of users returned from each List. Enter 0 to collect every result X makes available.

## Actor input object example

```json
{
  "operation": "account_lists",
  "accountListType": "all",
  "screenNames": [
    "https://x.com/TheZvi"
  ],
  "userIds": [
    "295218901"
  ],
  "listIds": [
    "https://x.com/i/lists/1455191294725312517"
  ],
  "maxListsPerAccount": 3,
  "maxUsersPerList": 100
}
```

# Actor output Schema

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

List records, subscriber profiles, and status rows stored in the 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 = {
    "screenNames": [
        "https://x.com/TheZvi"
    ],
    "maxListsPerAccount": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("arjun_code/x-twitter-lists-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 = {
    "screenNames": ["https://x.com/TheZvi"],
    "maxListsPerAccount": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("arjun_code/x-twitter-lists-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 '{
  "screenNames": [
    "https://x.com/TheZvi"
  ],
  "maxListsPerAccount": 3
}' |
apify call arjun_code/x-twitter-lists-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arjun_code/x-twitter-lists-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/udhUrPRhDerxIshnV/builds/LeXX16borE8p1ufg2/openapi.json