WEIR

Check Twitter Follow and Retweet Tasks for Quests (2026)

How to check Twitter follow, repost, reply and quote tasks in a quest or giveaway: what each check costs, a tested Python script, and why likes are out.


Published · Updated · 7 min read

Cover image: What a quest can check on X

To check Twitter follow and retweet tasks, match each entrant against public lists: the post's reposters, replies and quotes, and who the entrant follows.

Likes are the exception. X (Twitter) made them private in June 2024, so no public list shows who liked a post.

This guide is for teams running quests and giveaways. We run Weir, the API used here. This call lists who reposted a post, up to 100 at a time:

curl "https://api.weirapp.io/v1/x/posts/2116179061458555063/retweeters?limit=100" \
  -H "Authorization: Bearer $WEIR_API_KEY"
  1. Fix the rulesName the tasks and the deadline up front.
  2. Snapshot and matchRead the lists once at the deadline, then match entrants.
  3. Check follows lastFor the winners, or from the brand's newest followers.

What each X task check needs and costs

X has no checker of its own: its Help Center points you to a post's Reposts and Quote posts tabs.

Every task but a like leaves a public list, though. Through Weir, each call costs 1 credit plus 1 per account or post, as of November 2026.

Table of five X tasks: what to read for each, the credits and the main limit
Weir's prices and limits, checked 17 November 2026
  • X's app stops at 100 reposters, its Help Center says. On 17 November 2026, Weir paged 541 reposters over 9 pages of a post with 8,790 reposts.
  • Quotes come from X's search. X's promotion guidelines warn that some entries "may be filtered from search for quality."

Check who retweeted and replied with a Python script

This script reads each list once, saves it as a snapshot and matches your entrants. It needs only Python's standard library and a free Weir key in WEIR_API_KEY.

import hashlib, json, os, re, sys, time, urllib.parse, urllib.request
AUTH = {"Authorization": "Bearer " + os.environ["WEIR_API_KEY"]}
TASKS = {"reposted": "retweeters", "replied": "replies", "quoted": "quotes"}  # task: endpoint
REQUIRED = ["reposted", "replied"]  # your rules; add "quoted" if they ask for a quote
spent = [0]  # credits charged so far

def get(path, query):  # an error stops the run, such as 402 (no credits) or 429
    url = f"https://api.weirapp.io/v1/x/posts/{path}?{urllib.parse.urlencode(query)}"
    with urllib.request.urlopen(urllib.request.Request(url, headers=AUTH), timeout=60) as r:
        spent[0] += int(r.headers.get("x-credits-charged", 0))
        return json.load(r)

This part pages through one list until meta.nextCursor is null:

def who_did(post_id, endpoint, max_pages=20):
    found, query = {}, {"limit": 20 if endpoint == "quotes" else 100}
    for page in range(1, max_pages + 1):
        data = get(f"{post_id}/{endpoint}", query)
        for item in data["data"]:  # reposters are accounts; replies and quotes are posts
            if endpoint != "replies" or item["inReplyToId"] == post_id:  # direct replies only
                user = item.get("author", item)
                found[user["id"]] = user["username"].lower()
        if not data["meta"]["nextCursor"]:
            return found, page
        query["cursor"] = data["meta"]["nextCursor"]
        time.sleep(7)  # stays under the free plan's 30 requests a minute
    sys.exit(f"{endpoint}: still going after {max_pages} pages; raise max_pages")

This part saves each list as it's read, so a stopped run picks up where it left off:

link = re.search(r"\.com/(\w+)/status/(\d+)", sys.argv[1])
author, post_id = (link[1].lower(), link[2]) if link else ("", sys.argv[1])
saved = f"snapshot-{post_id}.json"
snap = json.load(open(saved)) if os.path.exists(saved) else {
    "taken": time.strftime("%Y-%m-%d %H:%M UTC", time.gmtime())}
for task in REQUIRED:
    if task not in snap:
        found, pages = who_did(post_id, TASKS[task])
        snap[task] = {i: h for i, h in found.items() if h != author}  # not the post's author
        json.dump(snap, open(saved, "w"))
        print(f"{task}: {len(snap[task])} found on {pages} page(s)")
print(f"Snapshot {snap['taken']}, credits this run: {spent[0]}")

The last part checks your entrants file, one handle or id per line:

did = {task: set(snap[task]) | set(snap[task].values()) for task in REQUIRED}  # ids, handles
if len(sys.argv) > 2:  # your entrants file
    names = open(sys.argv[2], encoding="utf-8-sig").read().split()
else:  # no file: everyone on the lists
    names = [handle for task in REQUIRED for handle in snap[task].values()]
entrants = sorted({name.lstrip("@").lower() for name in names} - {author})
passed = [e for e in entrants if all(e in did[task] for task in REQUIRED)]
open(f"passed-{post_id}.txt", "w").write("\n".join(passed))  # paste into a giveaway picker
print(f"{len(entrants)} entrants")
for task in REQUIRED:
    print(f"  {task}: {sum(e in did[task] for e in entrants)}")
print(f"  did every task: {len(passed)}")
print("  list SHA-256:", hashlib.sha256("\n".join(passed).encode()).hexdigest())

Save the four parts as verify_tasks.py and run it. The entrants file is optional:

python verify_tasks.py https://x.com/taskonxyz/status/2116179061458555063 entrants.txt

What our test on a live quest post found

On 17 November 2026, we ran it on TaskOn's Halloween campaign post from 30 October. X counted 14 reposts and 6 replies.

Terminal runs of verify_tasks.py: 9 reposters and 4 repliers for 18 credits, then a free re-check
We blanked the fingerprint, which would identify the one account.
  • The lists ran short of X's counts: 9 of 14 reposts. X's Help Center says protected accounts can repost, but only approved followers see it.
  • One reply was TaskOn's own, and the script leaves out the post's author.
  • The re-check was free. Given the 4 repliers and 3 brand accounts that took no part, it read the snapshot and passed 1.

Our run cost 18 credits; 5,000 credits a month are free; $5 buys 25,000.

No code? Our free giveaway picker loads who replied, reposted, quoted, or replied and reposted, from a post's link. With Weir connected to Claude or ChatGPT, the same lists come from its get_x_retweeters, get_x_replies and get_x_quotes tools.

How to check a Twitter follow for a giveaway

Each entrant has their own following list, so follows cost the most. For 200 entrants:

Credits to check follows for 200 entrants, November 2026
3 winners, follow on page 1about 240
Brand's newest 1,000 followersabout 1,020
All 200 entrants, follow on page 1about 14,600
  • Check only the winners. Draw first, then run our follow check script on each winner.
  • Read the brand's newest followers. X lists them mostly newest first, Weir's reference says, so read back to the campaign's start.
  • Read each entrant's following list. A fresh follow sits near the top, but a "no" means reading it all: about 1,017 credits for 1,000 follows.

On 17 November 2026, TaskOn's newest followers page held 67 of its 692,593 followers, for 70 credits. None of our 12 test accounts were on it: on a big account, the newest page is only the latest 67 follows.

What Zealy and Galxe check on X (Twitter)

Quest platforms check tasks for you. Their docs, on 17 November 2026:

Task X's app Zealy Galxe Weir
Follow Scroll by hand Yes Authentic only Following lists
Repost Latest 100 Yes Authentic only Every page
Reply Under the post Yes Not listed Replies list
Quote Quotes tab Yes Authentic only Quotes list
Like Author only Yes Not supported No
  • Zealy adds claim credits per check: 1 for a follow, reply or quote, 2 for a retweet, 3 for a like. It doesn't say how it checks likes.
  • Galxe records only a page visit by default: "the API counts the intent without verifying if the action was completed." Its Authentic Verification checks through X's API, at 10 credits a check.

Keep the draw fair: snapshot and fingerprint

  • Fix the rules first. Name every task and the deadline, and never add rules later.
  • Judge everyone on one snapshot, saved with its time.
  • Publish the fingerprint. The script hashes the passing list, lower case and sorted, like our giveaway picker. Both gave the same SHA-256 in our 17 November test.
  • Allow one account per person, as X's Guidelines for Promotions ask.
  • Check a "no" by hand. Protected accounts, hidden replies and X's spam filter can hide real entries.

X adds that following contest law "is your responsibility." This isn't legal advice.

When not to use Weir

  • Your quest platform checks the task. Zealy, or Galxe with Authentic Verification, reads X for you.
  • You need likes. Only the post's author sees them, in X's app.
  • The giveaway is small. X's app shows the latest 100 reposters for free.
  • You need a contract with X. Weir isn't licensed by X, so access can change.

FAQ

How do you check if someone retweeted your tweet?

Open the post's Reposts tab, which lists the latest 100. For more, page through Weir's reposters list and match entrants against it.

Can you check who liked a tweet for a giveaway?

Only on your own post, by hand in X's app. Since June 2024, only a post's author sees who liked it. For a check you can automate, ask for a repost, reply or quote.

How does Galxe verify Twitter tasks?

By default it records only a page visit. Authentic Verification checks follows, retweets and quotes through X's API, at 10 credits each. Galxe Quest's last campaign day is 5 December 2026.

How does Zealy check Twitter tasks?

Zealy checks follows, tweets, replies, retweets, likes, quotes and Spaces, for 1 to 3 extra claim credits each. A verified task stays done, even if the user undoes it later.

Sources

Checked 17 November 2026 (UTC). X's help pages are Wayback copies, dated in brackets: