# X/Twitter List Scraper (`scrapesmith/x-twitter-list-scraper`) Actor

Scrape tweets from any public X (Twitter) list. Monitor curated feeds, industry watchlists and influencer lists. Get full tweet text, engagement metrics, media and author details. Supports multiple lists and exports to JSON, CSV or Excel.

- **URL**: https://apify.com/scrapesmith/x-twitter-list-scraper.md
- **Developed by:** [Scrape Smith](https://apify.com/scrapesmith) (community)
- **Categories:** Social media, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.15 / 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.

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

## X (Twitter) List Scraper

Extract every tweet from any public X (Twitter) list — no login, no API keys, no hassle. Just paste a list URL or ID and get a clean, structured feed of tweets ready for analysis, monitoring, or archiving.

### What It Does

X/Twitter Lists are curated feeds — industry watchlists, competitor trackers, journalist roundups, community collections. This scraper pulls the full tweet timeline from any public list and returns it as structured data: text, engagement numbers, media, and author details for every tweet, in the order the list feed shows them.

Just provide one or more list links (or bare list IDs), and the scraper handles the rest — paging through the entire feed until it hits your limit or runs out of tweets.

### Key Features

- **Full list feed extraction** — pulls the complete tweet timeline from any public list, not just the first page.
- **Automatic pagination** — keeps paging through the list until your requested tweet count is reached.
- **Rich engagement metrics** — likes, retweets, replies, quotes, bookmarks, and view counts on every tweet.
- **Complete author info** — username, display name, bio, follower/following counts, verification status, and profile picture for each tweet's author.
- **Media extraction** — image and video URLs attached to tweets, including best-quality video links.
- **Quote tweet support** — quoted tweets are captured and nested inside the parent tweet.
- **Multiple lists per run** — queue up several lists and scrape them all in one job.
- **Resilient & resumable** — if a run is interrupted, it picks up where it left off instead of starting over.
- **Flexible export** — download results as JSON, CSV, Excel, or feed them straight into another tool via the Apify API.

### Input Parameters

| Parameter | Description |
|---|---|
| **List URLs or IDs** | One or more X/Twitter list links (e.g. `https://x.com/i/lists/123456`) or bare list IDs (e.g. `123456`). |
| **Max Tweets per List** | Maximum number of tweets to pull from each list. Default: 100. |
| **Max Total Items** | Optional overall cap on tweets collected across all lists in the run. |
| **Debug Logging** | Optional — turns on detailed diagnostic logs for troubleshooting. Leave off for normal use. |

### Output Fields

Each tweet in the output dataset includes:

- **Tweet text, ID, and direct URL**
- **Posted date/time**
- **Engagement metrics** — likes, retweets, replies, quotes, bookmarks, views
- **Media** — attached images and videos
- **Hashtags, mentions, and links** found in the tweet
- **Reply/retweet/quote flags** and conversation context
- **Author details** — username, display name, bio, follower count, verification status, profile picture, and more
- **Quoted tweet** (if the tweet quotes another one), nested with its own full details

Results can be downloaded in JSON, CSV, Excel, or accessed directly via the Apify API.

### Pricing

This actor runs on a **pay-per-result** model — you're charged only for each tweet actually delivered to your dataset. There are no charges for setup, retries, or overhead. Check the actor's page on the Apify Store for current per-result pricing.

### Example Use Cases

- **Industry & market monitoring** — track a curated list of competitors, analysts, or industry accounts to stay on top of announcements and sentiment without checking X manually.
- **Curated feed archiving** — preserve the full history of a valuable list (e.g. a conference speaker list or expert roundup) before it changes or disappears.
- **Influencer & creator tracking** — monitor a list of influencers or creators in your niche to spot trends, collaboration opportunities, or emerging voices.
- **Research & journalism** — pull structured tweet data from public lists for academic research, trend reports, or news gathering.
- **Brand & PR monitoring** — follow lists of press contacts, partners, or brand advocates to keep tabs on public conversation.

# Actor input Schema

## `listUrls` (type: `array`):

X/Twitter list URLs or bare list IDs to scrape (e.g. "https://x.com/i/lists/123456" or just "123456").
## `maxTweets` (type: `integer`):

Maximum number of tweets to collect per list.
## `maxItems` (type: `integer`):

Hard cap on total items pushed to the dataset across all lists.

## Actor input object example

```json
{
  "listUrls": [
    "https://x.com/i/lists/1275713815833915398"
  ],
  "maxTweets": 10,
  "maxItems": 10
}
````

# 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 = {
    "listUrls": [
        "https://x.com/i/lists/1275713815833915398"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapesmith/x-twitter-list-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 = { "listUrls": ["https://x.com/i/lists/1275713815833915398"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapesmith/x-twitter-list-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 '{
  "listUrls": [
    "https://x.com/i/lists/1275713815833915398"
  ]
}' |
apify call scrapesmith/x-twitter-list-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "X/Twitter List Scraper",
        "description": "Scrape tweets from any public X (Twitter) list. Monitor curated feeds, industry watchlists and influencer lists. Get full tweet text, engagement metrics, media and author details. Supports multiple lists and exports to JSON, CSV or Excel.",
        "version": "0.0",
        "x-build-id": "Cd9J3rFT7oCu1jsIf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapesmith~x-twitter-list-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapesmith-x-twitter-list-scraper",
                "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/scrapesmith~x-twitter-list-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapesmith-x-twitter-list-scraper",
                "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/scrapesmith~x-twitter-list-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapesmith-x-twitter-list-scraper",
                "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": [
                    "listUrls"
                ],
                "properties": {
                    "listUrls": {
                        "title": "List URLs or IDs",
                        "type": "array",
                        "description": "X/Twitter list URLs or bare list IDs to scrape (e.g. \"https://x.com/i/lists/123456\" or just \"123456\").",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxTweets": {
                        "title": "Max Tweets per List",
                        "minimum": 1,
                        "maximum": 500000,
                        "type": "integer",
                        "description": "Maximum number of tweets to collect per list.",
                        "default": 10
                    },
                    "maxItems": {
                        "title": "Max Total Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Hard cap on total items pushed to the dataset across all lists.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
