# X Twitter - We Scrape All At Any Scale (`tklinger50/x-twitter-we-scrape-all-at-any-scale`) Actor

Get X (Twitter) data at scale: user profiles, tweets, followers/following and search results. Just pass handles or queries — no login or cookies needed. Fast, reliable, pay per result.

- **URL**: https://apify.com/tklinger50/x-twitter-we-scrape-all-at-any-scale.md
- **Developed by:** [Tal Klinger](https://apify.com/tklinger50) (community)
- **Categories:** Social media, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 90.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## X (Twitter) Data — Profiles, Tweets, Followers & Search

Get clean, structured **X / Twitter** data at scale — **no login, no cookies, no proxies to manage.**
Just enter handles or search queries and get results back. Built by a scraping & proxy veteran, and
engineered for one thing: **runs that return data, every time.**

### What you can extract

| Operation | Returns |
|-----------|---------|
| **User tweets** | Recent tweets for any @handle — text, likes, retweets, timestamps |
| **Profile info** | Name, bio, followers, following, tweet count, verified status |
| **Search / hashtag** | Latest tweets for any keyword or `#hashtag` |
| **Followers** | Accounts following a user |
| **Following** | Accounts a user follows |

### Why this Actor

- ⚡ **Reliability first.** Backed by years of large-scale scraping and a battle-tested proxy layer —
  engineered so runs come back with data. No blocks, no login walls, no empty results.
- 🔓 **Zero setup.** No X account, no `auth_token`, no cookies, no proxy configuration. It just works.
- 💸 **Pay per result.** You only pay for the rows you actually receive — **$0.30 per item**. No
  subscription, no minimums, nothing charged for what you don't get.
- 📈 **Scales with you.** Run a single handle or thousands in one job.

### Input

| Field | Type | Description |
|-------|------|-------------|
| `operation` | select | `user.tweets` · `profile.info` · `search` · `user.followers` · `user.following` |
| `targets` | array | @handles (for user / profile) or search queries / `#hashtags` (for search) |
| `limit` | integer | Max results per target (default 40) |

```json
{
  "operation": "user.tweets",
  "targets": ["nasa", "spacex"],
  "limit": 50
}
````

### Output

Each result is one clean JSON row in the dataset. Example (`user.tweets`):

```json
{
  "target": "nasa",
  "operation": "user.tweets",
  "rest_id": "1780000000000000000",
  "full_text": "We're go for launch. 🚀",
  "favorite_count": 12840,
  "retweet_count": 2310,
  "created_at": "Wed Jul 09 12:00:00 +0000 2026"
}
```

Example (`profile.info`):

```json
{
  "target": "nasa",
  "operation": "profile.info",
  "screen_name": "NASA",
  "name": "NASA",
  "followers_count": 79000000,
  "friends_count": 180,
  "statuses_count": 71000,
  "verified": true,
  "description": "Exploring the universe and our home planet."
}
```

Export to JSON, CSV, Excel or fetch via API.

### Pricing

**Pay-per-result — $0.30 per item.** You're charged only for results actually returned, so a run that
finds nothing costs you nothing. No monthly fee, no commitment.

### FAQ

**Do I need an X/Twitter account?** No. No login, tokens or cookies — ever.
**Do I need to set up proxies?** No. Proxying and anti-blocking are handled for you.
**What if a target has no results?** You get an empty result for that target and you're not charged for it.
**Can I run many targets at once?** Yes — pass as many handles/queries as you like in `targets`.

***

*Questions or a custom data need? Reach out — happy to help.*

# Actor input Schema

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

User tweets = recent tweets of an @handle · Profile info = bio/followers count/verified · Followers = who follows an @handle · Following = who an @handle follows · Keyword search = tweets matching a phrase · Hashtag search = tweets for a #hashtag.

## `targets` (type: `array`):

One per line. For User tweets / Profile / Followers / Following: enter @handles (the @ is optional). For Keyword search: enter words or phrases. For Hashtag search: enter the tag (# optional).

## `limit` (type: `integer`):

How many results to return per target. You control the quantity — 1 to 500 (hard cap 500 per request).

## Actor input object example

```json
{
  "operation": "user.tweets",
  "targets": [
    "nasa"
  ],
  "limit": 40
}
```

# 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 = {
    "targets": [
        "nasa"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("tklinger50/x-twitter-we-scrape-all-at-any-scale").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 = { "targets": ["nasa"] }

# Run the Actor and wait for it to finish
run = client.actor("tklinger50/x-twitter-we-scrape-all-at-any-scale").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 '{
  "targets": [
    "nasa"
  ]
}' |
apify call tklinger50/x-twitter-we-scrape-all-at-any-scale --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=tklinger50/x-twitter-we-scrape-all-at-any-scale",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "X Twitter - We Scrape All At Any Scale",
        "description": "Get X (Twitter) data at scale: user profiles, tweets, followers/following and search results. Just pass handles or queries — no login or cookies needed. Fast, reliable, pay per result.",
        "version": "0.0",
        "x-build-id": "hRBBEMGQT3OaoD7Ux"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tklinger50~x-twitter-we-scrape-all-at-any-scale/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tklinger50-x-twitter-we-scrape-all-at-any-scale",
                "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/tklinger50~x-twitter-we-scrape-all-at-any-scale/runs": {
            "post": {
                "operationId": "runs-sync-tklinger50-x-twitter-we-scrape-all-at-any-scale",
                "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/tklinger50~x-twitter-we-scrape-all-at-any-scale/run-sync": {
            "post": {
                "operationId": "run-sync-tklinger50-x-twitter-we-scrape-all-at-any-scale",
                "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": [
                    "operation",
                    "targets"
                ],
                "properties": {
                    "operation": {
                        "title": "What to fetch",
                        "enum": [
                            "user.tweets",
                            "profile.info",
                            "user.followers",
                            "user.following",
                            "search",
                            "hashtag"
                        ],
                        "type": "string",
                        "description": "User tweets = recent tweets of an @handle · Profile info = bio/followers count/verified · Followers = who follows an @handle · Following = who an @handle follows · Keyword search = tweets matching a phrase · Hashtag search = tweets for a #hashtag.",
                        "default": "user.tweets"
                    },
                    "targets": {
                        "title": "Targets",
                        "type": "array",
                        "description": "One per line. For User tweets / Profile / Followers / Following: enter @handles (the @ is optional). For Keyword search: enter words or phrases. For Hashtag search: enter the tag (# optional).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "limit": {
                        "title": "Max results per target",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many results to return per target. You control the quantity — 1 to 500 (hard cap 500 per request).",
                        "default": 40
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
