# Fast Twitter List Scraper API | Extract Tweets & Members (`apidojo/twitter-list-scraper`) Actor

Discover the Twitter (X) List Scraper you've been looking for! Find the ultimate tool for extracting Tweets List from X / Twitter! It offers unparalleled speed and comprehensiveness, ensuring lightning-fast extraction of Tweets.

- **URL**: https://apify.com/apidojo/twitter-list-scraper.md
- **Developed by:** [API Dojo](https://apify.com/apidojo) (community)
- **Categories:** Lead generation, Social media, Automation
- **Features:** Limited permissions
- **Stats:** 1,114 total users, 30 monthly users, 98.3% runs succeeded, 42 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.40 / 1,000 dataset items

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

## Fast Twitter List Scraper API: Extract List Members & Tweets at Scale

Extract tweets, list members, and engagement data from X (formerly Twitter) lists at scale. This **Twitter list scraper** collects list metadata, member profiles, follower counts, bios, verification status, and tweet content—all without login or API keys.

Use this **Twitter list scraper API** to build lead lists from curated industry lists, monitor competitor networks, research influencers, or **export Twitter list to CSV** for CRM import. Extract up to 80 tweets per second with complete author profiles including usernames, follower counts, locations, and X Premium status.

**💰 Event-Based Pricing:** $0.008 per list + $0.0004 per tweet | **⚡ Speed:** 30-80 tweets/second | **🔓 No login required**

***

### 📋 Table of Contents

1. [What Does the Twitter List Scraper Do?](#-what-does-the-twitter-list-scraper-do)
2. [Features & Capabilities](#-features--capabilities)
3. [Pricing](#-pricing)
4. [Input Parameters](#-input-parameters)
5. [Twitter List Scraper Strategy Guide](#-twitter-list-scraper-strategy-guide)
6. [Output Format](#-output-format)
7. [Custom Map Function](#-custom-map-function)
8. [Send Results to Notion, Todoist and More](#-send-results-to-notion-todoist-and-more-mcp-connectors)
9. [Related Scrapers](#-related-scrapers)
10. [Demo Mode & Free Testing](#-demo-mode--free-testing)
11. [Troubleshooting](#-troubleshooting)
12. [Use Cases & Industries](#-use-cases--industries)
13. [Quick Start Guide](#-quick-start-guide)
14. [FAQ](#-frequently-asked-questions)
15. [Contact](#-contact)

***

### 🧭 What Does the Twitter List Scraper Do?

**Twitter list scraper** is a tool that automates the extraction of tweets, member profiles, and engagement metrics from public X (formerly Twitter) lists. This **X list scraper** enables lead generation, influencer research, and competitive intelligence by collecting list IDs, list names, member counts, subscriber counts, and tweet content from curated lists.

The **Api Dojo Twitter List Scraper API** retrieves comprehensive list data—including list descriptions, list owners, member usernames, follower counts, bio descriptions, verification status, and tweet engagement metrics—by list URL or list ID. This tool operates at speeds up to 80 tweets per second without requiring proxies, authentication, or official Twitter API quotas.

This **Twitter list data extractor** serves as a practical alternative to the official Twitter API v2 for bulk list extraction. No rate limits, no API key management—just straightforward data access through Apify's infrastructure. **Extract Twitter list members** for thousands of curated lists in minutes.

#### Why Choose This Twitter List Scraper?

| Feature              | This Scraper     | Twitter API v2     | Other Scrapers  |
| -------------------- | ---------------- | ------------------ | --------------- |
| **Speed**            | 30-80 tweets/sec | Rate limited       | 5-10 tweets/sec |
| **Cost**             | $0.008/list + $0.40/1K tweets | Free tier limited  | $2-5/1K tweets  |
| **Authentication**   | None required    | OAuth 2.0 required | Often required  |
| **Rate Limits**      | No hard limits   | 15 requests/15 min | Varies          |
| **List Member Data** | ✅ Full profiles  | ✅ Limited fields   | ⚠️ Partial       |
| **Export Formats**   | JSON, CSV, Excel | JSON only          | Varies          |

#### What Data Can You Extract?

##### List-Level Data

- **List ID** — Unique identifier for each list
- **List name** — Display name of the list
- **List URL** — Direct link to the list
- **List description** — Description text set by list owner
- **List slug** — URL-friendly list identifier
- **List owner** — Username, user ID, display name of creator
- **Member count** — Total members in the list
- **Subscriber count** — Users following the list
- **List visibility** — Public or private status
- **List creation date** — When the list was created
- **List banner image** — Header image URL
- **Is pinned list** — Whether list is pinned by owner
- **Is followed list** — Whether you follow the list

##### Member-Level Data (Per User in List)

- **User ID** — Unique Twitter user identifier
- **Username (handle)** — @username
- **Display name** — Profile display name
- **Bio / profile description** — User's bio text
- **Profile picture URL** — Avatar image
- **Banner image URL** — Header image
- **Follower count** — Total followers
- **Following count** — Accounts they follow
- **Tweet count** — Total tweets posted
- **Account creation date** — When account was created
- **Location** — Profile location
- **Website URL** — Profile website link
- **Is verified** — Legacy verification status
- **Is blue checkmark (X Premium)** — Paid verification
- **Is protected account** — Private account status
- **Pinned tweet ID** — ID of pinned tweet
- **Listed count** — How many lists they appear in

***

### ⚡ Features & Capabilities

#### Query Types Supported

| Input Type   | Example                          | Speed            | Best For               |
| ------------ | -------------------------------- | ---------------- | ---------------------- |
| **List URL** | `https://x.com/i/lists/78783491` | 30-80 tweets/sec | Direct list extraction |
| **List ID**  | `78783491`                       | 30-80 tweets/sec | Programmatic access    |

#### Core Features

- **🚀 High-Speed Extraction** — 30-80 tweets per second from any public list
- **📊 Complete Tweet Data** — Text, engagement metrics, media, author profiles
- **👥 Member Profiles** — Full user data for every list member
- **🔄 No Authentication** — No login, API keys, or OAuth required
- **📁 Multiple Export Formats** — JSON, CSV, Excel direct download
- **⚙️ Custom Transformations** — Shape output with custom map functions
- **🔗 API Integration** — RESTful API for Python, Node.js, or any HTTP client

#### Complete Twitter Scraper Ecosystem

This **X list scraper** is part of the Apidojo Twitter scraper suite. Combine with other tools for comprehensive Twitter data extraction:

| Tool                                                                                   | What It Extracts                    | Best For                           |
| -------------------------------------------------------------------------------------- | ----------------------------------- | ---------------------------------- |
| 🏯 **Twitter List Scraper**                                                             | List tweets, members, metadata      | List monitoring **(You are here)** |
| 🐦 **[Tweet Scraper](https://apify.com/apidojo/tweet-scraper?fpr=yhdrb)**               | Tweets by keyword, hashtag, user    | General tweet extraction           |
| 👤 **[Twitter User Scraper](https://apify.com/apidojo/twitter-user-scraper?fpr=yhdrb)** | User profiles, followers, following | Influencer research                |
| ⚡ **[Twitter Scraper Lite](https://apify.com/apidojo/twitter-scraper-lite?fpr=yhdrb)** | Lightweight tweet extraction        | Quick searches                     |

***

### 💰 Pricing

#### Event-Based Cost Structure

| Event                   | Cost    | What You Get                     |
| ----------------------- | ------- | -------------------------------- |
| **List Query** | **$0.008** per list | First ~20 tweets included FREE (first page) |
| **Dataset Items** | **$0.0004** per tweet | Only charged for tweets beyond the free ~20 |
| **Per 1,000 tweets**    | ~$0.40   | Complete list extraction         |
| **Per 10,000 tweets**   | ~$4.00   | Large-scale list monitoring      |

#### Cost Examples

| Scenario                     | Tweets  | What You Pay |
| ---------------------------- | ------- | ------------ |
| 1 list, 500 tweets           | 500     | $0.20        |
| 5 lists, 1,000 tweets each   | 5,000   | $2.00        |
| 20 lists, 2,500 tweets each  | 50,000  | $20.00       |
| 100 lists, 1,000 tweets each | 100,000 | $40.00       |

#### Why This Pricing Works

- **No monthly fees** — Pay only for data extracted
- **No API quotas** — Extract as much as you need
- **Predictable costs** — Calculate exact spend before running
- **Scales linearly** — Same rate whether extracting 100 or 100,000 tweets

#### Important Usage Guidelines

To keep things stable and cost-efficient:

- Each listId or startUrl must fetch **at least 50 tweets**
- Fetching fewer creates a negative margin and may trigger rate-limiter
- For smaller extractions, use [Twitter Scraper Lite](https://apify.com/apidojo/twitter-scraper-lite?fpr=yhdrb)
- **Free users**: Limited to **5 runs per month**, each capped at **10 items**

***

### 🍚 Input Parameters

Configure your **Twitter list scraper** extraction with these parameters. Whether you want to **scrape Twitter list** content by URL or list ID, these settings control what data you collect.

| Field               | Type   | Description                                                                                                                         | Default    |
| ------------------- | ------ | ----------------------------------------------------------------------------------------------------------------------------------- | ---------- |
| `startUrls`         | array  | X (Twitter) list URLs. Paste URLs and get results immediately.                                                                      | `[]`       |
| `listIds`           | array  | List IDs to extract tweets from. The ID is the last part of the URL (e.g., `78783491` from `https://twitter.com/i/lists/78783491`). | `[]`       |
| `maxItems`          | number | Maximum tweets to extract per list.                                                                                                 | `Infinity` |
| `customMapFunction` | string | JavaScript function to transform each output item. Not for filtering—filtering may trigger restrictions. Ignored with a warning if it is not a usable function.                                      | `null`     |
| `outputConnector`   | string | MCP connector to deliver the results to — pick one (see [Send Results to Notion, Todoist and More (MCP Connectors)](#-send-results-to-notion-todoist-and-more-mcp-connectors)). | `null`     |
| `deliverTarget`     | string | Where the connector writes — paste the URL or ID (Notion example: `https://www.notion.so/My-Posts-24f8a1b2c3d44e5f8a9b0c1d2e3f4a5b`); some services need none. | `null`     |
| `deliverMode`       | string | `perPost` (one record per item) or `summary` (one roll-up per run).                                                                 | `perPost`  |
| `deliverMaxItems`   | number | Optional cap on how many records `perPost` delivers (ignored in `summary`).                                                         | `null`     |

#### Parameter Examples

**Extract by List URL:**

```json
{
  "startUrls": ["https://x.com/i/lists/78783491"],
  "maxItems": 1000
}
```

**Extract by List ID:**

```json
{
  "listIds": ["78783491", "123456789"],
  "maxItems": 500
}
```

**Multiple Lists:**

```json
{
  "startUrls": [
    "https://x.com/i/lists/78783491",
    "https://x.com/i/lists/987654321"
  ],
  "maxItems": 2000
}
```

***

### 📖 Twitter List Scraper Strategy Guide

Master the art of **how to scrape Twitter list members** with these proven strategies. Whether you're building lead lists, monitoring competitors, or researching influencers, this guide covers the optimal approach for each use case.

***

#### 🎯 Strategy 1: Lead Generation from Curated Lists

**Goal:** Build B2B prospect lists from industry-specific Twitter lists

**Best Input:**

```json
{
  "startUrls": ["https://x.com/i/lists/YOUR_TARGET_LIST"],
  "maxItems": 5000
}
```

**Why This Works:**

- Industry experts curate lists of relevant accounts
- List members are pre-qualified by the curator
- Extract follower counts, bios, and website URLs for outreach
- **Export Twitter list to CSV** for CRM import

**Pro Tips:**

- Target lists created by industry publications, VCs, or thought leaders
- Look for lists named "Top \[Industry] Founders" or "\[Niche] Experts"
- Combine with [Twitter User Scraper](https://apify.com/apidojo/twitter-user-scraper?fpr=yhdrb) for deeper profile data

***

#### 🎯 Strategy 2: Competitor Intelligence

**Goal:** Monitor competitor curated lists for market insights

**Best Input:**

```json
{
  "listIds": ["COMPETITOR_LIST_ID_1", "COMPETITOR_LIST_ID_2"],
  "maxItems": 2000
}
```

**Why This Works:**

- Competitors often maintain lists of customers, partners, or influencers
- Discover who they're watching and engaging with
- Identify potential partnership or acquisition targets
- Track changes in their network over time

**Pro Tips:**

- Check competitor profiles for public lists they've created
- Monitor investor lists for deal flow intelligence
- Track media lists for PR opportunities

***

#### 🎯 Strategy 3: Influencer Research & Outreach

**Goal:** Identify and qualify influencers for partnerships

**Best Input:**

```json
{
  "startUrls": ["https://x.com/i/lists/INFLUENCER_LIST"],
  "maxItems": 1000
}
```

**Why This Works:**

- Influencer lists are curated by engagement, not just follower count
- Get bio descriptions, follower counts, and verification status
- Identify micro-influencers with high engagement
- Build outreach lists for **influencer marketing** campaigns

**Pro Tips:**

- Target lists from marketing agencies or brand accounts
- Look for niche-specific lists (e.g., "Tech YouTubers", "Fitness Influencers")
- Filter by follower count and listed count for quality signals

***

#### 🎯 Strategy 4: Academic Research & Network Analysis

**Goal:** Map social networks and community structures

**Best Input:**

```json
{
  "startUrls": ["https://x.com/i/lists/RESEARCH_LIST"],
  "maxItems": 10000
}
```

**Why This Works:**

- Lists represent curated social graphs
- Extract listed count to identify central nodes
- Map connections between communities
- Build datasets for **social graph analysis**

**Pro Tips:**

- Combine multiple lists to map overlapping communities
- Use listed count as a proxy for influence
- Export to network analysis tools (Gephi, NetworkX)

***

### 📊 Output Format

Clean, structured JSON output with comprehensive tweet and author data. Each tweet object contains engagement metrics, author profiles, and media—everything you need to **extract Twitter list members** and their content at scale.

#### Tweet Output Example

```json
{
  "type": "tweet",
  "id": "1757983181972930764",
  "url": "https://x.com/ESPNStatsInfo/status/1757983181972930764",
  "twitterUrl": "https://twitter.com/ESPNStatsInfo/status/1757983181972930764",
  "text": "Anthony Davis and Rui Hachimura are the 1st @Lakers duo with 35 points each...",
  "retweetCount": 58,
  "replyCount": 10,
  "likeCount": 158,
  "quoteCount": 8,
  "bookmarkCount": 7,
  "createdAt": "Thu Feb 15 04:20:26 +0000 2024",
  "lang": "en",
  "isReply": false,
  "isRetweet": false,
  "isQuote": false,
  "author": {
    "type": "user",
    "userName": "ESPNStatsInfo",
    "url": "https://x.com/ESPNStatsInfo",
    "id": "53120768",
    "name": "ESPN Stats & Info",
    "isVerified": true,
    "isBlueVerified": true,
    "verifiedType": "business",
    "profilePicture": "https://pbs.twimg.com/profile_images/.../Np_LXZ_x_normal.jpg",
    "coverPicture": "https://pbs.twimg.com/profile_banners/53120768/...",
    "description": "Our mission is to serve fans across every ESPN platform...",
    "location": "Bristol, CT",
    "followers": 1828908,
    "following": 61,
    "protected": false,
    "createdAt": "Thu Jul 02 17:03:54 +0000 2009",
    "mediaCount": 46266,
    "statusesCount": 162931
  },
  "media": [
    "https://pbs.twimg.com/media/GGWb69-a0AAj1iA.jpg"
  ]
}
```

#### Field Availability Guarantees

| Field                   | Availability | Data Type | Notes                 |
| ----------------------- | ------------ | --------- | --------------------- |
| `id`                    | ✅ Always     | string    | Unique tweet ID       |
| `url`                   | ✅ Always     | string    | X.com URL             |
| `twitterUrl`            | ✅ Always     | string    | Twitter.com URL       |
| `text`                  | ✅ Always     | string    | Tweet content         |
| `likeCount`             | ✅ Always     | number    | Total likes           |
| `retweetCount`          | ✅ Always     | number    | Total retweets        |
| `replyCount`            | ✅ Always     | number    | Total replies         |
| `quoteCount`            | ✅ Always     | number    | Total quote tweets    |
| `bookmarkCount`         | ✅ Always     | number    | Total bookmarks       |
| `createdAt`             | ✅ Always     | string    | Tweet timestamp       |
| `author.userName`       | ✅ Always     | string    | @handle               |
| `author.followers`      | ✅ Always     | number    | Follower count        |
| `author.isVerified`     | ✅ Always     | boolean   | Legacy verification   |
| `author.isBlueVerified` | ✅ Always     | boolean   | X Premium status      |
| `media`                 | ⚠️ Sometimes  | array     | Media URLs if present |

#### Export Options

- **JSON:** Complete datasets with nested objects—ideal for analysis pipelines
- **CSV:** Direct download from Apify Console—perfect for **export Twitter list to CSV**
- **API:** RESTful endpoints for Python, Node.js, or any HTTP client

***

### 🧩 Custom Map Function

Transform output using the `customMapFunction` parameter. This JavaScript function receives each tweet object and returns your desired format—flatten nested data, extract specific fields, or restructure for your pipeline.

**Important:** Custom map function is for data transformation—**not for filtering**. Filtering items may result in automatic restrictions. Returning an empty object does not remove the item from the dataset—it is saved as `{ "noResults": true }` instead.

#### Example: Simplified Output for Lead Generation

```javascript
(object) => ({
  tweetId: object.id,
  tweetUrl: object.url,
  text: object.text,
  likes: object.likeCount,
  retweets: object.retweetCount,
  authorHandle: object.author?.userName || null,
  authorName: object.author?.name || null,
  authorFollowers: object.author?.followers || null,
  authorBio: object.author?.description || null,
  authorLocation: object.author?.location || null,
  isVerified: object.author?.isBlueVerified || false
})
```

#### Common Transformations

| Use Case                | What to Extract                                                                |
| ----------------------- | ------------------------------------------------------------------------------ |
| **Lead Generation**     | `author.userName`, `author.followers`, `author.description`, `author.location` |
| **Influencer Research** | `author.followers`, `author.isBlueVerified`, `author.mediaCount`               |
| **Content Analysis**    | `text`, `likeCount`, `retweetCount`, `createdAt`                               |
| **Network Mapping**     | `author.userName`, `author.id`, `author.followers`, `author.following`         |

#### Requirements & Error Handling

The value must be a **single JavaScript function** that takes one item and returns the transformed item. Arrow functions and regular functions both work; `async` and generator functions are not supported.

**Limits:** the function runs in an isolated sandbox. It must be synchronous and finish within about 1 second per item, and only plain JavaScript is available (no network requests, `require` or `console`). Each item is passed in as plain JSON data.

**An unusable function never stops your run.** The actor logs a warning, ignores the function, and saves the original, unmodified items instead—so you still get your data:

| Situation | What happens |
| --------- | ------------ |
| Not valid JavaScript (for example, plain text pasted into the field) | Rejected before the first request; original items are saved |
| Valid JavaScript but not a function (for example, an object) | Rejected before the first request; original items are saved |
| `async` or generator function | Rejected before the first request; original items are saved |
| Returns a Promise (for example, `(object) => Promise.resolve(object)`) | Rejected at that point; the remaining items are saved unmodified |
| Returns something other than an object (for example, a number or `null`) | Rejected at that point; the remaining items are saved unmodified |
| Throws while transforming an item | Rejected at that point; the remaining items are saved unmodified |
| Takes longer than about 1 second on one item (for example, an endless loop) | Rejected at that point; the remaining items are saved unmodified |

If your output does not look transformed, check the run log for a warning that starts with `Your "customMapFunction" input was rejected:`—it explains exactly what was wrong.

If you do not need to transform the output, simply leave this field empty.

***

### 🔌 Send Results to Notion, Todoist and More (MCP Connectors)

Skip the manual exports — the Twitter List Scraper can deliver its results directly into the tools you already work in, through [Apify MCP Connectors](https://apify.com/store/collections/mcp-connectors).

1. Authorize a connector (Notion, Todoist, or any service whose MCP server offers non-destructive write tools) once in [Console → Settings → API & Integrations → MCP connectors](https://console.apify.com/settings/integrations).
2. Pick it from the **Send results to Notion, Todoist, …** dropdown.
3. Fill in where and how to write:
   - **Destination target** — paste the URL or ID (Notion example: `https://www.notion.so/My-Posts-24f8a1b2c3d44e5f8a9b0c1d2e3f4a5b`); share it with your connector first via Notion's **•••  → Connections** menu. For structured columns use a **page** URL (the Actor builds the database for you) or a database that **already has columns** — an empty database only receives titles. (Some services need no target.)
   - **Write mode** — `perPost` writes one record per tweet; `summary` writes a single roll-up for the run.
   - **Max records to deliver** *(optional)* — cap on how many records `perPost` delivers.

**Notion, structured like a spreadsheet:** for a table of typed columns, point the target at a Notion **page** — the Actor auto-creates a database from the data, one matching, correctly-typed column per field (URL, number, date, text). Pointing at an **existing database** fills the columns it already has (matched by name); an **empty database** receives only the title, and the rest of each record goes to the row body — the connector can't add columns to an existing database without destructive access it never requests. Nested fields are flattened into columns too — an `author` object becomes `author.userName`, `author.name` and so on — so everything is sortable and filterable in the grid. Fields that don't fit a column go to the row's page body, so nothing is lost.

Your credentials stay yours: the Actor talks to your services exclusively through your own authorized connector and only ever uses non-destructive write tools — it cannot delete or overwrite anything you already have. Delivery is best-effort and runs after the scrape: if a connector is misconfigured or a delivery fails, your run still finishes normally with all results intact — the failure is reported in the run log, never by failing the run. If the run is about to hit its timeout, delivery stops early so the run still succeeds, and the log tells you how many records were delivered.

***

### 🌴 Related Scrapers

Expand your Twitter data extraction capabilities with our complete suite of **X.com list scraper** tools. Each focuses on specific data types for comprehensive social intelligence.

#### 📦 Complete Apidojo Twitter Scraper Ecosystem

| Tool                                                                                   | What It Extracts                    | Best For                           |
| -------------------------------------------------------------------------------------- | ----------------------------------- | ---------------------------------- |
| 🏯 **Twitter List Scraper**                                                             | List tweets, members, metadata      | List monitoring **(You are here)** |
| 🐦 **[Tweet Scraper](https://apify.com/apidojo/tweet-scraper?fpr=yhdrb)**               | Tweets by keyword, hashtag, user    | General tweet extraction           |
| 👤 **[Twitter User Scraper](https://apify.com/apidojo/twitter-user-scraper?fpr=yhdrb)** | User profiles, followers, following | Influencer research                |
| ⚡ **[Twitter Scraper Lite](https://apify.com/apidojo/twitter-scraper-lite?fpr=yhdrb)** | Lightweight tweet extraction        | Quick searches                     |

#### 🌐 Cross-Platform Social Media Scrapers

| Platform    | Tool                                                                           | What It Extracts             |
| ----------- | ------------------------------------------------------------------------------ | ---------------------------- |
| 📺 YouTube   | **[YouTube Scraper](https://apify.com/apidojo/youtube-scraper?fpr=yhdrb)**     | Videos, channels, playlists  |
| 📸 Instagram | **[Instagram Scraper](https://apify.com/apidojo/instagram-scraper?fpr=yhdrb)** | Posts, reels, profiles       |
| 🎵 TikTok    | **[TikTok Scraper](https://apify.com/apidojo/tiktok-scraper?fpr=yhdrb)**       | Videos, profiles, engagement |

***

### 🆓 Demo Mode & Free Testing

If you run on Apify's Free plan, you can still use this **Twitter list scraper** in Demo Mode. **Free users can run the actor up to 5 times per month**, with each run capped at a maximum of 10 items — just enough to test it out. For unrestricted usage and to unlock the full power of this **Twitter list scraper API** at scale, subscribe to a paid Apify plan.

**Free Plan Benefits:**

- ✅ Test with up to 5 runs per month, each capped at 10 tweet extractions
- ✅ Perfect for testing workflows before scaling
- ✅ Validate output format and data quality risk-free

**Upgrade for Full Access:**

- 🚀 Unlimited tweet extraction from Twitter lists
- 🚀 Up to 80 tweets per second processing speed
- 🚀 API access for automated workflows and integrations
- 🚀 Scheduled runs with webhooks and cron jobs

For unrestricted usage, [subscribe to a paid Apify plan](https://apify.com/pricing?fpr=yhdrb).

***

### 🔧 Troubleshooting

Having trouble with your extraction? Here are solutions to common issues when you **scrape Twitter list** content.

***

#### ❓ Getting Fewer Tweets Than Expected?

**Problem:** Extraction returns fewer tweets than anticipated

**Solutions:**

✅ **Check `maxItems` setting**—increase the limit if you need more tweets\
✅ **Verify list activity**—some lists have limited recent activity\
✅ **Check list visibility**—private lists cannot be scraped\
✅ **Remember free tiers**—Free users are limited to **5 runs per month**, each capped at **10 items**

***

#### ❓ No Results Returned?

**Problem:** Extraction completes but returns empty dataset

**Solutions:**

✅ **Verify URL format**—must be valid X/Twitter list URL\
✅ **Check list visibility**—list must be public\
✅ **Verify list ID**—ensure the ID matches the URL\
✅ **Don't use `customMapFunction` for filtering**—this can cause automatic blocks

***

#### 💰 Unexpected Costs?

**Problem:** Your run cost more than anticipated

**Key pricing to remember:**

| Scenario             | Tweets | What You Pay |
| -------------------- | ------ | ------------ |
| 1 list, 1,000 tweets | 1,000  | $0.40        |
| 5 lists, 2,000 each  | 10,000 | $4.00        |
| 50 lists, 1,000 each | 50,000 | $20.00       |

**Cost control tips:**

✅ **Use `maxItems` to cap spending**—set hard limits on total extraction\
✅ **Start with smaller batches**—test with 500-1000 tweets first\
✅ **Minimum 50 tweets per list**—smaller extractions trigger rate limits

***

#### ❓ Rate Limiting Issues?

**Problem:** Extraction fails or slows down

**Solutions:**

✅ **Minimum 50 tweets per list**—smaller requests may be rate-limited\
✅ **Maximum 1-2 concurrent runs**—avoid parallel extractions\
✅ **Wait between runs**—allow a few minutes between large extractions

***

### 🎯 Use Cases & Industries

This **Twitter list scraper** serves professionals who need fast, structured list intelligence—from **lead generation** to **influencer research** and **competitive intelligence**. Use it to **extract Twitter list members** for any business intelligence need.

***

#### 🎯 Lead Generation & B2B Prospecting

Build targeted prospect lists from curated industry lists.

- **Extract Twitter list members** for sales outreach
- Build **lead generation** databases from expert-curated lists
- Collect bios, locations, and website URLs for qualification
- **Export Twitter list to CSV** for CRM import

**Example:** Extract members from "Top SaaS Founders" lists for **B2B prospecting**.

***

#### 👤 Influencer Research & Marketing

Discover and qualify influencers for partnership opportunities.

- Identify creators for **influencer research** and outreach
- Analyze **influencer list building** patterns
- Track creator follower counts and engagement
- Build **influencer marketing** campaign lists

**Example:** Extract members from brand influencer lists for **influencer research**.

***

#### 🔍 Competitor Intelligence

Monitor competitor networks and curated lists.

- Track **competitor intelligence** through their public lists
- Discover who competitors are watching and engaging with
- Identify potential partnership or acquisition targets
- Monitor changes in competitor networks over time

**Example:** Extract competitor customer lists for **competitive intelligence**.

***

#### 📰 Journalist & Media Monitoring

Track press lists and media contacts.

- Monitor **journalist & media monitoring** lists
- Build **PR & communications outreach** databases
- Track reporter beats and coverage areas
- Identify media contacts for press releases

**Example:** Extract media outlet lists for **press list** building.

***

#### 💼 Investor & VC Tracking

Monitor investment community lists.

- Track **investor tracking** lists from VCs and angels
- Identify **VC & investor lists** for fundraising research
- Monitor portfolio company lists
- Discover deal flow patterns

**Example:** Extract VC portfolio lists for **investor tracking**.

***

#### 🎤 Event & Speaker Discovery

Find speakers and event participants.

- Identify **event speaker discovery** opportunities
- Build **podcast guest research** databases
- Track conference speaker lists
- Discover thought leaders in specific niches

**Example:** Extract conference speaker lists for **speaker discovery**.

***

#### 🎓 Academic Research & Network Analysis

Build datasets for computational social science.

- Collect data for **academic research** and network studies
- Build **social graph analysis** datasets
- Map **community detection** patterns
- Analyze **network analysis** structures

**Example:** Extract political analyst lists for **academic research**.

***

#### 👥 Recruiting & Talent Sourcing

Build candidate pipelines from curated talent lists.

- Identify candidates for **recruiting** and **talent sourcing**
- Extract bios and locations for qualification
- Build outreach lists from industry expert lists
- Track talent movements across companies

**Example:** Extract "Top Engineers" lists for **talent sourcing**.

***

### 💡 Quick Start Guide

Simple setup—whether extracting tweets from one list or monitoring multiple curated lists. This **Twitter list scraper API** makes it easy to **scrape Twitter list** content in minutes.

#### Copy-Paste Examples by Persona

**For Sales Teams (Lead Gen → CSV):**

```json
{
  "startUrls": ["https://x.com/i/lists/YOUR_TARGET_LIST"],
  "maxItems": 2000
}
```

→ Run, then **export Twitter list to CSV** from Storage tab.

**For Developers (API → JSON):**

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_TOKEN")
run = client.actor("apidojo/twitter-list-scraper").call(run_input={
    "listIds": ["78783491"],
    "maxItems": 1000
})
items = client.dataset(run["defaultDatasetId"]).list_items().items
```

**For Researchers (Multiple Lists):**

```json
{
  "startUrls": [
    "https://x.com/i/lists/LIST_1",
    "https://x.com/i/lists/LIST_2",
    "https://x.com/i/lists/LIST_3"
  ],
  "maxItems": 5000
}
```

#### 3 Steps to Get Started

1. **Add input:** Paste list URL or enter list ID
2. **Configure:** Set `maxItems` limit
3. **Run & Export:** Click Start, then download JSON/CSV from Storage tab

***

#### 📋 Method 1: Scrape by List URL

**Best for:** Quick extraction from a single list

```json
{
  "startUrls": ["https://x.com/i/lists/78783491"],
  "maxItems": 1000
}
```

***

#### 📋 Method 2: Scrape by List ID

**Best for:** Programmatic access, multiple lists

```json
{
  "listIds": ["78783491", "123456789"],
  "maxItems": 500
}
```

***

#### 🔧 Best Practices for Twitter List Scraping

##### ✅ DO:

- **Minimum 50 tweets per list**—smaller requests may be rate-limited
- **Start with 500-1000 tweets**—test before scaling
- **Batch similar lists**—extract multiple in one run
- **Set `maxItems`**—control costs by limiting total extraction

##### ❌ DON'T:

- **Use customMapFunction for filtering**—this causes automatic blocking
- **Scrape private lists**—only public lists are accessible
- **Run too many concurrent extractions**—maximum 1-2 concurrent runs
- **Fetch fewer than 50 tweets**—creates negative margin

***

### ❓ Frequently Asked Questions

#### What is a Twitter List Scraper API?

A **Twitter list scraper API** is a tool that programmatically extracts tweets, member profiles, and engagement data from X (formerly Twitter) lists. This **Twitter list data extractor** serves as an alternative to the Twitter API v2 without rate limits or OAuth requirements.

#### How much does it cost to scrape Twitter lists?

**$0.008 per list + $0.0004 per tweet** (first ~20 free). Extract 10,000 tweets for just **~$4.00**—significantly cheaper than building custom scrapers.

#### Can I scrape Twitter lists without login?

Yes! This **Twitter list scraper** requires **no authentication** or login. Start extracting list data immediately without any Twitter account or API key.

#### What Twitter list data can I extract?

Extract **tweet IDs**, **tweet text**, **engagement metrics** (likes, retweets, replies, quotes, bookmarks), **author profiles** (username, followers, bio, location, verification status), **media URLs**, and **timestamps**—all in structured JSON or CSV format.

#### Can I export Twitter list data to CSV?

Yes. Download data directly from Apify Console in JSON, CSV, or Excel format. Perfect for **export Twitter list to CSV** workflows and CRM import.

#### Can I use Python to scrape Twitter lists?

Yes! Full Python support via the Apify Client library. See the [Quick Start Guide](#-quick-start-guide) above for **X list members scraper** Python integration.

#### Is this faster than the Twitter API?

Yes. Up to 80 tweets/second without rate limits. The official Twitter API v2 has strict rate limits (15 requests/15 min for list endpoints) and requires OAuth 2.0 setup.

#### Can I scrape multiple lists at once?

Yes. Add multiple URLs to `startUrls` or IDs to `listIds` for bulk extraction. Each list is processed efficiently.

#### Can I scrape private lists?

No. Only public lists are accessible. Private lists require authentication which this tool does not support.

#### How do I find Twitter list IDs?

The list ID is the last part of the list URL. For example, in `https://twitter.com/i/lists/78783491`, the ID is `78783491`.

#### Can I use this for lead generation?

Yes. Perfect for **lead generation**, **B2B prospecting**, and **sales prospecting**. **Extract Twitter list members** to build targeted outreach lists.

#### Can I use this for influencer research?

Yes. Ideal for **influencer research**, **influencer list building**, and **influencer marketing**. Extract follower counts, bios, and verification status for qualification.

#### Is this a real-time Twitter API?

Yes. Extract current Twitter list data in real-time with up to 80 tweets/second processing speed. Data reflects the latest publicly available information.

***

### 📞 Contact

If you need any sort of support, please send an email to **apidojo10@gmail.com**. You name it, we get it.

***

**Ready to start extracting Twitter list data?** With transparent event-based pricing, blazing-fast speeds, and support for list URLs and IDs, this **Twitter List Scraper API** is the ultimate tool for **lead generation**, **influencer research**, **competitive intelligence**, and **B2B prospecting**. Start scraping today! 🏯

# Actor input Schema

## `startUrls` (type: `array`):

Twitter (X) List URLs. Paste the URLs and get the results immediately.

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

List IDs you want to search from Twitter (X).

## `maxItems` (type: `integer`):

Maximum number of items that you want as output.

## `customMapFunction` (type: `string`):

JavaScript function to transform each output tweet. Use to add computed fields, modify values, or remove unnecessary data. NOT intended for filtering - filtering may result in automatic bans. Must be a single synchronous function, e.g. (object) => { return {...object} }. It runs in a sandbox with plain JavaScript only (no network or require) and about 1 second per item. Leave empty if you do not need to transform the output - an unusable function is ignored and the original items are saved instead.

## `outputConnector` (type: `string`):

Pick an MCP connector you authorized in Console → Settings → API & Integrations → MCP connectors (e.g. Notion, Todoist — any service whose MCP server offers non-destructive write tools works best-effort). The scraped results are written through your own connector — the Actor never sees your third-party credentials. Only non-destructive write tools are used; it can never delete or overwrite your existing data.

## `deliverTarget` (type: `string`):

Where to write into the connector — paste the URL or ID. Notion example: https://www.notion.so/My-Posts-24f8a1b2c3d44e5f8a9b0c1d2e3f4a5b. Leave empty for services that need no target (e.g. Todoist Inbox, Slack). For Notion, share the page or database with your connector first (Notion's ••• → Connections menu), and point at a PAGE for structured columns (the Actor builds the database for you) — an empty database receives only the title (the rest of each record goes to the row's body).

## `deliverMode` (type: `string`):

perPost writes one record per scraped item; summary writes a single roll-up for the run.

## `deliverMaxItems` (type: `integer`):

Cap on how many records perPost mode writes to the connector; ignored in summary mode. Leave empty to deliver everything scraped.

## Actor input object example

```json
{
  "startUrls": [
    "https://twitter.com/i/lists/78783491"
  ],
  "listIds": [
    "1657850814910590977",
    "1199504381886050304"
  ],
  "maxItems": 1000,
  "customMapFunction": "(object) => { return {...object} }",
  "deliverMode": "perPost"
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "startUrls": [
        "https://twitter.com/i/lists/78783491"
    ],
    "listIds": [
        "1657850814910590977",
        "1199504381886050304"
    ],
    "maxItems": 1000,
    "customMapFunction": (object) => { return {...object} }
};

// Run the Actor and wait for it to finish
const run = await client.actor("apidojo/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 = {
    "startUrls": ["https://twitter.com/i/lists/78783491"],
    "listIds": [
        "1657850814910590977",
        "1199504381886050304",
    ],
    "maxItems": 1000,
    "customMapFunction": "(object) => { return {...object} }",
}

# Run the Actor and wait for it to finish
run = client.actor("apidojo/twitter-list-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 '{
  "startUrls": [
    "https://twitter.com/i/lists/78783491"
  ],
  "listIds": [
    "1657850814910590977",
    "1199504381886050304"
  ],
  "maxItems": 1000,
  "customMapFunction": "(object) => { return {...object} }"
}' |
apify call apidojo/twitter-list-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,apidojo/twitter-list-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/mAxIirfenUcKwNXST/builds/CThCwJTtg3nD5TTaG/openapi.json