# Twitter Scraper - Scrape Tweets from X Profiles (`logiover/x-tweet-scraper`) Actor

Scrape tweets from any X / Twitter profile without an API key or login. Twitter timeline scraper with full engagement; export tweets to CSV/JSON.

- **URL**: https://apify.com/logiover/x-tweet-scraper.md
- **Developed by:** [Logiover](https://apify.com/logiover) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 6 total users, 5 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. 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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Scraper — Scrape Tweets from Any X (Twitter) Profile, No API Key

![Apify Actor](https://img.shields.io/badge/Apify-Actor-00A67E?logo=apify\&logoColor=white) ![No API key](https://img.shields.io/badge/No%20API%20key-required-2ea44f) ![Pay per result](https://img.shields.io/badge/Pricing-Pay%20per%20result-1C7ED6) ![Category](https://img.shields.io/badge/Category-Social%20Media-8B5CF6) ![Export](https://img.shields.io/badge/Export-JSON%20%7C%20CSV%20%7C%20Excel-F59E0B)

Scrape tweets from any **X / Twitter** profile with full engagement — **likes, retweets, replies, quotes, bookmarks and views** — plus hashtags, mentions, links, media, language and the post date. Point it at any `@handle` or profile URL and it paginates the timeline to pull **hundreds of tweets per profile**.

It needs **no login, no cookies and no API key** — it reads only public data through **guest-token access over residential proxies**, so there's **zero risk to any X account**. With no headless browser, it's a fast, low-cost way to build large, analysis-ready tweet datasets — the practical **X / Twitter API alternative** for tweet data at scale.

> ### 🏆 Why this X / Twitter tweet scraper?
>
> Hundreds of tweets per profile · every engagement metric incl. **views & bookmarks** · hashtags, mentions, links & media · author context (followers + verified) · retweet/reply filters · no login / no cookies / no API key · guest-token + residential proxy = **zero ban risk** · export to JSON, CSV & Excel

***

### ✨ What this Actor does

- **📦 Hundreds of tweets per profile** — cursor pagination walks the full public timeline; you control depth with `maxTweetsPerProfile`.
- **📊 Every engagement metric** — `likeCount`, `retweetCount`, `replyCount`, `quoteCount`, `bookmarkCount` and `viewCount` on each tweet.
- **🧵 Rich tweet data** — `hashtags`, `mentions`, `urls`, `media`, `lang` and type flags (`isReply` / `isQuote` / `isRetweet`).
- **👤 Author context** — the tweet author's `username`, `name`, `followers` count and `verified` status on every row.
- **🎚️ Smart filters** — toggle `includeRetweets` and `includeReplies` independently to keep only the original tweets you want.
- **📝 Long-form supported** — the full `text` is captured, including long-form posts, not just the 280-character preview.
- **⚡ No browser** — lightweight guest-token API access, so it's fast and cheap even at large scale.
- **🛡️ Login-free & safe** — guest-token access over residential proxies; no account, no cookies you provide, and no ban risk.
- **📤 Export anywhere** — download to JSON, CSV, Excel or HTML, or pull via the Apify API and webhooks.

***

### 🚀 Quick start (3 steps)

1. **Configure** — add one or more X **@handles or profile URLs** to `profiles`, set `maxTweetsPerProfile` for depth, and optionally toggle `includeRetweets` / `includeReplies`.
2. **Run** — click **Start**. The actor resolves each profile and walks its public timeline with cursor pagination.
3. **Get your data** — download the tweets as CSV, JSON or Excel from the run page, or pull them through the Apify API.

***

### 📥 Input

Add the profiles you want, then tune depth and the retweet/reply filters. Here are three ready-to-run scenarios:

**Two profiles, original tweets only (no replies)**

```json
{
  "profiles": ["nasa", "naval"],
  "maxTweetsPerProfile": 200,
  "includeReplies": false
}
```

**Deep single-profile archive with everything**

```json
{
  "profiles": ["https://x.com/stripe"],
  "maxTweetsPerProfile": 500
}
```

**Many handles into one capped dataset**

```json
{
  "profiles": ["nasa", "@naval", "stripe", "openai"],
  "maxTweetsPerProfile": 150,
  "includeRetweets": false,
  "includeReplies": false,
  "maxResults": 400
}
```

| Field | Type | Description |
|---|---|---|
| `profiles` | array | **Required.** X `@handles` or profile URLs (e.g. `nasa`, `@naval`, `https://x.com/stripe`). |
| `maxTweetsPerProfile` | integer | How many tweets to collect per profile (paginated). Default `100`. |
| `includeRetweets` | boolean | Include the profile's retweets. Default `true`. |
| `includeReplies` | boolean | Include the profile's reply tweets. Default `true`. |
| `maxResults` | integer | Global cap on tweets saved across all profiles. `0` = unlimited. |
| `proxyConfiguration` | object | Residential proxy (required by X). Pre-configured (Apify Proxy · RESIDENTIAL group). |

***

### 📤 Output

Each tweet is saved as one structured record. Here is a trimmed example:

```json
{
  "tweetId": "2059393717111308634",
  "url": "https://x.com/NASA/status/2059393717111308634",
  "text": "On Tuesday, June 9, we'll announce the four astronauts who will fly around the Moon on Artemis II.",
  "createdAt": "Tue Jun 03 16:00:00 +0000 2026",
  "lang": "en",
  "likeCount": 38146,
  "retweetCount": 4120,
  "replyCount": 612,
  "quoteCount": 210,
  "bookmarkCount": 1503,
  "viewCount": 2834957,
  "isReply": false,
  "isQuote": false,
  "isRetweet": false,
  "hashtags": ["Artemis"],
  "mentions": ["NASA_Astronauts"],
  "urls": ["https://www.nasa.gov/artemis"],
  "media": [{ "type": "photo", "url": "https://pbs.twimg.com/media/Gx1a2b3c.jpg" }],
  "author": { "username": "NASA", "name": "NASA", "followers": 92089565, "verified": true },
  "fromProfile": "NASA"
}
```

<details><summary><b>📋 Full field reference (click to expand)</b></summary>

| Field | Description |
|---|---|
| `tweetId` | Unique tweet ID |
| `url` | Direct link to the tweet |
| `text` | Full tweet text (long-form posts supported) |
| `createdAt` | Post date/time |
| `lang` | Detected language code |
| `likeCount` | Likes |
| `retweetCount` | Retweets |
| `replyCount` | Replies |
| `quoteCount` | Quote tweets |
| `bookmarkCount` | Bookmarks |
| `viewCount` | Views / impressions (when X exposes it) |
| `isReply` | True if the tweet is a reply |
| `isQuote` | True if the tweet quotes another tweet |
| `isRetweet` | True if the tweet is a retweet |
| `hashtags` | Hashtags in the tweet (array) |
| `mentions` | Mentioned @handles (array) |
| `urls` | Links in the tweet (array) |
| `media` | Photos / videos, each with `type` and `url` |
| `author.username` | Author @username |
| `author.name` | Author display name |
| `author.followers` | Author follower count |
| `author.verified` | Author verified status |
| `fromProfile` | The input profile this tweet came from |

</details>

***

### 💡 Use cases

- **📈 Content & competitor analysis** — see which posts and formats win in your niche, ranked by real engagement.
- **🗂️ Brand & executive monitoring** — archive an account's output over time with likes, views and reach.
- **🧠 Data science & ML** — build labelled tweet datasets for NLP, sentiment analysis and trend detection.
- **📊 Marketing benchmarks** — compare reach and engagement across accounts and time to set realistic targets.
- **🔎 Research & journalism** — collect a public figure's or organization's timeline as structured, exportable data.
- **🤖 AI agents & RAG** — feed clean tweet records into an LLM tool or vector store to answer questions about an account's activity.

***

### 👥 Who uses it

Social-media & content marketers · competitive-intelligence analysts · data scientists & ML engineers · brand and PR teams · researchers and journalists · growth and trend analysts · AI-agent / RAG builders

***

### 💰 Pricing

This actor runs on Apify's **pay-per-result** model — you're billed for the tweets you collect, with no monthly minimum and no X / Twitter API fees or developer-tier caps. Small pulls cost pennies; large multi-profile datasets scale linearly. Use `maxTweetsPerProfile` and `maxResults` to cap spend, and see the **Pricing** tab on the actor page for current rates.

***

### ❓ Frequently Asked Questions

#### Is this an X / Twitter API alternative?

Yes. It pulls a profile's tweets with full engagement without the official X / Twitter API, a developer account, app keys or the API's low free-tier read caps — just paste handles and run.

#### Can I scrape tweets without an API key or login?

Yes. This is a **Twitter scraper without an API key** — it uses public **guest-token** access over residential proxies, so you scrape tweets without login, cookies or a developer account, and with **zero ban risk** because no X account is ever used.

#### Does it need login or cookies?

No. The actor uses public guest-token access — no login, no cookies you provide and no developer API key. No X account is involved, so there's zero ban risk.

#### How many tweets can I get per profile?

Hundreds — it paginates the public timeline with cursor pagination, and you control depth with `maxTweetsPerProfile`. Run many handles in one go for a large dataset, and use `maxResults` for a global cap.

#### Are view counts included?

Yes — `viewCount` is captured whenever X exposes it, alongside `likeCount`, `retweetCount`, `replyCount`, `quoteCount` and `bookmarkCount`.

#### Can I exclude retweets or replies?

Yes — toggle `includeRetweets` and `includeReplies` independently to get only the original tweets you want.

#### Is this a Twitter timeline scraper?

Yes. Point it at any `@handle` and it walks the public timeline with cursor pagination to pull hundreds of tweets per profile with full engagement metrics.

#### Do I need residential proxies?

Yes — X requires them for reliable public access, and the input is pre-configured to use the Apify Proxy RESIDENTIAL group, so you don't have to set anything up.

#### How do I export tweets to CSV or JSON?

Every run builds a tweet dataset you can export to CSV, JSON, Excel or HTML, or pull straight from the API and webhooks — ideal for a tweet engagement dataset.

#### Is it legal?

The actor collects only **publicly available** tweet data. You are responsible for compliance with X's Terms and applicable laws, including bulk-access limits and data-protection rules such as the GDPR.

***

### 🔗 More social media scrapers by logiover

| Actor | What it does |
|---|---|
| [Threads Scraper](https://apify.com/logiover/threads-scraper) | Posts & profiles from Threads |
| [TikTok Brand Monitoring & Mention Tracker](https://apify.com/logiover/tiktok-brand-mention-monitor) | Track TikTok videos mentioning your brand |
| [TikTok Hashtag & Keyword Video Scraper](https://apify.com/logiover/tiktok-hashtag-video-scraper) | High-volume TikTok video pulls |
| [Instagram Media Downloader](https://apify.com/logiover/instagram-media-downloader) | Download Instagram posts & reels |
| [Reddit Search Scraper](https://apify.com/logiover/reddit-search-scraper) | Search posts across Reddit |
| [Reddit Subreddit Scraper](https://apify.com/logiover/reddit-subreddit-scraper) | Posts & discussions from any subreddit |
| [YouTube Channel Scraper](https://apify.com/logiover/youtube-channel-scraper) | Channel metadata & videos |
| [YouTube Search Scraper](https://apify.com/logiover/youtube-search-scraper) | Search results & video metadata |
| [Pinterest Scraper](https://apify.com/logiover/pinterest-scraper) | Pins, boards & image data |
| [LinkedIn Top Content Scraper](https://apify.com/logiover/linkedin-top-content-scraper) | Top-performing LinkedIn posts |

👉 Browse all **[logiover scrapers on Apify Store](https://apify.com/logiover)** — 180+ actors across real estate, jobs, crypto, social media & B2B data.

***

### ⏰ Scheduling & integration

- **Schedules** — open the **Schedules** tab in the Apify Console and point a daily or weekly run at this actor to keep an account's timeline archive fresh.
- **Export** — download every run as JSON, CSV, Excel or HTML.
- **No-code** — connect to **Make, n8n or Zapier** to push new tweets into Google Sheets, Airtable, a database or Slack.
- **API & webhooks** — call the actor via the Apify API (`run-sync-get-dataset-items`) or the JavaScript / Python clients, and fire a webhook when a run finishes.

***

### ⭐ Support & feedback

Found a bug or need another field or filter? Open an issue on the actor's **Issues** tab — responses are typically within 24 hours. If this actor saves you time, please leave a **★★★★★ review** on the Apify Store; it genuinely helps other builders discover it.

***

### ⚖️ Legal

This actor collects only **publicly available** tweet data — text, engagement counts, hashtags, media and public author handles that X already serves to anyone. It uses no login and no private data. You are responsible for using the collected data in compliance with X's Terms of Service, its bulk-access limits, applicable laws, and data-protection regulations such as the GDPR.

***

### 📝 Changelog

#### 2026-07-06

- ✨ README overhaul: richer output sample, ready-to-run example scenarios, cross-promo links, and clearer quick-start.

#### 2026-07-01

- Maintenance pass: re-verified end-to-end on live data and confirmed successful runs within the 5-minute quality window on the default input.
- Sharpened Store metadata (SEO title & description) and expanded the FAQ with high-intent, long-tail questions for easier discovery in Google and Apify Store search.
- Added ready-to-run example tasks that cover common real-world use cases.

#### 2026-06-15

- Hardened X engine: retry/fresh-proxy + built-in fallback queryIds — fixes intermittent zero-result and socket-disconnect runs.

#### 2026-06-07

- Docs: added coverage for scraping tweets without an API key or login, exporting tweets to CSV/JSON, and using the actor as a Twitter timeline scraper / API alternative.

#### 2026-06-05

- 🛡️ Reliability fix: results are no longer dropped by strict output validation — runs now complete cleanly even at high volume (thousands of results).
- ⚡ Stability & performance hardening; fresh rebuild.

#### 2026-06-04

- Verified live & refreshed build — reliability/maintenance pass.

# Actor input Schema

## `profiles` (type: `array`):

X / Twitter @handles or profile URLs to scrape tweets from. Examples: 'nasa', '@naval', 'https://x.com/stripe'. Leave empty to scrape tweets from a popular public account as a demo.

## `maxTweetsPerProfile` (type: `integer`):

How many tweets to collect per profile (paginated).

## `includeRetweets` (type: `boolean`):

Include the profile's retweets.

## `includeReplies` (type: `boolean`):

Include the profile's reply tweets.

## `maxResults` (type: `integer`):

Global cap on tweets saved across all profiles. 0 = unlimited.

## `proxyConfiguration` (type: `object`):

X requires residential proxies. Leave the default (Apify Proxy · RESIDENTIAL group).

## Actor input object example

```json
{
  "profiles": [
    "nasa",
    "https://x.com/naval"
  ],
  "maxTweetsPerProfile": 100,
  "includeRetweets": true,
  "includeReplies": true,
  "maxResults": 0,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

All records extracted by this run. Open the Dataset tab to browse, filter, and export as CSV, JSON, or Excel.

# 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 = {
    "profiles": [
        "nasa"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("logiover/x-tweet-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 = {
    "profiles": ["nasa"],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("logiover/x-tweet-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 '{
  "profiles": [
    "nasa"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call logiover/x-tweet-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/50nqc93420JzhBaBp/builds/MOzbjbimxOZrQumrR/openapi.json
