How to Track Andrew Tate's Tweets Using the Twitter (X) API
Andrew Tate (X handle @cobratate) is one of the most controversial and most-watched influencer accounts on X — a former kickboxer turned controversial commentator whose account was banned in 2022 and reinstated in 2023, and which routinely produces multi-million-engagement viral tweets when active. For audience-research teams, brand-safety platforms, and culture-watching analysts, the account is both high-value as a signal and high-risk as a tracker: the handle has gone away and come back before and could again.
Programmatically following @cobratate well means more than a timeline scrape — it means a tracker that survives suspensions gracefully, captures the viral-velocity profile that distinguishes a Tate tweet from background noise, and pulls the quote-tweet + reply network where most of the cultural reaction actually lives.
This guide covers the tracking methods, a runnable Python pipeline that handles the suspended/active state machine, and the specific data patterns (viral velocity, reply-sentiment polarization, quote-cluster topology) that make Tate-account data uniquely valuable for downstream products.
Who is Andrew Tate and why @cobratate is operationally tricky to track
Andrew Tate is a former professional kickboxer who became one of the most-discussed influencers on X starting in 2022. His content centers on masculinity, lifestyle, business, and political commentary. His current handle is @cobratate; the original @TateConfidential account is banned. His account has cycled through banned → reinstated states; on X, that cycle is part of what your tracker has to handle.
What makes this account distinctive from a tracking standpoint:
Implications for the tracker design: you need (a) a suspension-aware state machine so the pipeline doesn't crash when the handle 404s, (b) frequent polling immediately after each new tweet to capture engagement velocity at multiple time points (T+5m, T+30m, T+2h, T+24h), and (c) a quote-tweet collection pass on viral tweets so the reaction network is in your dataset, not just the original posts.
Twitter / X API methods for tracking @cobratate
The three architectural patterns for following one account map to Tate-style usage as follows.
1. Timeline polling with velocity-capture (pull) — Standard polling for new tweets, plus an engagement-revisit pass for tweets younger than 24 hours. Cheapest by total call volume; gives you the velocity profile (which is the signal that matters for this account).
2. Real-time filter stream (push) — Subscribe to from:cobratate via WebSocket. Sub-second freshness; useful if you're building an alerting product but expensive in operational complexity (persistent worker required).
3. Webhook callbacks — Each new tweet hits your HTTP endpoint. Operationally simple for serverless deploys; slightly higher per-event cost than the filter stream.
For most analytics use cases: option 1 with the velocity-capture pass is the right starting point. Add option 2 only if your product depends on beating other commentators to publication by 30-60 seconds.
TwitterAPI.io quickstart — pulling @cobratate's timeline
TwitterAPI.io is a third-party X API offering pay-per-call pricing at $0.00015 per read — roughly 33× cheaper than the official X API's $0.005 per post read. Setup is a Google sign-in + an X-API-Key header; no OAuth flow, no project approval, no monthly minimum.
Endpoints chosen for this guide:
- GET /twitter/user/info — resolves @cobratate → user_id; also returns the current banned/active state (404 if suspended).
- GET /twitter/user/last_tweets — recent ~20 tweets per call; for the main polling loop.
- GET /twitter/tweet/info — re-fetch a specific tweet to capture engagement velocity over time.
- GET /twitter/tweet/quotes — pull the quote-tweet thread for a viral tweet (the reaction network).
Authentication: put your API key in the X-API-Key header.
Code example — a suspension-aware Python tracker
The script below polls @cobratate's timeline, schedules a velocity-revisit pass for each new tweet at T+30m, T+2h, T+24h, and handles the suspension state explicitly: if user/info 404s, we flag the account as suspended and back off to a once-per-hour heartbeat check until the handle resolves again.
Implementation notes:
- POLL_INTERVAL = 120 — 2-minute base poll. Fine for most analytics uses.
- VELOCITY_CHECKPOINTS = [30, 120, 1440] — minutes after first-seen at which we re-fetch each tweet for engagement counts.
- SUSPENSION_HEARTBEAT = 3600 — when account is suspended, check hourly via user/info and resume the normal loop when it comes back.
- Both the timeline poll and the velocity-revisit pass write to the same JSONL with a kind field (new_tweet vs velocity_checkpoint) so downstream consumers can join cleanly.
Viral velocity, polarization, and quote-network patterns
Three patterns emerge consistently across a few weeks of @cobratate data:
1. Viral velocity has a fast-decay shape. Viral Tate tweets tend to accumulate the majority of their 24-hour engagement within the first 90 minutes — the precise fraction depends on the tweet and the moment, but the rule that engagement concentrates early holds across most viral cases. The slope of likes/minute in the first 15 minutes is commonly used as a leading indicator of final reach, and is usually a stronger signal than text features alone for high-velocity accounts. Calibrate the specific threshold against your own observed data. Capture engagement at T+15m as your headline velocity metric.
2. Reply sentiment is sharply bimodal. Run an off-the-shelf sentiment classifier on the first 500 replies to each viral Tate tweet; the distribution is bimodal (strongly positive + strongly negative) rather than gaussian. The ratio of pro/anti replies is a stable signal that's stable across his viral tweets — and useful for testing whether your sentiment classifier is calibrated, since this is a clean test case.
3. Quote-tweet networks cluster by political topic, not tweet content. Even when a Tate tweet is about lifestyle or business, the quote-tweet commentary clusters by the commentator's political identity — left-wing critics, right-wing endorsers, center-skeptics. Useful for audience-mapping: pull the quote-tweets for 50 Tate tweets, cluster the quoter user_ids, and you have a high-leverage map of the political-commentary network on X.
Operational notes — suspension archives, ToS, cost scaling
Because @cobratate has a history of going from active to suspended and back, three operational notes matter more than they would for a stable account:
- Suspension is an event, not an error. Your alerting should distinguish 'API error during fetch' from 'account is suspended.' Suspensions are useful state for downstream products (sentiment analysts, brand-safety teams) and worth surfacing as an explicit event in your data.
- Archive your own data assertively. Suspensions can take recent tweets out of public-facing view (re-fetches will 404 even for tweets that existed before suspension). If you want a permanent record, your JSONL is the archive — there's no second-chance API path after the fact.
- Cost scales linearly per-account. At the 2-minute base cadence with 3 velocity checkpoints per new tweet, one Tate tracker is roughly 750 calls/day = 22,500/month ≈ $3.40/month on TwitterAPI.io vs $112/month on the official X API at $0.005/read. See [our cost-at-volume breakdown](/blog/x-api-cost-breakdown-2026) for the math at 10/100/1000 accounts.
What this data unlocks for downstream products
A clean @cobratate dataset composes with other sources for several use cases:
- Brand-safety scoring — Train a classifier on (Tate-tweet, brand-mention) pairs to flag tweets that mention a brand alongside controversial topics — useful as a real-time signal for brand PR teams who need to react fast.
- Audience-overlap discovery — Pull the quoter user_ids across 100 viral Tate tweets, cluster them, and you have a high-resolution map of the political-commentary network. Same technique applied to a basket of accounts yields the full influencer-network graph.
- Viral-velocity benchmarking — Use Tate tweets as a high-velocity comparison case for your own product's viral-detection thresholds. If your alerting system doesn't fire on Tate tweets, your sensitivity is too low.
- Polarization-signal datasets — The bimodal reply-sentiment distribution makes Tate tweets useful as ground-truth examples in polarization-research training data. Most off-the-shelf datasets have weaker signal.
# pip install requests
import json
import time
import pathlib
import requests
API_KEY = "YOUR_TWITTERAPI_IO_KEY"
BASE = "https://api.twitterapi.io"
HANDLE = "cobratate"
POLL_INTERVAL = 120 # 2 min base
SUSPENSION_HEARTBEAT = 3600 # 1 h while suspended
VELOCITY_CHECKPOINTS = [30, 120, 1440] # minutes after first-seen
STATE_DIR = pathlib.Path(".state")
STATE_DIR.mkdir(exist_ok=True)
IDS_FILE = STATE_DIR / "cobratate_seen_ids.json"
VEL_FILE = STATE_DIR / "cobratate_velocity_queue.json"
OUT_FILE = STATE_DIR / "cobratate_events.jsonl"
headers = {"X-API-Key": API_KEY}
def load_json(p, default):
return json.loads(p.read_text()) if p.exists() else default
def save_json(p, obj):
p.write_text(json.dumps(obj))
def append_event(d):
with OUT_FILE.open("a") as f:
f.write(json.dumps(d) + "\n")
def resolve_uid(handle):
r = requests.get(f"{BASE}/twitter/user/info",
params={"userName": handle}, headers=headers, timeout=10)
if r.status_code == 404:
return None # suspended
r.raise_for_status()
return str(r.json()["data"]["id"])
def enqueue_velocity_checkpoints(tid, first_seen):
q = load_json(VEL_FILE, [])
for minutes in VELOCITY_CHECKPOINTS:
q.append({"tid": tid, "at": first_seen + minutes * 60})
save_json(VEL_FILE, q)
def due_velocity_checkpoints(now):
q = load_json(VEL_FILE, [])
due = [x for x in q if x["at"] <= now]
remaining = [x for x in q if x["at"] > now]
save_json(VEL_FILE, remaining)
return due
def fetch_tweet_info(tid):
r = requests.get(f"{BASE}/twitter/tweet/info",
params={"tweetId": tid}, headers=headers, timeout=10)
if r.status_code == 404:
return None # deleted or hidden
r.raise_for_status()
return r.json().get("data", {})
def poll_once(uid):
r = requests.get(f"{BASE}/twitter/user/last_tweets",
params={"userId": uid}, headers=headers, timeout=10)
r.raise_for_status()
tweets = r.json().get("data", {}).get("tweets", [])
seen = set(load_json(IDS_FILE, []))
now = time.time()
for t in tweets:
if t["id"] in seen:
continue
append_event({
"kind": "new_tweet", "id": t["id"],
"created_at": t.get("createdAt"), "text": t.get("text"),
"likes": t.get("likeCount", 0), "retweets": t.get("retweetCount", 0),
"replies": t.get("replyCount", 0), "first_seen_at": now,
})
enqueue_velocity_checkpoints(t["id"], now)
seen.add(t["id"])
save_json(IDS_FILE, sorted(seen))
def velocity_pass():
for ck in due_velocity_checkpoints(time.time()):
info = fetch_tweet_info(ck["tid"])
append_event({
"kind": "velocity_checkpoint",
"id": ck["tid"], "at": ck["at"],
"likes": (info or {}).get("likeCount"),
"retweets": (info or {}).get("retweetCount"),
"replies": (info or {}).get("replyCount"),
"present": info is not None,
})
if __name__ == "__main__":
while True:
uid = resolve_uid(HANDLE)
if uid is None:
append_event({"kind": "suspension_check", "at": time.time(), "present": False})
time.sleep(SUSPENSION_HEARTBEAT); continue
try:
poll_once(uid); velocity_pass()
except Exception as e:
print("err:", e)
time.sleep(POLL_INTERVAL)
Questions readers ask
What is Andrew Tate's X / Twitter handle?
@cobratate is the current handle (since 2023 reinstatement). The original @TateConfidential is banned and inaccessible. Double-check the current state with user/info at the start of each pipeline run — handles on X can change state.
Is @cobratate currently active or suspended?
As of 2026 the account is active and posting. Suspensions can recur; treat the active/suspended state as runtime state your pipeline must check, not a static assumption. A user/info call that returns 404 is the signal.
How do I capture engagement velocity (not just final counts)?
After your timeline poll captures a new tweet, schedule re-fetches of that tweet at T+30m, T+2h, T+24h via tweet/info. The slope of likes between T+15m and T+30m is a commonly used signal of viral potential — the runnable code above implements this directly via a checkpoint queue. Calibrate the threshold against your own captured data.
What happens to my tracker if @cobratate is suspended?
user/info returns 404 — treat this as state, not error. Back off to a once-per-hour heartbeat check via user/info, log a suspension_check event, and resume the normal poll loop when the handle resolves again.
Can I get historical Andrew Tate tweets via the API?
Use TwitterAPI.io's advanced_search with from:cobratate since:YYYY-MM-DD until:YYYY-MM-DD. The catch: tweets posted under the previously-banned handle (@TateConfidential) are no longer accessible via any X-API surface. For pre-ban content, only third-party snapshot archives (with their own legal and accuracy caveats) help.
Is it legal to programmatically monitor a public X account?
Programmatic access to public tweets via the X API (official or third-party) is governed by the API's Terms of Service, not by per-account consent — public posts are available for public consumption and analysis under those terms. Note: this is access to public data only; protected/private accounts are excluded. For downstream commercial use (brand-safety products, analytics platforms), consult your jurisdiction's data-protection regulations.
Continue
- X API — TwitterAPI.io coverage hub
- How to track Acyn's tweets — the same pattern applied to a political-journalism account
- How to track Ben Shapiro's tweets — high-volume political commentary pattern
- How to track Kanye West's tweets — burst + deletion-archive pattern
- X API cost breakdown — per-call pricing at scale
- TwitterAPI.io pricing — per-call rates and volume tiers
Stop reading. Start building.
Starter credits cover real testing on real data. Google sign-in, no card, no application queue.
Get an API key