"""Render the X tweet-scraper comparison post from data.json + hand-written prose. Output: site/blog/best-twitter-scraper-apify/index.html (standalone page, site chrome, design.css). Also copies the harness + analysis scripts into raw/tools/ so the raw-data section is self-contained. Not wired into build.py on purpose. """ import json, html, shutil, datetime as dt from pathlib import Path HERE = Path(__file__).resolve().parent ROOT = HERE.parents[1] OUTDIR = ROOT / "site/blog/best-twitter-scraper-apify" RAW = OUTDIR / "raw" DATA = json.loads((OUTDIR / "data.json").read_text()) R = DATA["runs"] ORDER = DATA["order"] CROSS = DATA["cross"] LOOK = DATA["lookups"] ASSET_V = "6dd8b56bcc" DATA_DATE = "2026-09-08" POST_DATE = "2026-09-09" # ---- census facts used for the selection (snapshot 2026-09-08; 6-week window = 2026-07-28 → 09-08) SEL = { "apidojo/tweet-scraper": dict(short="apidojo / Tweet Scraper V2", why="Widest user base and the oldest listing", users=7459, users_prev=7039, total_users=97945, created="2023-11-24", success=95.4, reviews=195, rating=3.94, listed=0.0004, runs30=4653854, rank="#1 for “tweet scraper”, “twitter scraper” and “twitter” on every day we have"), "kaitoeasyapi/twitter-x-data-tweet-scraper-pay-per-result-cheapest": dict(short="kaitoeasyapi / Tweet Scraper (“cheapest”)", why="Second-largest user base; “cheapest” is in its slug", users=4004, users_prev=3767, total_users=23823, created="2024-10-14", success=99.6, reviews=83, rating=4.22, listed=0.00025, runs30=2633111, rank="#2 for “tweet scraper”, #3 for “twitter scraper”"), "apidojo/twitter-scraper-lite": dict(short="apidojo / Twitter Scraper Unlimited", why="Highest rating among the high-volume actors", users=1957, users_prev=2123, total_users=33132, created="2024-05-09", success=99.8, reviews=101, rating=4.76, listed=0.0004, runs30=1301762, rank="#2 for “twitter scraper”"), "xquik/x-tweet-scraper": dict(short="xquik / X Tweet Scraper", why="Fastest-growing and youngest of the fifteen; lowest listed price", users=1006, users_prev=723, total_users=3626, created="2026-03-28", success=99.7, reviews=14, rating=4.55, listed=0.00015, runs30=1015916, rank="#4 for “tweet scraper” (was #5 on 28 July), #7 for “twitter scraper”"), "danek/twitter-scraper": dict(short="danek / Twitter Scraper", why="Most runs of any actor in the set, with a 100.0% 30-day success rate", users=576, users_prev=664, total_users=7737, created="2024-03-28", success=100.0, reviews=20, rating=4.43, listed=0.0003, runs30=8716460, rank="#3 for “tweet scraper”, #6 for “twitter scraper”"), "scrape.badger/twitter-tweets-scraper": dict(short="scrape.badger / X Tweet Scraper", why="xquik’s price twin: same listed price, and since 10 August the same title", users=401, users_prev=488, total_users=2673, created="2025-05-17", success=99.6, reviews=17, rating=3.30, listed=0.00015, runs30=1380444, rank="#6 for “tweet scraper”, #9 for “twitter scraper”"), } LEFT_OUT = [ ("api-ninja/x-twitter-advanced-search", "398 users, rated 4.86 from 45 reviews, but $0.015 per tweet: 100× the cheapest actor here. It is a search-only actor and deserves its own test at its own price point."), ("scraper_one/x-profile-posts-scraper + x-posts-search", "417 and 313 users. The publisher splits profile posts and search into two actors; you would need both for our three jobs."), ("altimis/scweet", "192 users. It entered our candidate list only on the latest snapshot, so we have no six-week history for it."), ("automation-lab/twitter-scraper", "145 users, 92.6% success, down from 194 users six weeks ago."), ("maximedupre/twitter-scraper", "83 users; its 30-day success rate swung from 50% to 94% inside the six-week window."), ("scrapesmith, igolaizola, fastcrawler", "69, 50 and 30 users; the last two run at 87% and 90% success."), ] # ---- input surface, read from each actor's published input schema (default build, 2026-09-08) FILTERS = { "apidojo/tweet-scraper": dict(fields=26, required="none", modes="URLs, search terms, handles, conversation ids in one run", dates="start / end date fields", lang="yes", engagement="min retweets / likes / replies", media="image, video, quote only", verified="verified, Blue", geo="near, radius, geocode, place id", sort="Top, Latest, both", multi="yes", notes="Clean field names; a custom JavaScript map function for reshaping output."), "kaitoeasyapi/twitter-x-data-tweet-scraper-pay-per-result-cheapest": dict(fields=48, required="maxItems", modes="tweet ids, one query string, or a list of search terms", dates="since_time / until_time as unix seconds, or since_id / max_id", lang="yes", engagement="min and max retweets / likes / replies", media="12 filter:* switches (images, videos, spaces, links, news…)", verified="filter:blue_verified", geo="near, within, geocode", sort="Latest, Top, Photos, Videos", multi="yes", notes="Every X search operator is its own field, named after the operator (filter:blue_verified, -min_faves). No profile mode: use from:."), "apidojo/twitter-scraper-lite": dict(fields=8, required="none", modes="search terms, handles, URLs", dates="start / end date fields", lang="no", engagement="no", media="no", verified="no", geo="no", sort="Top, Latest, both", multi="yes", notes="The small sibling of Tweet Scraper V2: same output, a fraction of the filters."), "xquik/x-tweet-scraper": dict(fields=100, required="none", modes="12 modes (search, profile tweets/replies/media/likes, list, article, replies, quotes…) or auto-route", dates="since / until (hidden fields), plus the operator set", lang="yes", engagement="min and max retweets / likes / replies", media="the same 12 filter:* switches as kaito", verified="filter:blue_verified", geo="near, within, geocode", sort="Latest, Top, both", multi="yes", notes="Roughly a third of the 100 fields are aliases: the item cap alone can be spelled maxItems, maxResults, max_results, resultsLimit, resultsCount, numberOfTweets, maxPosts or max_posts. Output shape is configurable (legacy / rich / raw; camelCase / snake_case; nested / flat)."), "danek/twitter-scraper": dict(fields=7, required="max_posts", modes="one username, or one query, or post ids", dates="no field; put operators in the query", lang="no field", engagement="no field", media="search_type Media", verified="no", geo="no", sort="Top, Latest, Media, People, Lists", multi="no: one target per run", notes="Seven flat fields. Which ones apply depends on what you fill in; the schema does not say."), "scrape.badger/twitter-tweets-scraper": dict(fields=6, required="mode", modes="8 modes, chosen from a dropdown whose values are UI labels (Get a Few Tweets, Advanced Search)", dates="no field; put operators in the query", lang="no field", engagement="no field", media="query_type Media", verified="no", geo="no", sort="Top, Latest, Media", multi="no: one query per run", notes="No profile mode: use from:. The mode string must match the label exactly."), } LIKED = { "apidojo/tweet-scraper": (["The richest filter set of the six, with clean names.", "Retweets carry the original post as a nested object.", "Profile job returned the pinned post and flagged it."], ["Long-form posts are cut at roughly 280 characters: 1 of 25 came back whole.", "Slowest on the search job bar one, and the most expensive per tweet.", "Profile output is not sorted; two sources are concatenated."]), "kaitoeasyapi/twitter-x-data-tweet-scraper-pay-per-result-cheapest": (["Full text on long-form posts.", "Charged us $0.00022 per tweet against a listed $0.00025.", "Same record shape as apidojo, so a drop-in swap for many pipelines."], ["Padded a one-tweet lookup with 14 “mock_tweet” rows and billed all 15.", "Returned 60 rows when asked for 50, and billed 60.", "No profile mode: from:apify is a search, so no retweets, and replies dominate. No source field."]), "apidojo/twitter-scraper-lite": (["Highest-rated actor in the set (4.76 from 101 reviews).", "Same record shape and same freshness as its big sibling."], ["A $0.05 fee for every single-tweet URL, and $0.016 per search or profile query on top of the per-tweet price.", "Same ~280-character cut on long-form posts.", "Dropped the pinned post that its sibling returned."]), "xquik/x-tweet-scraper": (["Fastest single-tweet lookup by a wide margin (1.8 s).", "Full text on long-form posts, and the only actor that flags them (isNoteTweet).", "Most fields per record (57–60), with media URLs flattened for CSV users."], ["Slowest on the search job (34 s).", "The only actor here where you also pay platform usage: +8% on our search run.", "Retweets are not flagged and the original post is not included, so 10 of 14 retweets arrive as 140-character stubs.", "100 input fields, many of them aliases."]), "danek/twitter-scraper": (["Smallest records (1.4–1.9 KB) and among the fastest.", "Retweets carry the original post in full.", "Charged $0.00028 against a listed $0.0003."], ["Three different record shapes across the three jobs (search, profile, lookup).", "No url field; views is a string.", "Two duplicate rows in a 50-post profile pull."]), "scrape.badger/twitter-tweets-scraper": (["Cheapest all-in on every job: $0.14 per 1,000 tweets, and the fastest search run (15 s).", "Full text on long-form posts.", "Flat snake_case records, easy to load into a table."], ["No profile mode: from:apify is a search, so no retweets and mostly replies.", "No url field.", "Rated 3.30 from 17 reviews, the lowest in the set."]), } CANON_LABELS = [("id", "Tweet id"), ("url", "Tweet URL"), ("text", "Text"), ("created_at", "Created at"), ("lang", "Language"), ("author_username", "Author handle"), ("author_name", "Author name"), ("author_id", "Author id"), ("author_followers", "Author followers"), ("likes", "Likes"), ("reposts", "Retweets"), ("replies", "Replies"), ("quotes", "Quotes"), ("views", "Views"), ("bookmarks", "Bookmarks"), ("is_reply", "Reply flag"), ("is_repost", "Retweet flag"), ("is_quote", "Quote flag"), ("conversation_id", "Conversation id"), ("media", "Media"), ("urls", "Links"), ("hashtags", "Hashtags"), ("is_long", "Long-form flag"), ("source", "Source app")] def e(s): return html.escape(str(s)) def short(slug): return SEL[slug]["short"] def store(slug): return f"https://apify.com/{slug}" def _safe(part): # mirrors actor_pages._safe — the function that writes the actor pages out = "".join(c if (c.isalnum() or c in "-_") else "-" for c in part.lower()) return out.strip("-") or "actor" def page(slug): u, n = slug.split("/") return f"/actors/{_safe(u)}/{_safe(n)}.html" def usd(v, digits=4): return "—" if v is None else f"${v:,.{digits}f}" def num(v): return "—" if v is None else f"{v:,}" def run(slug, task): return R.get(f"{slug}|{task}") def actor_link(slug, with_slug=False): out = f'{e(short(slug))}' if with_slug: out += f' ({e(slug)})' return out def th(cols): return "" + "".join(f"{c}" for c in cols) + "" def table(cols, rows, cls="results-table", note=None): body = "".join("" + "".join(f"{c}" for c in r) + "" for r in rows) out = f'
{th(cols)}{body}
' if note: out += f'

{note}

' return out import re as _re def strip_tags(h): return _re.sub(r"<[^>]+>", "", h).replace(" ", " ") FAQ = [ ("Is it legal to scrape Twitter (X)?", "We are not lawyers and this is not legal advice. The facts: every tweet in this test is public, and none of the six scrapers asked for an X login. X’s Terms of Service prohibit scraping without permission, which is a contract between X and its account holders. In the United States, hiQ Labs v. LinkedIn (2022) held that scraping publicly available data does not violate the Computer Fraud and Abuse Act. Tweets contain personal data, so storing or processing them can fall under GDPR or CCPA regardless of how they were collected. What you may do with the data depends on where you are and what you do with it; ask counsel for your case."), ("Can I scrape tweets without the X API?", "Yes. That is what all six actors here do: none asked for an API key, a login or a cookie in the jobs we ran. The trade is that there is no contract with X about rate limits or continuity; the store’s public 30-day success rates for the six ran from 95.4% to 100%."), ("How does this compare with X API pricing?", "X’s own API is priced per usage: you buy credits and each request deducts from them (docs.x.com, September 2026); the current per-request rates are on X’s pricing page. At the per-tweet prices we were charged, 10,000 tweets cost between $1.40 (scrape.badger) and $4.00 (apidojo), with no credit purchase and no subscription. The X API returns the platform’s own data under its own terms; the scrapers return what a logged-out visitor sees."), ("Is there a free Twitter scraper on Apify?", "Apify’s free plan includes $5 of usage credit every month, and all six scrapers run on it. At the prices we were charged, $5 buys between 12,500 and 35,000 tweets a month. None of the six is free beyond that credit; a “free” Twitter scraper on the store usually means a free trial or that same platform credit."), ("Which Twitter scraper on Apify is the cheapest?", "As charged to our account: scrape.badger $0.14 per 1,000 tweets, xquik $0.16 including the platform usage it bills to the user, kaitoeasyapi $0.22, danek $0.28, apidojo $0.40. Watch the minimums: kaitoeasyapi billed 15 rows for a single-tweet lookup, and apidojo’s Twitter Scraper Unlimited charges $0.05 for every single-tweet URL and $0.016 per search or profile query."), ("Which scrapers return long-form (note) tweets in full?", "kaitoeasyapi, xquik, danek and scrape.badger returned a 1,334-character post whole, in search and on a direct lookup. apidojo’s Tweet Scraper V2 and Twitter Scraper Unlimited returned the first 277 characters. In our 100-tweet search sample, 25 tweets were long-form."), ("How do I scrape all tweets from an account?", "A timeline actor (apidojo V2, danek, or xquik in profileTweets mode) pages back through the profile the way X shows it; apidojo’s own schema notes that X stops the timeline at roughly 800 posts. For older posts, run a search with date operators (from:user since:… until:…) in windows; apidojo V2, kaitoeasyapi, xquik and scrape.badger all accept those operators. Sort the output yourself: two of the timeline actors did not return it in date order."), ("Which scraper has the most filters?", "apidojo’s Tweet Scraper V2, with 26 named fields: date range, language, minimum retweets/likes/replies, image/video/quote filters, verified and Blue filters, geo. kaitoeasyapi and xquik expose X’s full search-operator set as individual fields instead. danek and scrape.badger take a single query string and leave the operators to you."), ("Which Twitter scraper is the fastest?", "On the 100-tweet search, scrape.badger finished in 15 seconds and xquik in 34; the others took 18 to 25. On a single-tweet lookup xquik answered in under 2 seconds, danek and scrape.badger in 3 to 6, apidojo in 4 to 16. All timings include the actor’s cold start."), ] # ---------------------------------------------------------------- sections def sec_tldr(): return f"""
The short answer

Details and every number behind this list are in section 11; how we tested is in section 2.

""" def sec_faq(): items = "".join(f"

{e(q)}

{a}

" for q, a in FAQ) return f"""

13. Questions people ask about scraping Twitter (X)

Short answers from this test, for the questions that come up most in search.

{items}
""" def sec_time(): links = ", ".join(f'{e(short(s))}' for s in ORDER) return f"""
A note on time

Everything on this page was true on 8 September 2026. By the time you read it, some of it will be stale and some of it may simply be wrong. These actors change often, and a few of them change daily: in the six weeks before this test, xquik renamed its listing twice, apidojo renamed Tweet Scraper V2 once, scrape.badger and xquik each changed their pricing once, apidojo’s two actors shipped a new build on every one of the 18 days we looked, xquik shipped 12, kaitoeasyapi 5, scrape.badger 2, and danek did not change once. We record every listing in the store every day. If a number here matters to you, open the actor’s page on this site and follow it; you will see the change the day it happens. The six: {links}.

""" def sec_selection(): rows = [] for s in ORDER: f = SEL[s] g = (f["users"] - f["users_prev"]) / f["users_prev"] * 100 gcls = "up" if g > 0 else "down" rows.append([actor_link(s, True) + f'{e(f["why"])}', f'{f["users"]:,}', f'{g:+.0f}%', f'{f["created"]}', f'{f["success"]:.1f}%', f'{f["rating"]:.2f} / {f["reviews"]}', f'${f["listed"]:.5f}']) t = table(["Actor and why it is in", "Users, 30 d", "6-week change", "First published", "Success, 30 d", "Rating / reviews", "Listed price"], rows, note=f"Census snapshot of {DATA_DATE}. “6-week change” compares monthly users on 28 July and 8 September. “First published” is the actor’s creation date from the Apify API. Success is the store’s public 30-day run statistic. Listed price is the primary pay-per-event price shown on the store listing.") left = "".join(f"
  • {e(a)} — {b}
    • " for a, b in LEFT_OUT) return f"""

    1. How we chose the six tweet scrapers

    The census behind this site tracks every X (Twitter) actor on the Apify Store; 53 of them have at least 30 monthly users. We removed everything that is not a tweet scraper: profile and user scrapers, follower scrapers, trend scrapers, list scrapers, reply-only scrapers, a video downloader. Fifteen remained.

    Ranking the fifteen by monthly users and taking the top six would put four actors from two publishers on the page and tell you little. We took one actor per reason instead.

    {t}

    Two of the six share a name

    Since 10 August the listings of xquik/x-tweet-scraper and scrape.badger/twitter-tweets-scraper carry the same title, character for character: X Tweet Scraper | $0.15/1K Tweets | Pay-Per-Result. scrape.badger’s is the older listing (May 2025 against March 2026). Our title history starts on 24 July, so we cannot say which wording came first. On 24 July xquik’s title still read From $0.15/1K Tweets | Pay-Per Result; it changed on 31 July and again on 10 August and arrived at the identical string. We report this because a buyer scanning the store sees two identical names and has no way to tell them apart. The rest of this page is one way.

    Who we left out, and why

    """ def inputs_block(task): parts = [] for s in ORDER: r = run(s, task) if not r: continue parts.append(f"
    {e(short(s))}
    {e(json.dumps(r['input'], indent=1))}
    ") return '
    ' + "".join(parts) + "
    " def sec_method(): canon = ", ".join(l for _, l in CANON_LABELS) return f"""

    2. What we asked each scraper to do

    Three jobs, the same for everyone.

    1. Keyword search. The phrase web scraping, newest first, 100 tweets.
    2. Profile timeline. The 50 newest posts by @apify.
    3. Single-tweet lookup. Two tweets by id: a post with an image and some engagement, and a long-form post of 1,334 characters.

    Rules

    What we expected back

    A tweet record with, at minimum: {e(canon)}. Section 7 shows who returns which.

    Exact inputs, keyword search (6){inputs_block('search')}
    Exact inputs, profile timeline (6){inputs_block('profile')}
    Exact inputs, single-tweet lookups (12){inputs_block('lookup_media')}{inputs_block('lookup_note')}
    """ def glance_table(task, label): lookup = task.startswith("lookup") rows = [] for s in ORDER: r = run(s, task) if not r: continue it = r["items"] n = it["n"] real = it.get("real_items", n) ncell = f'{n}' + (f' ({it["filler"]} filler)' if it.get("filler") else "") billing = "user pays" if r["billing_model"] == "USER" else "publisher pays" row = [actor_link(s), ncell, f'{r["duration_s"]:.1f} s', f'{usd(r["usd_total"])}'] if not lookup: row.append(f'{usd(r["usd_per_1k"], 3)}') row += [f'${r["listed_price_per_item"]:.5f}', billing, f'{r["bytes_per_item"]:,}', f'{r["keys_per_item"]}'] rows.append(row) cols = ["Actor", "Rows", "Time", "Charged"] + ([] if lookup else ["Per 1,000 rows"]) + ["Event price applied", "Platform usage", "Bytes / row", "Fields / row"] return f"

    {label}

    " + table(cols, rows) def sec_glance(): total = sum(v["usd_total"] or 0 for v in R.values()) return f"""

    3. Results at a glance

    Every run finished with status SUCCEEDED. Total charged for all 24 runs: {usd(total, 2)}.

    {glance_table('search', 'Keyword search: 100 tweets for “web scraping”')} {glance_table('profile', 'Profile timeline: 50 newest posts by @apify')} {glance_table('lookup_media', 'Single tweet, the one with an image')} {glance_table('lookup_note', 'Single tweet, the long-form one')}

    “Charged per row” is the per-event price the platform applied to our run, which is not always the listed price (section 9). “Platform usage” says who pays compute and storage for the run: for five actors the publisher absorbs it, for xquik the user pays it on top of the per-tweet price. “Fields / row” is the average number of top-level keys per record.

    """ def sec_search(): x = CROSS["search"] lf = x["longform_capture"] rows = [] for s in ORDER: r = run(s, "search") it = r["items"] l = lf[s] rows.append([actor_link(s), f'{l["full_text"]} / {l["long_ids_seen"]}', f'{it["text_max"]:,}', f'{r["duration_s"]:.1f} s', f'{usd(r["usd_per_1k"], 3)}']) ma = x["metric_agreement"] return f"""

    4. Scraping tweets by keyword: the same 100 tweets, different text and different bills

    All six actors returned the same tweets. The union of the six result sets is {x["union"]} ids; {x["in_all"]} of them appear in all six outputs, and no id appears in only one. The newest tweet is the same across all six (21:11:54 UTC, 62 minutes before the runs). View counts are identical for {ma["views"]["identical"]} of {ma["views"]["ids"]} shared tweets. Whatever these actors do behind the scenes, they read the same source at the same moment, and on this job retrieval is not where they differ.

    Where they differ is the text. X allows posts far beyond 280 characters (long-form, or “note” tweets). 25 of the 100 tweets in this sample are long-form. Four actors return them whole. apidojo’s two actors return the first ~280 characters and stop, on 24 of the 25.

    {table(["Actor", "Long-form posts returned in full", "Longest text, chars", "Time", "Per 1,000"], rows, note="“In full” means the text is at least 95% as long as the longest version any actor returned for the same id. The long-form set is the 25 ids xquik flags as isNoteTweet; the other actors do not flag them, but four of them return the same 1,000–2,000-character bodies.")}

    Speed ran from 15 s (scrape.badger) to 34 s (xquik) for the same 100 tweets. Price per 1,000 ran from $0.14 (scrape.badger) to $0.40 (both apidojo actors). Records ran from 1.9 KB (danek) to 6.1 KB (xquik) each; the difference is nested author objects, entity lists and, in xquik’s case, about thirty flattened author* fields per row.

    """ def sec_profile(): x = CROSS["profile"] base = "apidojo/tweet-scraper" rows = [] for s in ORDER: r = run(s, "profile") it = r["items"] replies = it["reply_flagged"] if it["reply_flagged"] is not None else f'{it["reply_by_text"]}*' rt_note = "" if it["repost_by_text"]: rt_note = f' ({it["repost_truncated"]} truncated, original attached for {it["repost_with_original"]})' rows.append([actor_link(s), f'{it["n"]}' + (f' ({it["dups"]} dup)' if it["dups"] else ""), f'{it["repost_by_text"]}{rt_note}', f'{replies}', f'{it["newest"][:16].replace("T", " ")}', f'{it["oldest"][:10]}', f'{it["newest_first_pct"]:.0f}%', f'{x["matrix"][s][base]}', f'{r["duration_s"]:.1f} s']) return f"""

    5. Profile timeline: “the 50 newest posts by @apify” means five different things

    This is the job where the six stop agreeing. The union of the six outputs is {x["union"]} distinct posts; only {x["in_all"]} of them appear in all six, and {x["only_one"]} appear in exactly one.

    {table(["Actor", "Rows", "Retweets", "Replies", "Newest post (UTC)", "Oldest post", "Sorted newest-first", "Overlap with apidojo V2", "Time"], rows, note="Retweets are rows whose text starts with “RT @”. Replies use the actor’s own flag; * marks actors without a reply flag, where we counted texts that start with “@”. “Sorted newest-first” is the share of consecutive rows in descending date order. Overlap is the number of ids in common with apidojo/tweet-scraper’s 50.")}

    None of these is wrong. They are different definitions of a profile pull. If you need what a visitor sees on the profile page, use a timeline actor and sort. If you need only original posts, xquik’s mode does that in one call. If you need replies, the two search-based actors give you mostly that.

    """ def sec_lookups(): rows = [] for s in ORDER: m, n = LOOK["lookup_media"][s], LOOK["lookup_note"][s] rm, rn = run(s, "lookup_media"), run(s, "lookup_note") fill = f' +{m["filler"]} filler rows' if m and m.get("filler") else "" rows.append([actor_link(s), f'{m["text_len"]}{fill}', f'{n["text_len"]:,}', f'{num(m["likes"])} / {num(m["views"])}', f'{rm["duration_s"]:.1f} s / {rn["duration_s"]:.1f} s', f'{usd(rm["usd_total"])} / {usd(rn["usd_total"])}']) mock = "From KaitoEasyAPI, a reminder: Our API pricing is based on the volume of data returned. However, to ensure we can cover our costs on the Apify platform, we have a minimum charge of $X per API call, even if the response contains no results. Thus, we returned N pieces of mock data. We will monitor and adjust the size of N based on the infrastructure costs incurred by Apify." return f"""

    6. Single-tweet lookup: one id, six answers

    {table(["Actor", "Image post: text, chars", "Long-form post: text, chars", "Likes / views (image post)", "Time (image / long-form)", "Charged (image / long-form)"], rows)}
    """ def sec_fields(): rows = [] for k, label in CANON_LABELS: cells = [label] for s in ORDER: f = run(s, "search")["items"]["fill"][k] if f is None: cells.append('—') elif f >= 99: cells.append('✓') else: cells.append(f'✓ when set') rows.append(cells) heads = ["Field"] + [e(short(s).split(" / ")[0]) + "
    " + e(short(s).split(" / ")[1]) + "" for s in ORDER] return f"""

    7. Field coverage

    Read from the 100 search rows of each actor, after mapping every actor’s names onto one list. “✓ when set” means the key is present only when it has a value (an empty media list is omitted rather than written as []). “—” means the actor never returns the field under any name.

    {table(heads, rows, cls="results-table fields")}
    """ def sec_filters(): rows = [] for s in ORDER: f = FILTERS[s] rows.append([actor_link(s), f'{f["fields"]}', f["required"], f["modes"], f["dates"], f["lang"], f["engagement"], f["media"], f["sort"], f["multi"]]) notes = "".join(f"
  • {e(short(s))}. {FILTERS[s]['notes']}
    • " for s in ORDER) return f"""

    8. Filters and the shape of the input

    Read from each actor’s published input schema on 8 September 2026. We did not exercise every filter; this is what the schema offers.

    {table(["Actor", "Input fields", "Required", "Targets / modes", "Date range", "Language", "Engagement filters", "Media filters", "Sort", "Several queries per run"], rows, cls="results-table wide")}
    """ def sec_cost(): rows = [] for s in ORDER: tot = sum((run(s, t) or {}).get("usd_total") or 0 for t in ("search", "profile", "lookup_media", "lookup_note")) listed = SEL[s]["listed"] charged = run(s, "search")["listed_price_per_item"] model = {"apidojo/tweet-scraper": "flat per row", "kaitoeasyapi/twitter-x-data-tweet-scraper-pay-per-result-cheapest": "flat per row, padded on empty or tiny results", "apidojo/twitter-scraper-lite": "per query + per row tiers + per single-tweet URL", "xquik/x-tweet-scraper": "flat per row + platform usage billed to you", "danek/twitter-scraper": "flat per row", "scrape.badger/twitter-tweets-scraper": "flat per row"}[s] rows.append([actor_link(s), f'${listed:.5f}', f'${charged:.5f}', model, f'{usd(tot, 4)}']) x = run("xquik/x-tweet-scraper", "search") plat = x["platform_usage_usd"] return f"""

    9. Cost: what each Twitter scraper actually charged

    {table(["Actor", "Listed per tweet", "Applied to our run", "Pricing model", "Our total, 4 runs"], rows)}
    """ def sec_liked(): cards = [] for s in ORDER: good, bad = LIKED[s] cards.append(f"""

    {actor_link(s, True)}

    Liked
      {''.join(f'
    • {g}
      • ' for g in good)}
    Did not like
      {''.join(f'
    • {b}
      • ' for b in bad)}
    """) return f"""

    10. What we liked and what we did not

    {''.join(cards)}
    """ def sec_verdict(): return f"""

    11. Best Twitter (X) scraper on Apify, by use case

    If you need

    There is no single winner, and we did not expect one. The six were chosen to be different, and they are. The one result we did not expect is that the oldest and most-used actor in the category, with 98,000 lifetime users, is the one that loses most of a long-form post, on a direct lookup as well as in search.

    Disclosure

    apifystats publishes no X actor and has no commercial relationship with any of the six publishers. None of them was contacted before or during the test. We paid list price from our own Apify account; the actors were not told they were being compared. This is the first post in a series; the method will change as we learn, and we will say so when it does.

    """ def sec_raw(): rows = [] for s in ORDER: d = s.replace("/", "__") cells = [actor_link(s)] for t in ("search", "profile", "lookup_media", "lookup_note"): if run(s, t): cells.append(f'input · run · rows') else: cells.append("—") rows.append(cells) return f"""

    12. Raw data

    Everything the actors returned, untouched, plus the run objects Apify keeps for each run (timing, memory, charged events, applied pricing) and the exact input we sent. One directory per actor. If you find a mistake in our reading of it, tell us and we will correct the page.

    {table(["Actor", "Keyword search", "Profile timeline", "Lookup: image post", "Lookup: long-form post"], rows)}

    Method notes and limits

    """ CSS = """ """ def main(): tools = RAW / "tools" tools.mkdir(exist_ok=True) SKILL = ROOT / ".claude/skills/apifystats-comparison-post/scripts" for f in ("common.py", "run_tests.py", "refresh_runs.py", "analyze.py", "research.py", "census_candidates.py", "fetch_schemas.py", "check_links.py"): shutil.copy(SKILL / f, tools / f) for f in ("plan.json", "mapping.py", "build_post.py"): shutil.copy(HERE / f, tools / f) total = sum(v["usd_total"] or 0 for v in R.values()) n_rows = sum(v["items"]["n"] for v in R.values()) title = "Best Twitter (X) Scrapers on Apify, Tested in 2026" h1 = "Best Twitter (X) scrapers on Apify, tested: six tweet scrapers, the same three jobs, every byte kept" desc = "Six Apify tweet scrapers, same three jobs, same second: search, profile timeline, single tweet. Speed, cost as charged, full-text capture. Raw data included." url = "https://apifystats.com/blog/best-twitter-scraper-apify/" ld = {"@context": "https://schema.org", "@graph": [ {"@type": "Article", "headline": title, "alternativeHeadline": h1, "description": desc, "datePublished": POST_DATE, "dateModified": POST_DATE, "url": url, "mainEntityOfPage": url, "author": {"@type": "Organization", "name": "apifystats", "url": "https://apifystats.com/"}, "publisher": {"@type": "Organization", "name": "apifystats", "url": "https://apifystats.com/"}, "about": [{"@type": "SoftwareApplication", "name": short(s2), "url": store(s2)} for s2 in ORDER]}, {"@type": "BreadcrumbList", "itemListElement": [ {"@type": "ListItem", "position": 1, "name": "apifystats", "item": "https://apifystats.com/"}, {"@type": "ListItem", "position": 2, "name": "Blog", "item": "https://apifystats.com/blog/"}, {"@type": "ListItem", "position": 3, "name": title, "item": url}]}, {"@type": "FAQPage", "mainEntity": [{"@type": "Question", "name": q, "acceptedAnswer": {"@type": "Answer", "text": strip_tags(a)}} for q, a in FAQ]}]} toc = [("selection", "How we chose"), ("method", "What we asked"), ("glance", "At a glance"), ("search", "Search"), ("profile", "Profile"), ("lookup", "Single tweet"), ("fields", "Fields"), ("filters", "Filters"), ("cost", "Cost"), ("liked", "Liked / not"), ("verdict", "Best by use case"), ("raw", "Raw data"), ("faq", "FAQ")] body = f""" {e(title)} — apifystats {CSS}
    apifystats
    Log in Start free
    Deep comparison · No. 1 · X (Twitter) tweet scrapers · September 2026

    {e(h1)}

    There are hundreds of Twitter (X) scrapers on the Apify Store and no way to tell them apart from their listings. We picked six tweet scrapers, each for a different reason, gave them the same three jobs at the same second, and kept every byte they returned. This page explains how the six were chosen, what we sent, what came back, and where they differ. The raw data is at the bottom.

    apifystats · published {POST_DATE} · runs on 2026-09-08 · census data of {DATA_DATE}
    {''.join(f'{n}' for a, n in toc)}
    6
    actors, from 5 publishers
    24
    runs, all SUCCEEDED
    {n_rows:,}
    rows returned
    {usd(total, 2)}
    charged in total
    {sec_tldr()} {sec_time()} {sec_selection()} {sec_method()} {sec_glance()} {sec_search()} {sec_profile()} {sec_lookups()} {sec_fields()} {sec_filters()} {sec_cost()} {sec_liked()} {sec_verdict()} {sec_raw()} {sec_faq()}
    """ (OUTDIR / "index.html").write_text(body) print(f"wrote {OUTDIR/'index.html'} ({len(body):,} bytes); rows={n_rows} total=${total:.4f}") if __name__ == "__main__": main()