# X (Twitter) Tweet Scraper | $0.12/1K | No Login (`feedminer/x-tweet-scraper`) Actor

Scrape tweets from X by search term, profile, tweet URL, conversation or community. No login, no cookies. Full engagement metrics and author data, exported to JSON, CSV or Excel. Flat $0.12 per 1,000 tweets with no start or query fees. By FeedMiner.

- **URL**: https://apify.com/feedminer/x-tweet-scraper.md
- **Developed by:** [FeedMiner](https://apify.com/feedminer) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.10 / 1,000 tweet scrapeds

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/actors/running/actors-in-store.md#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

<div style="border-left:4px solid #1D9BF0;background:#F2F9FF;padding:14px 18px;border-radius:6px">
<strong>Scrape X (Twitter) tweets by search term, profile, thread or community.</strong> Full engagement metrics on every row, view counts included, exported as JSON, CSV or Excel. No X account, no API key, no code.
</div>

🔓 **Nothing to connect.** No login, no cookie, no API key on your side, and nothing to create or keep alive. Paste your input and press Start.

⚡ **Built for speed.** Measured on a real run: 600 posts in 22 seconds, around 27 posts per second.

💸 **One price, every input type.** $0.12 per 1,000 tweets, down to $0.10 on the larger Apify plans. The market leader charges $0.40 for the same rows.

🧵 **Whole threads, real views.** Point it at a tweet and get every reply with its own metrics. Every row carries views, the number most X scrapers skip.

#### Copy to your AI assistant

```
feedminer/x-tweet-scraper on Apify. Scrapes X (Twitter) tweets by search term, profile, tweet URL, conversation ID or community. One row per tweet with full text, engagement counts (likes, reposts, replies, quotes, bookmarks, views) and author profile. Call ApifyClient("TOKEN").actor("feedminer/x-tweet-scraper").call(run_input={...}), then client.dataset(run["defaultDatasetId"]).list_items().items. Provide at least one of searchTerms (string[]), twitterHandles (string[]), startUrls (string[]) or conversationIds (string[]); cap the dataset with maxItems. Full spec: GET https://api.apify.com/v2/acts/feedminer~x-tweet-scraper/builds/default (Bearer TOKEN) → inputSchema, actorDefinition.storages.dataset, readme. Token: https://console.apify.com/account/integrations
```

***

### <img src="https://apify-image-uploads-prod.s3.us-east-1.amazonaws.com/hoZ24gXinDHziMQKm-actor-3hbiY2nfMGfbNdh1w-DUuuMSYQpE-IMG_9471.jpeg" width="26" height="26" style="vertical-align:-4px;border-radius:6px"/> How to scrape tweets from X (Twitter)

Paste what you have, press Start. The scraper works out what each input is.

##### Basic: one search

```json
{ "searchTerms": ["web scraping"], "maxItems": 200 }
```

Keyword search covers all of X, and the full X advanced syntax works as is: `scraping from:apify min_faves:50 lang:en since:2026-01-01` does exactly what it says.

##### An account's timeline

```json
{ "twitterHandles": ["NASA"], "maxItems": 3200 }
```

##### An account's timeline, replies included

```json
{ "twitterHandles": ["NASA"], "includeReplies": true, "maxItems": 1000 }
```

A timeline stops at posts by default. `includeReplies` adds what the account answered to other people, which is where most of a support or community account's writing lives.

##### A thread, with every reply

```json
{ "startUrls": ["https://x.com/elonmusk/status/1519480761749016577"], "maxItems": 200 }
```

##### A competitor set over a date window

```json
{
  "searchTerms": ["from:openai", "from:anthropicai"],
  "start": "2026-07-01",
  "end": "2026-08-01",
  "includeSearchTerms": true
}
```

***

### Input parameters

| Parameter | Type | Default | Description |
|---|---|---|---|
| `searchTerms` | array | | Search queries, advanced syntax supported |
| `startUrls` | array | | Profile, tweet, search, list, community, /media or /highlights URLs |
| `twitterHandles` | array | | Accounts to pull, with or without the @ |
| `conversationIds` | array | | Tweet IDs whose replies you want |
| `maxItems` | integer | `1000` | Caps the dataset size |
| `sort` | select | Latest | Latest, Top, or both merged |

**Filter tweets**

| Parameter | Type | Default | Description |
|---|---|---|---|
| `tweetLanguage` | select | | Keeps only tweets X detected in this language |
| `onlyVerifiedUsers`, `onlyTwitterBlue` | boolean | false | Author badge filters |
| `onlyImage`, `onlyVideo`, `onlyQuote` | boolean | false | Media and type filters |
| `includeReplies` | boolean | false | Adds an account's replies to its posts |

**Search operators**

| Parameter | Type | Default | Description |
|---|---|---|---|
| `author`, `inReplyTo`, `mentioning` | string | | Scope to accounts |
| `minimumFavorites`, `minimumRetweets`, `minimumReplies` | integer | | Engagement floors |
| `start`, `end` | date | | Date window, YYYY-MM-DD |

**Location**

| Parameter | Type | Default | Description |
|---|---|---|---|
| `geotaggedNear`, `withinRadius`, `geocode`, `placeObjectId` | string | | Scope a search to a place |

**Advanced**

| Parameter | Type | Default | Description |
|---|---|---|---|
| `includeSearchTerms` | boolean | false | Tags each tweet with the term that found it |
| `sessions` | array | | Your own X accounts, for anyone who would rather run on accounts they control. Optional |
| `debugMode` | boolean | false | Extra logging for troubleshooting |

Filters stack: anything set in the form is added to every search term, and anything written inline in a term wins for that term.

***

### What data can you extract from X (Twitter)?

| Field | Type | Description |
|---|---|---|
| `id`, `url` | string | Tweet ID and direct link |
| `text`, `fullText` | string | Full tweet text, long form posts included |
| `createdAt` | string | Publication time, ISO format |
| `likeCount`, `retweetCount`, `replyCount` | integer | Core engagement |
| `quoteCount`, `bookmarkCount` | integer | Extended engagement |
| `viewCount` | integer | Views, on every tweet that has them |
| `isReply`, `isQuote`, `isRetweet`, `isPinned` | boolean | Tweet type flags |
| `conversationId`, `inReplyToId`, `inReplyToUsername` | string | Thread context |
| `hashtags`, `mentions`, `links` | array | Entities, links unwrapped to their real destination |
| `media`, `mediaType` | array | Photo URLs and playable MP4 video links |
| `lang`, `source`, `searchTerm`, `sourceType` | string | Language, client, and which input surfaced the row |
| `author` | object | userName, name, followers, following, verification, bio, location, pictures, counts |

##### Example row

```json
{
  "id": "1519480761749016577",
  "url": "https://x.com/elonmusk/status/1519480761749016577",
  "text": "Next I'm buying Coca-Cola to put the cocaine back in",
  "createdAt": "2022-04-28T00:56:58Z",
  "lang": "en",
  "likeCount": 4206944,
  "retweetCount": 579238,
  "replyCount": 167997,
  "quoteCount": 168171,
  "bookmarkCount": 22546,
  "viewCount": 0,
  "isReply": false,
  "isQuote": false,
  "isRetweet": false,
  "conversationId": "1519480761749016577",
  "author": {
    "userName": "elonmusk",
    "name": "Elon Musk",
    "followers": 227000000,
    "isBlueVerified": true,
    "twitterUrl": "https://x.com/elonmusk"
  },
  "sourceType": "conversation"
}
```

The output uses the same field names as the most popular X scraper on the Store, so an existing pipeline keeps working when you point it here.

***

### Pricing: Pay Per Event (PPE)

| Event | Price | Per 1,000 |
|---|---|---|
| Tweet delivered | $0.00012 | $0.12 |

No start fee and no per-query fee: you pay for rows, and only for rows. The price steps down on its own for the larger Apify plans, to $0.11 and then $0.10 per 1,000.

| Scraper | Per 1,000 tweets |
|---|---|
| Market leader | $0.40 |
| Usual challengers | $0.15 to $0.28 |
| **FeedMiner** | **$0.12** |

What real runs cost:

| Run | Cost |
|---|---|
| A brand search, 500 tweets | $0.06 |
| One account's whole available timeline, around 1,100 posts | $0.13 |
| A daily 200 tweet monitor, for a whole month | $0.72 |
| A 10,000 tweet research dataset | $1.20 |

##### Free tier

The Apify free plan includes $5 of usage every month, which is roughly 40,000 tweets here. No card required.

***

### Advanced usage

##### Trend and brand monitoring

Schedule a `Latest` search on your brand terms with `minimumFavorites: 0` and a daily Apify Schedule. Each run reads X at that moment, nothing is cached, so the feed is live.

##### Influencer discovery

Search a niche term with `sort: "Top"` and an engagement floor like `minimumFavorites: 100`, then rank the `author.followers` column. `Top` reaches further back than `Latest` on quiet terms.

##### Research datasets

Combine `searchTerms`, a date window and `includeSearchTerms: true` to build labelled corpora. A list of a hundred post links costs barely more time than a single one.

***

### Integrate tweets into your stack

Results flow through the Apify API into Python, JavaScript, Google Sheets, Make, Zapier, n8n, Airtable or Slack. Runs can be scheduled, monitored and chained with other Actors.

##### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("feedminer/x-tweet-scraper").call(run_input={
    "searchTerms": ["from:openai"],
    "maxItems": 200,
})

for tweet in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(tweet["createdAt"], tweet["viewCount"], tweet["text"][:80])
```

##### JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('feedminer/x-tweet-scraper').call({
    twitterHandles: ['NASA'],
    maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`${items.length} tweets`);
```

***

### Performance

| Measure | Value |
|---|---|
| Reading speed | 27 posts per second, measured on a 600 post run |
| Timeline depth | Around 1,100 posts per account, measured on a real run. The run follows a timeline as far as X serves it; X's own ceiling, for any tool including its official API, is 3,200 |
| Long lists of links | A hundred pasted post links cost barely more time than one |
| Partial results | Kept and delivered when a limit is reached, never discarded |

***

### FAQ

**Do I need an X account or an API key?**
No. There is nothing to connect and nothing to keep alive on your side. If you would rather the run used accounts you own, the optional `sessions` field takes them.

**How far back can it go?**
On one account, around 1,100 posts on a measured run. X's documented ceiling is 3,200 for any tool, its own API included, and a run follows a timeline as far as X serves it. On a search, as far as the date window you set.

**Can I get the replies to a specific tweet?**
Yes. Give it the tweet URL or the conversation ID and the thread under it comes back, each reply with its own metrics and author.

**Can I pull just an account's photos and videos?**
Yes. Add its `/media` URL. Highlighted posts are at `/highlights`.

**Why is a search thinner than expected?**
Recent windows on quiet terms have little to show. Switch `sort` to `Top`, which reaches back further, or anchor the search to an account with `from:`.

**What does it not do?**
Follower and following lists, the accounts behind a like or a repost, and direct messages. Everything this Actor advertises, it delivers from the inputs on the form.

**Is the data live?**
Yes. Every run reads X at that moment. Nothing is cached or resold.

***

### Support

- Found something off in the output, or need a field that is missing? Open the **Issues** tab on this Actor's page with what you ran and what you expected. Issues are read daily.
- Need a custom variant of this scraper for your pipeline? Ask in the Issues tab, FeedMiner builds on request.

### Legal compliance

This scraper collects only public data, the same information any visitor can see on x.com. Tweets and profiles can contain personal data: processing information about people in the EU, the UK or California requires a lawful basis under GDPR or CCPA. Use the data for research, analytics and business intelligence, not for spam or harassment.

***

**FeedMiner** · Fast, honestly priced scrapers, kept alive when platforms change.

X Tweet Scraper · [X Profile Scraper](https://apify.com/feedminer/x-profile-scraper) · [All FeedMiner Actors](https://apify.com/feedminer)

# Actor input Schema

## `searchTerms` (type: `array`):

What to search for on X. Supports the full advanced syntax, for example scraping from:apify min\_faves:10 lang:en.

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

Profile, tweet, search, list, community, /media or /highlights URLs. Paste them and get results.

## `twitterHandles` (type: `array`):

Accounts to scrape, with or without the @.

## `conversationIds` (type: `array`):

Tweet IDs whose replies you want.

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

Caps how many tweets end up in your dataset.

## `sort` (type: `string`):

How search results are ranked. Latest gives you the newest, Top the most engaging. Latest + Top runs both and merges them.

## `tweetLanguage` (type: `string`):

Keeps only tweets X detected in this language.

## `onlyVerifiedUsers` (type: `boolean`):

Restricts searches to verified authors.

## `onlyTwitterBlue` (type: `boolean`):

Restricts searches to authors on X Premium.

## `onlyImage` (type: `boolean`):

Restricts searches to tweets carrying an image.

## `onlyVideo` (type: `boolean`):

Restricts searches to tweets carrying a video.

## `onlyQuote` (type: `boolean`):

Restricts searches to quote tweets.

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

Adds each account's replies to its posts.

## `author` (type: `string`):

Restricts searches to tweets from this account, with or without the @.

## `inReplyTo` (type: `string`):

Restricts searches to replies addressed to this account, with or without the @.

## `mentioning` (type: `string`):

Restricts searches to tweets that mention this account, with or without the @.

## `minimumFavorites` (type: `integer`):

Drops search results with fewer likes than this.

## `minimumRetweets` (type: `integer`):

Drops search results with fewer reposts than this.

## `minimumReplies` (type: `integer`):

Drops search results with fewer replies than this.

## `start` (type: `string`):

YYYY-MM-DD

## `end` (type: `string`):

YYYY-MM-DD

## `geotaggedNear` (type: `string`):

A place name, for example San Francisco.

## `withinRadius` (type: `string`):

For example 15km, used together with Geotagged near.

## `geocode` (type: `string`):

latitude,longitude,radius, for example 37.7,-122.4,10km.

## `placeObjectId` (type: `string`):

X place id.

## `includeSearchTerms` (type: `boolean`):

Adds the term that found each tweet to its record.

## `sessions` (type: `array`):

Optional, and normally left empty. X accounts of your own, for anyone who would rather the run used accounts they control.

## `debugMode` (type: `boolean`):

Writes the actor's internal steps to the log. Turn it on when a run returns less than you expected.

## Actor input object example

```json
{
  "searchTerms": [
    "web scraping"
  ],
  "startUrls": [
    "https://x.com/apify"
  ],
  "maxItems": 1000,
  "sort": "Latest",
  "onlyVerifiedUsers": false,
  "onlyTwitterBlue": false,
  "onlyImage": false,
  "onlyVideo": false,
  "onlyQuote": false,
  "includeReplies": false,
  "includeSearchTerms": false,
  "debugMode": false
}
```

# Actor output Schema

## `tweets` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "searchTerms": [
        "web scraping"
    ],
    "startUrls": [
        "https://x.com/apify"
    ],
    "maxItems": 1000,
    "sort": "Latest"
};

// Run the Actor and wait for it to finish
const run = await client.actor("feedminer/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 = {
    "searchTerms": ["web scraping"],
    "startUrls": ["https://x.com/apify"],
    "maxItems": 1000,
    "sort": "Latest",
}

# Run the Actor and wait for it to finish
run = client.actor("feedminer/x-tweet-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "searchTerms": [
    "web scraping"
  ],
  "startUrls": [
    "https://x.com/apify"
  ],
  "maxItems": 1000,
  "sort": "Latest"
}' |
apify call feedminer/x-tweet-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,feedminer/x-tweet-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/3hbiY2nfMGfbNdh1w/builds/0k5Mhgrp8NGJJX8OC/openapi.json