TwitterAPI.io vs Apify for Twitter data: cost per query, limits and how to switch

How each one bills

Apify has two layers. The platform sells a monthly plan, listed on its pricing page (apify.com/pricing): Free ($5 of usage a month, no card), Starter $19, Scale $199 and Business $999, each including the same dollar amount of prepaid usage, with overage added to the next invoice (on the free plan, access is blocked until the next cycle). Unused usage is not rolled over. On top of that, every Store actor sets its own price. Most Twitter actors use pay per event: the developer defines events such as “query” or “result” and charges for each. Apify says most pay-per-event actors include platform usage in the event price, but some charge compute separately, so the actor's pricing tab is the source of truth.

This page prices the three Twitter actors by Api Dojo, whose Tweet Scraper V2 is the most-used Twitter actor in Apify Store by monthly users:

• Tweet Scraper V2 (apify.com/apidojo/tweet-scraper): $0.40 per 1,000 tweets. Each query must return at least 50 tweets, one run at a time with up to 5 batched queries, no single tweets, no replies, and “No monitoring”.
• Twitter Scraper Unlimited (apify.com/apidojo/twitter-scraper-lite): $0.016 per search, profile or list query, including the first two pages (about 40 tweets), then $0.0004 per tweet in runs of up to 5 queries, $0.0008 for 6–10, $0.0012 for 11–30, $0.0016 for 31–100 and $0.002 above 100. A single tweet URL is $0.05 plus the item. This is the actor Api Dojo recommends for small queries, single tweets and replies.
• Twitter User Scraper (apify.com/apidojo/twitter-user-scraper): $0.004 per profile URL, $0.016 per followers, following or retweeters query (first ~70 users included), $0.008 per keyword search (first ~20 included), $0.0004 per additional user, at least 5 objects per run.

TwitterAPI.io uses credits: 100,000 credits are $1, no plan required. Tweets cost 15 credits each and profiles 18, with a 15-credit minimum per request. There is no per-request cap, so the price per tweet is the same on a page of 1 or of 20:

request = max(15, 15 × tweets returned) credits · user search = 18 per user · 100,000 credits = $1

The structural difference is the floor. The smallest query on Api Dojo's actors costs $0.016 whether it returns 0 tweets or 40; ours costs $0.00015 when it returns nothing. Past the floor, Apify charges $0.0004 per tweet in small runs, while every tweet here costs $0.00015, so a full 20-tweet page is $0.003. The chart shows what one query costs as the number of tweets it returns grows.

Price per data type

Each row prices one kind of data the way you would fetch it on each service, using the lower-priced Api Dojo actor that supports it. Green marks the lower price.

Apify prices from the actor pages for Tweet Scraper V2 (apify.com/apidojo/tweet-scraper), Twitter Scraper Unlimited (apify.com/apidojo/twitter-scraper-lite) and Twitter User Scraper (apify.com/apidojo/twitter-user-scraper), paid-plan rates; Api Dojo states that free-plan users get different terms. Followers per 1,000 on Apify: ($0.016 + 930 × $0.0004) for 1,000 users = $0.388. TwitterAPI.io prices from our pricing page. Checked in 2026.

Apify Store also lists Twitter actors from other developers, each with its own price, minimums and limits. Some charge per result with no query event, others a minimum per query or per run; check how the actor bills a query that returns nothing and whether it adds platform usage. If you are comparing a specific actor, read its pricing tab and its minimum charge per query before you price a workload; the floor per query matters more than the headline per-1,000 figure for anything you run often.

We also publish Twitter actors in Apify Store ourselves, under the developer name kaitoeasyapi, for teams that would rather stay on Apify. They are billed by Apify at the prices on their listings, which are separate from the API prices on this page. Calling the API directly needs no Apify plan, and a search with no results returns an empty list.

What a month costs: ten workloads

Here are ten common jobs, each costed on both services with the arithmetic shown. Where Api Dojo's cheaper actor does not allow the job, the Apify column uses the actor that does, and where grouping queries lowers the Apify bill, it uses the grouped version.

Keyword alert, checked every 60 seconds

43,200 checks a month; 90% find nothing, 10% find 3 tweets

TwitterAPI.io38,880 × $0.00015 + 4,320 × $0.00045 = $7.78

ApifyUnlimited: 43,200 × $0.016 = $691.20 (V2 rules out monitoring)

Same alert, checked every 15 minutes

2,880 checks; same hit rate

TwitterAPI.io2,592 × $0.00015 + 288 × $0.00045 = $0.52

ApifyUnlimited: 2,880 × $0.016 = $46.08

Research backfill, 1 million tweets

full pages here; one large V2 run there

TwitterAPI.io50,000 pages × $0.003 = $150.00 (Business plan: $78.95)

ApifyV2: 1,000,000 × $0.0004 = $400.00

200 accounts, new posts every hour

about 1 new tweet per account per hour; Apify grouped into 10 OR-queries of 20 handles

TwitterAPI.io144,000 from: searches × $0.00015 = $21.60 (the same if grouped: billing is per tweet returned)

ApifyUnlimited: 7,200 queries × $0.016 = $115.20 ($2,304 one handle per query)

Enrich 100,000 profiles

by user ID in batches of 100+ here; profile URLs there

TwitterAPI.io100,000 × $0.00001 = $1.00 (or $18.00 one by one)

ApifyUser Scraper: 100,000 × $0.004 = $400.00

Export 1 million followers of one account

200 per page here; first ~70 included in the query there

TwitterAPI.io5,000 pages × $0.002 = $10.00

Apify$0.004 + $0.016 + 999,930 × $0.0004 = $399.99

Followers of 1,000 accounts, ~500 each

500,000 followers in total

TwitterAPI.io1,000 × 600 credits (two pages of 200 at 1 credit each, a last page of 100 at 2 each) = $6.00

Apify1,000 × ($0.004 + $0.016 + 430 × $0.0004) = $192.00 (Api Dojo's own example: $0.19)

Replies under 1,000 tweets, ~100 each

5 pages of 20 here; Unlimited runs of 5 queries or fewer there

TwitterAPI.io1,000 × 5 × $0.003 = $15.00

Apify1,000 × ($0.016 + 60 × $0.0004) = $40.00

Look up 10,000 tweets by ID

tweet IDs you already have; Apify in runs of 5 URLs or fewer

TwitterAPI.io10,000 × $0.00015 = $1.50

ApifyUnlimited: 10,000 × ($0.05 + $0.0004) = $504.00

Real-time feed of 6 fixed accounts

push delivery here; one OR-query run every minute there

TwitterAPI.ioTwitter Stream Starter: $29.00

ApifyUnlimited: 43,200 × $0.016 = $691.20

Two patterns stand out. First, anything you repeat on a schedule is dominated by Apify's per-query floor: on Api Dojo's Twitter Scraper Unlimited a check that finds nothing still costs $0.016, so a keyword alert costs about 89 times more there. Polling 200 accounts for new posts costs about 5 times less here, even with the handles grouped into OR-queries on Apify. Second, bulk data that TwitterAPI.io serves in large pages (200 followers, 100+ profiles per request) costs about 30 to 400 times less here, because the per-item price is $0.00001 against $0.0004 or $0.004. Large exports and reply threads cost about 2.7 times less here, since we bill $0.00015 for every tweet returned and Apify $0.0004.

None of the Apify figures include a plan fee. If Twitter data is all you run on Apify, the Starter plan's $19 a month covers $19 of usage, so a workload under $19 still costs $19, and anything unused at the end of the cycle expires. TwitterAPI.io has no plan to buy. Optional subscriptions ($29 to $1,499 a month) add extra credits for steady volume: counting the first-month bonus and 12 monthly returns, $1 buys 1.22× the credits on Builder and 1.9× on Business, which takes the 1-million-tweet backfill above from $150.00 to $78.95.

Alerts and monitoring: where the per-query floor costs most

Most Twitter workloads that run every day are some form of “tell me when something new appears”: brand mentions, a competitor's posts, a keyword, a cashtag. They have three properties that Apify's actors handle poorly. The checks are frequent, most of them find nothing, and you want the result in seconds, not after a run starts, finishes and writes a dataset.

On Apify, Tweet Scraper V2, the actor Api Dojo built for large jobs, rules the job out directly. Its page lists “No monitoring - Don't run the same query repeatedly in short intervals” and requires at least 50 tweets per query, which a minute-by-minute check rarely returns. Twitter Scraper Unlimited allows it, but every check is a $0.016 query event. You can run it on an Apify schedule (docs.apify.com/platform/schedules) (cron syntax, runs at least 10 seconds apart) and have a webhook (docs.apify.com/platform/integrations/webhooks/events) call you when a run succeeds, but the webhook reports that the run finished; your code still reads the dataset to find out whether anything new arrived.

On TwitterAPI.io there are two ways to do it. You can poll advanced search with since_id, paying $0.00015 for an empty check and $0.00015 per new tweet it returns. Or you can add a filter rule and let us run the search and push matches to your webhook or WebSocket, billed at the same rate as polling; see the webhooks guide. For a fixed list of accounts, Twitter Stream pushes new posts for a flat monthly price: $29 for 6 accounts (+$5 per extra account), $79 for 20, $149 for 50, $299 for 150 and $499 for 500.

import os, time, requests

KEY = os.environ["TWITTERAPI_IO_KEY"]
URL = "https://api.twitterapi.io/twitter/tweet/advanced_search"
QUERY = '"your brand" -filter:retweets'  # any advanced-search query
since_id = None  # newest tweet ID already seen

def fetch(params):
    while True:
        r = requests.get(URL, headers={"X-API-Key": KEY},
                         params=params, timeout=30)
        if r.status_code != 429:
            return r
        time.sleep(5)

while True:
    q = QUERY + (f" since_id:{since_id}" if since_id else "")
    params = {"query": q, "queryType": "Latest"}
    newest, complete = since_id, True
    while True:
        r = fetch(params)
        if not r.ok:
            print("check failed:", r.status_code)  # retried on the next loop
            complete = False
            break
        body = r.json()
        for t in body.get("tweets", []):
            print(t["author"]["userName"], t["url"])
            if newest is None or int(t["id"]) > int(newest):
                newest = t["id"]
        # The first run reads one page to set a starting point. Later runs
        # follow next_cursor, so a burst of more than 20 new tweets in a
        # minute is not skipped.
        if since_id is None or not body.get("has_next_page") or not body.get("next_cursor"):
            break
        params["cursor"] = body["next_cursor"]
    if complete:  # a failed check repeats alerts next time, never skips them
        since_id = newest
    # billed per tweet returned: an empty check is the 15-credit minimum ($0.00015)
    time.sleep(60)  # 43,200 checks a month

At one check a minute, that loop costs about $7.78 a month if one check in ten finds three tweets. The same schedule on Twitter Scraper Unlimited is 43,200 query events, $691.20, before any tweets beyond the first 40 per query. Checking every 15 minutes brings Apify to $46.08 and TwitterAPI.io to about $0.52. A busier keyword costs more here, since every returned tweet is billed: at 20 new tweets a minute the TwitterAPI.io loop is $129.60 a month, still below the $691.20 for the query events alone on Apify.

Features and limits

Apify figures from its pricing (apify.com/pricing), Store pricing (docs.apify.com/platform/actors/running/actors-in-store), API (docs.apify.com/api/v2), run-sync (docs.apify.com/api/v2/act-run-sync-get-dataset-items-post), schedules (docs.apify.com/platform/schedules) and MCP (docs.apify.com/platform/integrations/mcp) documentation and the three Api Dojo actor pages; TwitterAPI.io from our pricing, rate limits and MCP server pages. Checked in 2026.

Throughput and run limits

An Apify actor run is a container that pages through X for you. Api Dojo reports 30 to 80 tweets a second per run (49 on search in its own benchmark table), and both of its tweet actors allow one run at a time; V2 accepts up to 5 queries per run. Apify's platform also caps concurrent runs by plan (5 on Free, 32 on Starter, 128 on Scale, 256 on Business), and its API allows 400 run requests a second, so the actor is the bottleneck, not the API.

TwitterAPI.io is limited per request instead: 0.2 requests a second before your first payment, 20 after it, 50 on the Scale plan and 500 on Business, with up to 1,000 on request. At 20 requests a second and 20 tweets a page, that is a ceiling of 400 tweets a second, or about 1.7 million search pages a day. Hitting the limit returns HTTP 429 with no Retry-After header; the code on this page backs off and retries.

Synchronous calls and timeouts

Apify's run-sync-get-dataset-items (docs.apify.com/api/v2/act-run-sync-get-dataset-items-post) endpoint starts a run and returns its dataset in one HTTP call, but if the run takes longer than 300 seconds you get a 408 and must fetch the dataset separately. Large jobs are usually started asynchronously and read back when done. TwitterAPI.io calls are ordinary request and response: each page comes back on its own, so a large job is a loop you can stop, resume from a cursor or spread across workers.

AI agents and MCP

Apify's MCP server (docs.apify.com/platform/integrations/mcp) at mcp.apify.com lets an agent search Apify Store and run actors, so one connection reaches scrapers for many websites, each billed at its own actor price. TwitterAPI.io's MCP server exposes 12 read-only Twitter tools (search, users, followers, replies, trends); it is open source under the MIT license on GitHub and runs locally as an npx package. For an agent that works across For an agent that searches X a lot, a $0.00015 empty search keeps exploratory queries cheap, where each query on Api Dojo's Twitter Scraper Unlimited costs $0.016.

Coverage

Between them, Api Dojo's three actors cover search with advanced operators, profiles, lists, tweet URLs, replies through conversation_id: queries, followers, following and retweeters. TwitterAPI.io adds verified followers, quotes, thread context, a dedicated mentions endpoint, communities, trends, Spaces details and write actions (posting, liking, following through an account you log in), plus filter rules and account monitoring. Neither side needs your X login for reads.

The same request on both

On Apify you send actor input as JSON and get back the dataset; on TwitterAPI.io you call the endpoint and page with a cursor. Here is the same search on both:

# Apify: start Tweet Scraper V2 and wait for its dataset (one call, up to 300 s)
curl -X POST "https://api.apify.com/v2/acts/apidojo~tweet-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchTerms": ["from:nasa"], "sort": "Latest", "maxItems": 100}'

# TwitterAPI.io: the same search, one page (up to 20 tweets) per request
curl -H "X-API-Key: $TWITTERAPI_IO_KEY" \
  "https://api.twitterapi.io/twitter/tweet/advanced_search?query=from%3Anasa&queryType=Latest"

Output fields

The tweet objects are closer than you might expect, because both mirror the shape of X's own data. In Api Dojo's documented output and in TwitterAPI.io's responses these fields share a name: id, url, text, createdAt, likeCount, retweetCount, replyCount, quoteCount, bookmarkCount, lang, isReply, and an author object with userName, followers, following and isBlueVerified. Apify also returns twitterUrl; use url instead. The envelope is the real difference: an actor run returns a flat array, TwitterAPI.io returns tweets (or followers) with has_next_page and next_cursor. Diff a sample of each endpoint you use before you switch.

An adapter that returns what an actor returns

If the rest of your pipeline expects an Apify dataset, keep it and replace only the call. These functions take Tweet Scraper-style input, page through TwitterAPI.io, back off on 429 and return a flat list:

import os, time, requests

KEY = os.environ["TWITTERAPI_IO_KEY"]
BASE = "https://api.twitterapi.io"

def get(path, params, retries=5):
    """GET with exponential back-off on 429."""
    for attempt in range(retries + 1):
        r = requests.get(BASE + path, headers={"X-API-Key": KEY},
                         params=params, timeout=30)
        if r.status_code != 429 or attempt == retries:
            r.raise_for_status()
            return r.json()
        time.sleep(2 ** attempt)

def search_tweets(search_terms, sort="Latest", max_items=100):
    """Takes Tweet Scraper-style input and returns a flat list of
    tweets, like an actor's dataset. max_items applies per term."""
    items = []
    for term in search_terms:
        cursor, got = "", 0
        while got < max_items:
            params = {"query": term, "queryType": sort}  # Latest or Top
            if cursor:
                params["cursor"] = cursor
            body = get("/twitter/tweet/advanced_search", params)
            page = body.get("tweets", [])[: max_items - got]
            items.extend(page)
            got += len(page)
            if not page or not body.get("has_next_page") or not body.get("next_cursor"):
                break
            cursor = body["next_cursor"]
    return items

def followers(user_name, max_items=10_000):
    """Replaces User Scraper with getFollowers: 200 per page, 1 credit each."""
    items, cursor = [], ""
    while len(items) < max_items:
        params = {"userName": user_name, "pageSize": 200}
        if cursor:
            params["cursor"] = cursor
        body = get("/twitter/user/followers", params)
        page = body.get("followers", [])
        items.extend(page)
        if not page or not body.get("has_next_page") or not body.get("next_cursor"):
            break
        cursor = body["next_cursor"]
    return items[:max_items]

if __name__ == "__main__":
    for t in search_tweets(["from:nasa"], max_items=40):
        print(t["id"], t["createdAt"], t["author"]["userName"], t["text"][:60])

Switching checklist

1. List your actor runs for a month: which actor, how many queries, how many items. Apify's billing page shows the events you were charged for.
2. Separate scheduled checks from one-off exports. Scheduled checks are where the per-query floor costs most; move them first.
3. Map each actor input to an endpoint with the table above. For accounts you poll, use from:handle since_id: searches, or Twitter Stream if you need push delivery.
4. Replace maxItems with a cursor loop, and store the last cursor or the newest tweet ID so a job can resume.
5. Diff the tweet and user objects for one sample per endpoint and adjust any fields your parser reads beyond the shared ones.
6. Make a first payment before load testing: unpaid accounts are limited to 0.2 requests a second, paid ones to 20.
7. Run both side by side for a few days and compare row counts and bills before you cancel the Apify plan. Remember unused prepaid Apify usage expires at the end of the cycle.

Price your own workload

Apify is not in our calculator, because its price depends on the actor you pick. To price TwitterAPI.io against the per-call APIs, use the calculator on our Twitter API price comparison. For an Apify actor, the formula is: queries × the actor's query price + items beyond the included ones × its item price, plus a plan fee if your usage is below the plan's included amount. For our full rate card see Twitter API pricing. If most of your requests return full pages of tweets (bulk exports, full timelines), on the Business plan a 20-tweet page costs $0.0016 after 12 monthly payments ($0.002 in the first month).

Both against the official X API

The official API is the third option and the most expensive for reading. X now bills per resource read with no subscriptions: according to its pricing documentation, $0.005 per post read, $0.010 per user read and $0.010 per follower or following read; creating a post costs $0.015, or $0.20 if it contains a URL. Pay-per-use is capped at 3 million post reads per monthly billing cycle, above which you need an Enterprise agreement. New accounts get $20 of credits when they save a first eligible card, plus a match of the first auto-recharge up to $50.

The Business plan row assumes every extra credit from the first-month bonus and 12 monthly returns is used before it expires.

For 1 million followers the gap is wider: $10,000 on the official API at $0.010 per follower read, about $400 on Api Dojo's User Scraper and $10 here. The official API still makes sense when you need a contract with X, posting through X's own consent screen, or data only an authenticated first-party app can read. See TwitterAPI.io vs the official X API for the full comparison.

Quick decision guide