# ✅ X (Twitter) User Replies Scraper (`datamagnet/x-twitter-user-replies-scraper`) Actor

Collect replies for any X username and get the raw reply data exactly as received. Use it to review reply activity, export conversations, and keep fetching more replies until you reach your limit or run out of results.

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

## Pricing

from $3,000.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## User Replies Collector — Replies Scraper and Data Collector

User Replies Collector helps you quickly collect replies for any username and turn them into a ready-to-use dataset. It is built for marketers, researchers, analysts, and social media teams who need a simple way to review reply activity, export conversation data, or keep gathering more replies when available. Use it to capture Twitter/X reply content exactly as received, including the reply text, engagement counts, author details, and related conversation context. If you need a reliable replies extractor for social media monitoring, audience research, or content analysis, this actor gives you clean results with minimal effort.

### Key Features

- **Collect** replies for any username you provide and get a structured dataset ready for review.
- **Preserve** the reply content exactly as received so you can analyze it without losing detail.
- **Capture** useful context such as reply text, author information, engagement counts, and conversation references.
- **Continue** fetching more replies when available until you reach your chosen limit.
- **Export** results for reporting, spreadsheet analysis, or sharing with your team.
- **Review** reply activity in one place without manually searching through profiles or threads.
- **Support** social media research, brand monitoring, and audience insights with real reply data.

### Use Cases

#### Social Media Monitoring
Brand and community teams use this actor to track how people reply to a specific account. The returned fields like `text`, `created_at`, `favorites`, `replies`, and `retweets` help teams understand what kind of responses are getting attention and when they appeared.

#### Audience Research
Researchers and marketers can study reply patterns to learn what followers care about, what language they use, and which topics trigger engagement. Fields such as `author.name`, `author.screen_name`, `author.followers_count`, and `lang` help identify who is replying and in what context.

#### Content Performance Review
Creators and social media managers can compare replies to see which posts sparked the most discussion. By looking at `conversation_id`, `in_reply_to_status_id_str`, `views`, `quotes`, and `bookmarks`, they can judge which conversations are worth revisiting or repurposing.

#### Competitive Analysis
Teams can collect replies for public figures, competitors, or industry accounts to understand audience sentiment and engagement style. The dataset makes it easier to compare reply volume, author profiles, and engagement signals across different accounts.

#### Lead and Community Discovery
Sales, partnerships, and community teams can scan replies to find active users, influential accounts, or recurring commenters. The `author` details, combined with reply text and engagement metrics, help identify people worth following up with or adding to a watchlist.

### Input

| Field | Type | Required | Description | Example |
|---|---|---:|---|---|
| screenname | String | Yes | Enter the username whose replies you want to collect. | elonmusk |
| max_results | Integer | No | Set the maximum number of replies you want to gather before stopping. | 100 |

### Output

| Field | Type | Description |
|---|---|---|
| tweet_id | String | Unique ID of the reply, useful for tracking or referencing it later. |
| bookmarks | Integer | How many times the reply was bookmarked. |
| created_at | String | The date and time when the reply was posted. |
| favorites | Integer | How many likes the reply received. |
| text | String | The full reply text exactly as returned. |
| lang | String | The language of the reply. |
| in_reply_to_status_id_str | String or Null | The ID of the post this reply responds to, if available. |
| views | String | The number of views the reply received. |
| quotes | Integer | How many times the reply was quoted. |
| replies | Integer | How many replies the reply itself received. |
| retweets | Integer | How many times the reply was reposted. |
| conversation_id | String | The conversation thread ID that links related posts together. |
| media | Array | Any media attached to the reply, such as photos or other visual content. |
| entities | Array or Object | Extra structured details such as mentions or other referenced items. |
| author | Object | Information about the person who posted the reply, including name and profile details. |
| quoted | Object or Null | Details of a quoted post, if the reply includes one. |

### Sample Output

```json
{
  "tweet_id": "2076475640941830521",
  "bookmarks": 4,
  "created_at": "Mon Jul 13 01:15:46 +0000 2026",
  "favorites": 162,
  "text": "SpaceXAI is a far better steward of frontier technology than others, and they have proven it time and time again\n\nYou don't become a trillionaire by ripping people off",
  "lang": "en",
  "in_reply_to_status_id_str": null,
  "views": "18223",
  "quotes": 0,
  "replies": 13,
  "retweets": 14,
  "conversation_id": "2076475640941830521",
  "media": [],
  "entities": [],
  "author": {
    "rest_id": "16052860",
    "name": "Jess Fields",
    "screen_name": "jessalanfields",
    "followers_count": 29213,
    "favourites_count": 15438,
    "avatar": "https://pbs.twimg.com/profile_images/1969098427465142272/NZnQkd8n_normal.jpg",
    "blue_verified": true
  },
  "quoted": {
    "tweet_id": "2076382375248843101",
    "bookmarks": 0,
    "created_at": "Sun Jul 12 19:05:10 +0000 2026",
    "favorites": 21,
    "text": "This is sweet justice\n\nDo it, Elon https://t.co/mtzqR8VXJm",
    "lang": "en",
    "views": "20051",
    "quotes": 1,
    "replies": 0,
    "retweets": 2,
    "conversation_id": "2076382375248843101",
    "author": {
      "rest_id": "16052860",
      "name": "Jess Fields",
      "screen_name": "jessalanfields",
      "avatar": "https://pbs.twimg.com/profile_images/1969098427465142272/NZnQkd8n_normal.jpg",
      "blue_verified": true
    },
    "media": {
      "photo": [
        {
          "media_url_https": "https://pbs.twimg.com/media/HNDKw9uWoAAHaIo.jpg",
          "id": "2076382370769313792"
        }
      ]
    }
  }
}
````

### How It Works

1. You enter the username whose replies you want to collect.
2. You optionally set how many replies you want the actor to gather.
3. The actor automatically collects the replies and keeps going if more are available.
4. It returns the reply data in a ready-to-use format with the original fields preserved.
5. You download or export the results for analysis, reporting, or archiving.

### Getting Started

Getting started is simple and does not require coding knowledge. Click **Try for free**, enter the username you want to collect replies for, optionally set the maximum number of results, and click **Run**. The actor will gather the replies automatically and return the results in a format you can work with right away. You can then download the output as JSON, CSV, or Excel for easy sharing and analysis.

### Frequently Asked Questions

#### Do I need technical skills?

No. This actor is designed for business users, researchers, and social media teams who want results without dealing with complicated setup. Just enter a username, run the actor, and review the output.

#### How fast does it run?

Speed depends on how many replies are available for the username and how many you ask for. Smaller collections finish quickly, while larger collections may take longer because the actor keeps gathering more replies until it reaches your limit or runs out of data.

#### What format is the output?

The output is delivered in a clean, structured format that is easy to review and export. You can download it as JSON, CSV, or Excel, which makes it simple to use in spreadsheets, dashboards, or reports.

#### Is this legal to use?

This actor is intended for collecting publicly available reply data for legitimate business, research, and analysis purposes. You are responsible for using the results in a way that respects applicable laws, platform rules, and privacy expectations.

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

Yes. You can set it up to run on a schedule if you want regular updates for monitoring or reporting. This is useful for tracking ongoing reply activity around a brand, account, or topic over time.

# Actor input Schema

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

Enter the username whose replies you want to collect.

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

Maximum number of replies to collect. The actor will keep fetching more until it reaches this limit or there are no more replies.

## Actor input object example

```json
{
  "screenname": "elonmusk",
  "max_results": 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 = {
    "screenname": "elonmusk"
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "✅ X (Twitter) User Replies Scraper",
        "description": "Collect replies for any X username and get the raw reply data exactly as received. Use it to review reply activity, export conversations, and keep fetching more replies until you reach your limit or run out of results.",
        "version": "0.0",
        "x-build-id": "Fpfay9B98LZiB3eNz"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datamagnet~x-twitter-user-replies-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datamagnet-x-twitter-user-replies-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/datamagnet~x-twitter-user-replies-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datamagnet-x-twitter-user-replies-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/datamagnet~x-twitter-user-replies-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datamagnet-x-twitter-user-replies-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": [
                    "screenname"
                ],
                "properties": {
                    "screenname": {
                        "title": "Username",
                        "type": "string",
                        "description": "Enter the username whose replies you want to collect."
                    },
                    "max_results": {
                        "title": "Max results",
                        "type": "integer",
                        "description": "Maximum number of replies to collect. The actor will keep fetching more until it reaches this limit or there are no more replies."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
