# Twitter Scraper | Extract Tweets & Profiles | No API Key (`cryptosignals/twitter-scraper`) Actor

Scrape Twitter/X profiles, tweets, and search results without API key or rate limits. Get tweet text, author, likes, retweets, replies, and timestamps. Ideal for social listening and brand monitoring. PPE pricing — pay only for results.

- **URL**: https://apify.com/cryptosignals/twitter-scraper.md
- **Developed by:** [Web Data Labs](https://apify.com/cryptosignals) (community)
- **Categories:** Social media, AI, Lead generation
- **Stats:** 223 total users, 37 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

$5.00 / 1,000 result scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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/X Scraper — Extract Tweets, Profiles & Search Results Without API Keys

> **Free plan?** Apify gives every user **$5 in free credits every month** — at $5/1K tweets that covers **~1,000 tweets/month**. No credit card needed.

Scrape public data from Twitter/X at scale — no official API key, no developer account, no authentication tokens required. Just enter a username or keyword/hashtag and get structured JSON data with full tweet text, engagement metrics, author details, and media URLs. Fetch up to **10,000 tweets per run**.

This actor uses multiple redundant extraction methods with automatic failover to ensure reliable data extraction even when individual methods hit rate limits.

### Why Use This Instead of the Official Twitter API?

| Feature | Official Twitter API | This Scraper |
|---------|---------------------|--------------|
| **Cost** | Gated paid dev account — legacy Basic (~$200/mo) closed to new signups; new devs get pay-per-use (~$0.005/read, ~2M-read cap), above which it jumps to Enterprise (~$42k+/mo) | Pay-per-event — $5/1K tweets |
| **Setup time** | Apply for developer account (days/weeks) | Start scraping in 30 seconds |
| **Rate limits** | Strict monthly caps | Automatic rate limit handling with retries |
| **Authentication** | OAuth tokens required | No tokens needed |
| **Data format** | Complex nested JSON | Clean, flat JSON ready for analysis |
| **Historical data** | Gated behind a paid developer account | Available via search |

Twitter's official API is now locked behind a paid developer account: the legacy Basic tier (~$200/mo) is closed to new signups, new developers are metered on pay-per-use (~$0.005/read, ~2M-read cap), and anything above that cap jumps to Enterprise (~$42k+/mo) — putting it out of reach for most researchers, marketers, and small businesses. This scraper provides the same public data at a fraction of the cost.

***

### What Data Can You Extract?

#### Tweet Data

Every scraped tweet includes:

- **Full text** — complete tweet content including long tweets
- **Engagement metrics** — likes, retweets, replies, quotes, views, bookmarks
- **Author info** — username, display name, user ID
- **Timestamps** — exact creation date and time
- **Media** — URLs for images, videos, and GIFs (highest quality)
- **Tweet metadata** — language, whether it's a retweet/reply/quote tweet
- **Direct URL** — link back to the original tweet on x.com

#### Profile Data

When scraping a user profile, you also get:

- Display name and bio
- Follower and following counts
- Tweet count
- Profile and banner images
- Account creation date
- Verification status

***

### Use Cases

#### 1. Brand Monitoring & Reputation Management

Track what people are saying about your brand, products, or executives on Twitter/X. Set up scheduled runs to get daily or hourly alerts on brand mentions. Combine with sentiment analysis tools to gauge public perception over time.

**Example**: A SaaS company monitors mentions of their product name and competitor names to track share-of-voice and respond to customer complaints within hours.

#### 2. Competitor Research & Market Intelligence

Analyze your competitors' Twitter presence — what content gets the most engagement, what topics they cover, and how their audience responds. Extract competitor tweet data to benchmark your social media performance.

**Example**: An e-commerce brand scrapes competitor profiles weekly to identify trending product categories and successful promotional strategies.

#### 3. Trend Tracking & News Monitoring

Monitor hashtags, keywords, or specific accounts to stay on top of industry trends, breaking news, or emerging topics. Useful for journalists, analysts, and content creators who need to react quickly.

**Example**: A crypto research firm tracks tweets from key opinion leaders and trending hashtags to identify market-moving narratives before they go mainstream.

#### 4. Sentiment Analysis & Opinion Mining

Collect tweets about a topic, product launch, or event and feed them into NLP/sentiment analysis pipelines. The structured JSON output integrates directly with Python data science tools (pandas, TextBlob, VADER, OpenAI).

**Example**: A political consultancy scrapes tweets mentioning candidate names during a debate to measure real-time public sentiment shifts.

#### 5. Influencer Discovery & Outreach

Find influential accounts in any niche by scraping tweets with specific keywords and sorting by engagement metrics. Identify micro-influencers with high engagement rates for marketing campaigns.

**Example**: A fitness brand searches for tweets about "home workout" and "protein powder" to find creators with engaged audiences for partnership opportunities.

#### 6. Academic & Social Science Research

Researchers studying online discourse, misinformation, political polarization, or cultural trends need large tweet datasets. This scraper provides structured, exportable data suitable for academic analysis without the cost barriers of the official API.

**Example**: A university research team collects tweets about climate change over a 6-month period to study how framing differs across political groups.

#### 7. Lead Generation

Extract tweets from people expressing purchase intent, asking for recommendations, or complaining about competitor products. These high-intent signals make excellent sales leads.

**Example**: A B2B software company scrapes tweets containing "looking for CRM" or "hate my current CRM" to find warm leads for outreach.

#### 8. Content Curation & Inspiration

Content creators and social media managers scrape top-performing tweets in their niche to understand what resonates with audiences, find shareable content, and generate ideas for their own posts.

**Example**: A marketing agency scrapes the top 50 most-liked tweets each week about "AI tools" to curate a weekly newsletter for their audience.

***

### Input Parameters

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| `username` | String | Yes | — | Twitter/X username to scrape (without the @ symbol). Example: `elonmusk` |
| `action` | String | No | `profile` | What to scrape. Options: `profile` (profile info + tweets), `tweets` (tweets only) |
| `maxTweets` | Integer | No | `20` | Maximum number of tweets to retrieve. Range: 1–10,000 |

#### Input Example

```json
{
    "username": "elonmusk",
    "action": "profile",
    "maxTweets": 20
}
```

#### Advanced Input — Scraping Multiple Users

To scrape multiple accounts, run the actor in a loop or use the Apify scheduler to run separate configurations for each username.

***

### Sample Output

#### Tweet Object

```json
{
    "tweet_id": "1908234567890123456",
    "user_id": "44196397",
    "user_name": "Elon Musk",
    "user_handle": "elonmusk",
    "tweet_text": "The mass of a mass-produced vehicle is the best proxy for its cost. Reducing mass is the key design challenge for making electric vehicles affordable for everyone.",
    "likes": 142850,
    "retweets": 18230,
    "replies": 12450,
    "quotes": 3280,
    "views": 0,
    "bookmarks": 9840,
    "tweet_url": "https://x.com/elonmusk/status/1908234567890123456",
    "created_at": "Wed Mar 05 14:23:01 +0000 2026",
    "is_retweet": false,
    "is_reply": false,
    "is_quote": false,
    "language": "en",
    "media_urls": [
        "https://pbs.twimg.com/media/example_image.jpg"
    ],
    "source": "twitter_api"
}
```

#### Profile Object (when action = "profile")

The actor returns profile metadata alongside tweets when using the `profile` action:

```json
{
    "user_id": "44196397",
    "user_name": "Elon Musk",
    "user_handle": "elonmusk",
    "bio": "Read @TheBoringCompany, @Tesla, @SpaceX, & @xAI",
    "followers": 210500000,
    "following": 860,
    "tweet_count": 52400,
    "verified": true,
    "profile_image": "https://pbs.twimg.com/profile_images/example.jpg",
    "banner_image": "https://pbs.twimg.com/profile_banners/44196397/example.jpg",
    "created_at": "Tue Jun 02 20:12:29 +0000 2009",
    "location": "Mars & Austin, TX"
}
```

***

### Code Examples

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run_input = {
    "username": "elonmusk",
    "action": "tweets",
    "maxTweets": 50,
}

run = client.actor("cryptosignals/twitter-scraper").call(run_input=run_input)

## Fetch results from the dataset
for tweet in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"@{tweet['user_handle']}: {tweet['tweet_text'][:80]}...")
    print(f"  Likes: {tweet['likes']}  Retweets: {tweet['retweets']}  Views: {tweet['views']}")
    print()
```

##### Export to CSV with Pandas

```python
from apify_client import ApifyClient
import pandas as pd

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("cryptosignals/twitter-scraper").call(
    run_input={"username": "OpenAI", "action": "tweets", "maxTweets": 100}
)

tweets = list(client.dataset(run["defaultDatasetId"]).iterate_items())
df = pd.DataFrame(tweets)

## Analyze engagement
print(f"Average likes: {df['likes'].mean():.0f}")
print(f"Average views: {df['views'].mean():.0f}")
print(f"Top tweet: {df.loc[df['likes'].idxmax()]['tweet_text'][:100]}")

df.to_csv("tweets.csv", index=False)
```

#### Node.js / JavaScript

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

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

const run = await client.actor('cryptosignals/twitter-scraper').call({
    username: 'elonmusk',
    action: 'tweets',
    maxTweets: 50,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();

for (const tweet of items) {
    console.log(`@${tweet.user_handle}: ${tweet.tweet_text.slice(0, 80)}...`);
    console.log(`  Likes: ${tweet.likes}  Retweets: ${tweet.retweets}  Views: ${tweet.views}`);
    console.log();
}
```

#### cURL (Direct API Call)

```bash
## Start the actor run
curl -X POST \
  "https://api.apify.com/v2/acts/cryptosignals~twitter-scraper/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"username": "elonmusk", "action": "tweets", "maxTweets": 20}'

## Fetch results (replace DATASET_ID with the ID from the run response)
curl "https://api.apify.com/v2/datasets/DATASET_ID/items?token=YOUR_API_TOKEN&format=json"
```

***

### Pricing

This actor uses a **pay-per-event** pricing model — you only pay for the data you actually receive.

| Event | Price |
|-------|-------|
| Tweet scraped | $0.005 per tweet |
| Profile scraped | $0.005 per profile |

#### Cost Examples

| Scenario | Tweets | Cost |
|----------|--------|------|
| Quick check on one account | 10 tweets | $0.05 |
| Daily brand monitoring | 100 tweets/day | $0.50/day (~$15/month) |
| Weekly competitor analysis (5 accounts) | 500 tweets/week | $2.50/week (~$10/month) |
| Research dataset | 1,000 tweets | $5.00 |
| Large-scale analysis | 1,000 tweets (across accounts) | $5.00 |

**Compare with Twitter API**: Official access now requires a paid developer account — the legacy Basic tier (~$200/mo) is closed to new signups, and heavy usage escalates to Enterprise (~$42k+/mo). This scraper has no monthly commitment, no application process, and pay-as-you-go flexibility.

You can also use the Apify Free plan (which includes $5/month in platform credits) to try the scraper at no additional cost.

***

### Scheduling & Automation

Set up automatic recurring runs to collect tweet data on a schedule:

1. Go to the actor's page on Apify Console
2. Click **"Schedule"** in the top menu
3. Set your desired frequency (hourly, daily, weekly)
4. Configure the input parameters
5. Results are saved to a named dataset you can access via API

#### Common Scheduling Patterns

| Use Case | Frequency | maxTweets | Estimated Monthly Cost |
|----------|-----------|-----------|----------------------|
| Brand alerts | Every 4 hours | 20 | ~$18/month |
| Daily digest | Once daily | 100 | ~$15/month |
| Weekly report | Once weekly | 500 | ~$10/month |

#### Webhook Integration

Set up a webhook URL in the actor's run configuration to get notified (or trigger downstream processes) whenever a run completes. This works great with:

- **Zapier / Make** — pipe tweet data into Google Sheets, Slack, or email
- **Custom endpoints** — send data to your own API for processing
- **Apify integrations** — chain with other actors for enrichment

***

### Output & Export Options

Results are stored in an Apify dataset and can be exported in multiple formats:

- **JSON** — structured data, ideal for programmatic access
- **CSV** — open in Excel, Google Sheets, or import into databases
- **XLSX** — native Excel format
- **XML** — for legacy system integration
- **RSS** — subscribe to results as a feed

Access your data through the Apify Console, API, or client libraries.

***

### How It Works

The scraper uses a layered, multi-method extraction approach for maximum reliability. It reads only publicly available data — the same data any visitor to twitter.com can see — with no login or API credentials required.

If one extraction method is rate-limited or temporarily unavailable, the actor automatically fails over to alternatives, so it keeps working even when individual methods degrade. Rate limits are handled automatically with exponential backoff and retries.

***

### Limitations

> ⚠️ **Important — read before buying:** This scraper uses Twitter's unauthenticated public endpoints (no API key). This has hard limits that cannot be worked around without official API access. See below.

- **Small accounts return 0 tweets** — Twitter's unauthenticated endpoints do not return tweet timelines for accounts with fewer than approximately 10,000 followers. Profile data (bio, follower count, etc.) is still returned, but tweets will be empty. This is a Twitter platform restriction, not a bug. If you need to scrape small accounts, you require the official Twitter API (a gated paid developer account — see the cost comparison above).
- **No view counts** — Twitter requires authentication to return view/impression data. The `views` field will always be 0.
- **Public data only** — Cannot access private/protected accounts or DMs
- **Rate limits** — Twitter enforces rate limits on public endpoints; the actor handles this with retries and fallbacks, but very large scraping jobs may take longer
- **Maximum 10,000 tweets per run** — The actor paginates automatically using cursor-based pagination. For very large archives, run the actor multiple times.
- **Data freshness** — Scrapes live data from Twitter; results reflect what is publicly visible at the time of scraping

***

### 📡 More social monitoring actors by this team

Track your brand or niche across every platform — same clean JSON output, same pay-per-result pricing:

| Platform | Actor |
|---|---|
| Instagram | [Instagram Profile Scraper](https://apify.com/cryptosignals/instagram-profile-scraper) |
| Bluesky | [Bluesky Scraper](https://apify.com/cryptosignals/bluesky-scraper) |
| Reddit | [Reddit Scraper (Fast)](https://apify.com/cryptosignals/reddit-scraper-fast) |
| YouTube | [YouTube Scraper](https://apify.com/cryptosignals/youtube-scraper) |
| Pinterest | [Pinterest Scraper](https://apify.com/cryptosignals/pinterest-scraper) |
| Substack | [Substack Scraper](https://apify.com/cryptosignals/substack-scraper) |

***

### Frequently Asked Questions

#### Do I need a Twitter/X API key or developer account?

No. This scraper works without any Twitter API credentials. You do not need to apply for or maintain a Twitter developer account. Just provide a username and run the actor.

#### Is this legal?

This scraper only accesses publicly available data through public endpoints — the same data any visitor to twitter.com can see. It does not bypass any authentication, access private data, or violate Twitter's technical access controls. Users are responsible for complying with applicable laws and regulations in their jurisdiction regarding data collection and use.

#### How fresh is the data?

The scraper fetches live data directly from Twitter's servers each time it runs. Data is as fresh as the moment of scraping — typically within seconds of the current state of an account's public timeline.

#### Can I scrape tweets from private/protected accounts?

No. This scraper only accesses publicly available data. Protected accounts' tweets are not visible to unauthenticated users and cannot be scraped.

#### What happens if Twitter changes their API or blocks scraping?

The actor uses multiple fallback methods. If one method stops working, it automatically switches to alternatives. We actively monitor and update the scraper to adapt to changes in Twitter's infrastructure.

#### Can I scrape by keyword or hashtag search?

Yes — set `action` to `search` and provide a `searchQuery` (e.g. `#Bitcoin` or `AI news`). Note: search coverage depends on live availability of public data sources and may be limited.

#### Why am I getting 0 tweets for a username?

The most common reason is account size. Twitter's unauthenticated API does not return tweet timelines for accounts with fewer than ~10,000 followers. You will get the profile (bio, follower count) but the tweets array will be empty. This is a platform restriction — the actor cannot bypass it. For small accounts, use the official Twitter API or search for their tweets by keyword instead.

#### How do I scrape multiple accounts?

Run the actor separately for each username, or use Apify's scheduling feature to set up recurring runs for multiple accounts. You can also use the Apify API to programmatically start runs for a list of usernames.

#### What is pay-per-event pricing?

Instead of paying a flat monthly fee, you pay only for the data you actually receive. Each tweet or profile scraped counts as one event at $0.005. If you scrape 200 tweets, you pay $1.00. No minimums, no commitments, no wasted budget.

#### Can I integrate this with my existing tools?

Yes. Apify provides native integrations with Zapier, Make (Integromat), Google Sheets, Slack, and more. You can also use webhooks or the REST API to connect with any custom tool or pipeline.

#### How does this compare to other Twitter scrapers on Apify?

This scraper is designed for simplicity and reliability. It uses multiple fallback methods for consistent data extraction, provides clean flat JSON output (no nested objects to parse), and offers competitive pay-per-event pricing at $0.005 per tweet.

***

### Support & Updates

If you encounter any issues or have feature requests, please open an issue on the actor's Apify page. We actively maintain this scraper and release updates to handle changes in Twitter's infrastructure.

**Recent updates:**

- Cursor-based pagination: up to 10,000 tweets per run (previously capped at 20)
- Keyword/hashtag search via `action=search`
- Clarified limitation: accounts with <10K followers return 0 tweets (Twitter platform restriction)
- Multi-method extraction system with automatic failover
- Media extraction for images, videos, and GIFs
- Automatic rate limit handling with exponential backoff

# Actor input Schema

## `username` (type: `string`):

Twitter/X username to scrape (without @). Required for profile and tweets actions.

## `action` (type: `string`):

What to scrape: profile info, tweets from a user, or keyword/hashtag search results

## `maxTweets` (type: `integer`):

Maximum number of tweets to retrieve

## `searchQuery` (type: `string`):

Hashtag or keyword to search (e.g. #Bitcoin, 'AI news'). Used when action=search.

## Actor input object example

```json
{
  "username": "elonmusk",
  "action": "tweets",
  "maxTweets": 20
}
```

# Actor output Schema

## `dataset` (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 = {
    "username": "elonmusk",
    "action": "tweets",
    "maxTweets": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("cryptosignals/twitter-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 = {
    "username": "elonmusk",
    "action": "tweets",
    "maxTweets": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("cryptosignals/twitter-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 '{
  "username": "elonmusk",
  "action": "tweets",
  "maxTweets": 20
}' |
apify call cryptosignals/twitter-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/HoV6fnR4MTcMqEkbz/builds/ijJqhZH0GkPI2v61A/openapi.json