# Twitter/X Thread Reader (`igview-owner/twitter-x-thread-reader`) Actor

Read and extract full Twitter/X threads and conversations. Extract the original tweet, all replies, engagement metrics (likes, retweets, views), media, and author info. Supports cursor pagination for large threads. Export to JSON/CSV.

- **URL**: https://apify.com/igview-owner/twitter-x-thread-reader.md
- **Developed by:** [Sachin Kumar Yadav](https://apify.com/igview-owner) (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 $2.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

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

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

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

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

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

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

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## 🐦 Twitter/X Thread Reader – Extract Complete Twitter Threads & Replies

**Extract complete Twitter/X threads and sequential conversation replies with detailed metadata, engagement metrics, author profiles, and media. Perfect for archiving threads, content curation, social media analytics, research, and marketing analysis!**

### 📋 Table of Contents

- [Features](#features)
- [Use Cases](#use-cases)
- [Quick Start](#quick-start)
- [Input Parameters](#input-parameters)
- [Output Format](#output-format)
- [Data Fields Explained](#data-fields-explained)
- [FAQ](#faq)

### 🚀 Features

#### **Complete Thread Extraction**
- **Sequential Replies** - Extract the parent tweet and all subsequent replies in a thread.
- **Author Information** - Username, display name, user ID, avatar image, bio, verification status, and subscribers count.
- **Engagement Metrics** - Likes, retweets, replies, quotes, bookmarks, and views.
- **Media Content** - Retrieve image and video URLs embedded within the thread tweets.
- **High-Res Avatars** - Fetch high-quality profile picture URLs of all thread participants.

#### **Advanced Functionality**
- **Automated Pagination** - Automatically paginate replies using the cursor loop up to the defined maxPages limit.
- **No Login Required** - Scrape public threads without providing any account login credentials.
- **Error Mapping** - Structured logs and detailed error mapping in case of missing or private tweets.

### 🎯 Use Cases

| Use Case | Description | Benefits |
|----------|-------------|----------|
| **Thread Archiving** | Save full informational threads for offline reading or reference | Prevent data loss, store educational content |
| **Content Curation** | Collect highly viral Twitter threads on specific niches | Curate posts for newsletters, blogs, or reposting |
| **Sentiment Analysis** | Analyze replies and public feedback under specific threads | Understand community reaction and feedback |
| **Competitor Monitoring** | Monitor customer interaction and replies under competitor tweets | Gain insights into client engagement patterns |
| **Academic Research** | Collect long-form structured discussions on Twitter/X | Research social discourse, trending debates |

### ⚡ Quick Start

#### 1️⃣ Single Thread Scrape
```json
{
  "tweetIds": [
    "1800000000000000000"
  ],
  "maxPages": 2
}
````

#### 2️⃣ Multiple Threads or URLs

```json
{
  "tweetIds": [
    "https://x.com/jack/status/20",
    "https://twitter.com/elonmusk/status/1800000000000000000"
  ],
  "maxPages": 5
}
```

### 📊 Input Parameters

#### Configuration Options

| Parameter | Type | Required | Description | Default |
|-----------|------|----------|-------------|---------|
| `tweetIds` | Array | Yes | List of Tweet IDs or URLs to scrape. Supports status URLs and raw numeric IDs. | |
| `maxPages` | Integer | No | Max pages of replies to retrieve per tweet (1 page = 1 API call). Range: 1 to 20. | `1` |

### 📤 Output Format

#### **Thread Result Output Example**

```json
{
  "type": "original_tweet",
  "tweet_id": "1800000000000000000",
  "text": "This is the start of an awesome thread on technology trends.",
  "display_text": "This is the start of an awesome thread on technology trends.",
  "created_at": "Wed Jun 12 14:20:00 +0000 2026",
  "likes": 12500,
  "retweets": 850,
  "replies": 320,
  "quotes": 45,
  "bookmarks": 120,
  "views": "250000",
  "lang": "en",
  "source": "Twitter for iPhone",
  "conversation_id": "1800000000000000000",
  "author_id": "44196397",
  "author_name": "Tech Enthusiast",
  "author_username": "tech_enthusiast",
  "author_avatar": "https://pbs.twimg.com/profile_images/1234567890/photo_400x400.jpg",
  "author_verified": true,
  "author_description": "Exploring next-generation tech and AI research.",
  "author_subscribers": 12,
  "media": null,
  "scraped_at": "2026-07-08T10:45:00.000Z",
  "input": "https://x.com/tech_enthusiast/status/1800000000000000000"
}
```

### 📈 Data Fields Explained

#### **Complete Field Reference**

| Field | Type | Description |
|-------|------|-------------|
| `type` | String | Type of entry: `original_tweet` (root tweet) or `thread_reply` (thread response). |
| `tweet_id` | String | Unique Twitter/X status ID. |
| `text` | String | Unformatted text content of the tweet. |
| `display_text` | String | Formatted/rendered text content of the tweet. |
| `created_at` | String | Original post date and time (standard Twitter format). |
| `likes` | Integer | Number of favorites / likes. |
| `retweets` | Integer | Number of retweets. |
| `replies` | Integer | Direct reply count on this specific tweet. |
| `quotes` | Integer | Number of quote tweets. |
| `bookmarks` | Integer | Number of times this tweet was bookmarked. |
| `views` | String/Number | View count / impressions. |
| `lang` | String | ISO language code of the tweet (e.g. `en`, `es`). |
| `conversation_id` | String | Root conversation ID for grouping the thread. |
| `author_id` | String | Unique Twitter user identifier. |
| `author_name` | String | User display name. |
| `author_username` | String | User handle (screen name). |
| `author_avatar` | String | URL to the author profile picture. |
| `author_verified` | Boolean | True if the author is blue verified. |
| `parent_tweet_id` | String | Root tweet ID (present only in `thread_reply` records). |
| `scraped_at` | String | Extraction timestamp. |

### ❓ FAQ

#### **Q: Do I need a Twitter API key or account?**

**A:** No, you do not need any credentials. The actor runs entirely using internal API key.

#### **Q: Can I fetch replies that are not part of the sequential thread?**

**A:** This actor is designed specifically to read consecutive thread responses from the author and direct thread flow. To scrape all replies of a tweet regardless of who wrote them, use the **Twitter X Recent Replies Scraper**.

#### **Q: How does the maxPages parameter work?**

**A:** Twitter returns replies in pages. Setting a higher `maxPages` value will make the scraper request more pages of replies. Each page requires one API call.

***

### Related Actors 🤝

- **[Twitter X Recent Replies Scraper](https://apify.com/igview-owner/twitter-x-recent-replies)**
- **[Twitter X Lists Timeline Scraper](https://apify.com/igview-owner/twitter-x-lists-timeline)**
- **[Twitter X Profile Scraper](https://apify.com/igview-owner/twitter-x-profile-scraper)**
- **[Twitter X Video Downloader](https://apify.com/igview-owner/twitter-x-video-downloader)**
- **[X Profile Viewer](https://apify.com/igview-owner/x-twitter-profile-viewer)**
- **[X Follower Scraper](https://apify.com/igview-owner/twitter-x-follower-scraper)**
- **[X Following Scraper](https://apify.com/igview-owner/twitter-x-following-scraper)**
- **[Twitter Affiliates X Scraper](https://apify.com/igview-owner/twitter-advanced-x-scraper)**

***

### 🏷️ **Keywords & Tags**

`twitter thread reader`, `x thread scraper`, `unroll twitter thread`, `read twitter thread`, `twitter replies extractor`, `twitter conversation scraper`, `twitter thread downloader`, `save twitter thread`, `twitter scraper`, `x.com thread reader`, `twitter api thread`, `export twitter replies`, `apify twitter scraper`, `social media archiver`

***

### 🚀 **Get Started Now**

1. Click [**"Try for free"**](https://apify.com?fpr=ykgg9c) to run this actor in the Apify Console.
2. Enter one or more Tweet URLs or IDs into the list.
3. Configure `maxPages` depending on the thread length.
4. Download the resulting JSON, CSV, or Excel file!

**⭐ If this actor is useful to your workflow, please leave a star!**

***

*Built by Sachin Kumar Yadav using Apify Platform*

# Actor input Schema

## `tweetIds` (type: `array`):

Enter Tweet IDs or full tweet URLs. Examples: '2073311697474076672', 'https://x.com/elonmusk/status/2073311697474076672'

## `maxPages` (type: `integer`):

📊 Number of result pages to scrape (1-20). Each page contains thread replies. More pages = more results but longer runtime and higher API usage.

## Actor input object example

```json
{
  "tweetIds": [
    "2073311697474076672"
  ],
  "maxPages": 1
}
```

# Actor output Schema

## `thread_overview` (type: `string`):

Open the dataset view with an overview of the thread including author, tweet text, likes, retweets, views, and more.

# 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 = {
    "tweetIds": [
        "2073311697474076672"
    ],
    "maxPages": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("igview-owner/twitter-x-thread-reader").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 = {
    "tweetIds": ["2073311697474076672"],
    "maxPages": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("igview-owner/twitter-x-thread-reader").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 '{
  "tweetIds": [
    "2073311697474076672"
  ],
  "maxPages": 1
}' |
apify call igview-owner/twitter-x-thread-reader --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitter/X Thread Reader",
        "description": "Read and extract full Twitter/X threads and conversations. Extract the original tweet, all replies, engagement metrics (likes, retweets, views), media, and author info. Supports cursor pagination for large threads. Export to JSON/CSV.",
        "version": "1.0",
        "x-build-id": "PSxxjUyNcVRgpQmFF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/igview-owner~twitter-x-thread-reader/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-igview-owner-twitter-x-thread-reader",
                "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/igview-owner~twitter-x-thread-reader/runs": {
            "post": {
                "operationId": "runs-sync-igview-owner-twitter-x-thread-reader",
                "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/igview-owner~twitter-x-thread-reader/run-sync": {
            "post": {
                "operationId": "run-sync-igview-owner-twitter-x-thread-reader",
                "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": [
                    "tweetIds"
                ],
                "properties": {
                    "tweetIds": {
                        "title": "Tweet IDs or URLs",
                        "minItems": 1,
                        "maxItems": 50,
                        "type": "array",
                        "description": "Enter Tweet IDs or full tweet URLs. Examples: '2073311697474076672', 'https://x.com/elonmusk/status/2073311697474076672'",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "2073311697474076672"
                        ]
                    },
                    "maxPages": {
                        "title": "📄 Maximum Pages",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "📊 Number of result pages to scrape (1-20). Each page contains thread replies. More pages = more results but longer runtime and higher API usage.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
