Meta platforms have a bot problem. In June, Johnny Palmadessa posted a theory as to why this bot problem may be so rampant, and how it may play into Meta's plans. These bots don't post or comment or sell anything, they just sit in your follower list. His argument was that if a platform ranks your posts partly on how your followers engage, then followers who never engage drag your reach down without anyone taking anything away.

Our largest following is on Threads, which is owned by Meta. Our monthly views fell from over 70 million to four million. Over the same stretch our following almost doubled, our reach on other networks increased and our website faced record views. A following that grows while views collapse is what his theory would produce, and the opposite of how the Threads algorithm is supposed to behave. When we scanned that out we found tens of thousands of accounts that look like bots.

We ran our own audience through a bot check, and if you scroll down, you can follow our lead.

Of the roughly 220,000 accounts that follow this outlet on Threads, we pulled 152,000 and put every one through a set of simple tests. Depending on how strictly you count, somewhere between one in ten and one in five of them carries the fingerprint of an automated account.

We cast a deliberately wide net, aiming to overreach on our hunt for bots. The thinking was that if we cast such a wide net, we will get false positives, but should catch most of the bot accounts. We flagged 14,789 of the 152,000 as possible bots, a shade under ten percent. This isn't the confirmation of that number of bots, as it also brought along false positives, but it means there are 14,789 accounts that tripped up on typical indicators of bot accounts.

What the handles give away is often enough. The accounts that trip every test look exactly like what they are: user_7804_30965, zoro____1937, ____my______life_________7743, a junk prefix, a number, a second number, an underscore thicket, and no name attached. We also looked for accounts with no following, who have their account set to private, or simply do not interact with the accounts they follow.

The bots are not spread evenly

The more useful finding is where they cluster. We pulled the follower list in the order Threads serves it, which is newest first, and the newer half of the list flagged at nearly twenty-seven percent while the older half flagged at sixteen. The accounts that arrived recently are markedly more bot-heavy than the base we built over the past year. This says that there has been an increase in bot followers in recent time, which lines up with complaints that now plague the platform.

With Meta recently celebrating 500 million users on their Threads platform, the gradual increase in the number of bots appears as more than suspicious. What's more, is Meta seems entirely disinterested in the bot plague.

Meta does not give you a tool to see any of this. There is no button on Threads that says "show me my fake followers," no export, no dashboard where you can mass unfollow. So we went and got it ourselves, and below is how you get yours.

What you are about to do

You are going to ask Threads for your own follower list the same way the Threads website already asks for it, page through the whole thing, and score each account against a handful of bot tells. Nothing here touches anyone else's account or any private data. Your follower list is public. You are automating a read of information already on display.

Two warnings before you start:

First, this likely runs against Meta's terms of service, which do not permit automated access. For an ordinary user auditing their own audience the practical risk is low, but it is not zero, and if your account is already under any kind of enforcement you should weigh that. Keep this in mind.

Second, the request you are about to capture contains your live session tokens. Those tokens are the keys to your account. Never paste them into anything public, never put them in a screenshot, never include them in an article about doing this, should you want to amplify this piece on your own blog. Every example below uses a placeholder, do not publicise a version where you have filled in that placeholder.

You will need a computer, a browser (Chrome or Firefox), and about ten minutes to set up. The scoring step needs Python, which most machines already have. If yours does not, follow these instructions to install python.

Step one:

  1. Log in to threads.com and open your own profile.
  2. Open the developer tools. On Firefox that is Command-Option-K on a Mac, Control-Shift-K on Windows. On Chrome, swap the K for a J.
  3. Click the Network tab, then the XHR (Firefox) or Fetch/XHR (Chrome) filter.
  4. Click Followers on your profile so the list opens, and scroll it down once so it loads a batch.
  5. Every request in that list is named query, which is unhelpful, so you have to find the right one by its contents. Click a query row, open its Response tab, and look for one whose text contains fetch__XDTUserDict and a followers block full of usernames. A faster way: with a row selected, type username into the Response panel's filter box. The followers request will show username fields, the others will not.
  6. When you have the right row, right-click it, choose Copy, then Copy as cURL. On Firefox pick the POSIX version if asked.

You now have a long block of text on your clipboard. It contains your session cookies. Treat it like a password.

Step two

The script below runs in the browser console, in your own logged-in tab, and reuses your session. It never asks you for a password, and you paste your captured request into a box when it runs rather than into the file, so nothing sensitive lives on disk.

  1. In the developer tools, switch to the Console tab.
  2. If the console refuses to let you paste and shows a self-XSS warning, type allow pasting and press Enter, then paste again.
  3. Paste the whole script below, press Enter.
  4. A box appears asking for your cURL. Paste your captured request into it and click OK.

It will start printing a rising count and downloading a followers_partNN.csv file every ten thousand accounts. On a large list it will hit rate limits, back off, and carry on. To stop early, type THF_STOP = true. To resume later, paste the script again; it remembers where it left off.

const BATCH = 50, BASE_MS = 2500, JITTER_MS = 2000, CHUNK_ROWS = 10000;
window.THF_STOP = false;

(async () => {
  const sleep = ms => new Promise(r => setTimeout(r, ms));

  let CURL = window.THF_CURL || '';
  if (!CURL) {
    CURL = prompt('Paste your Threads followers cURL here, then press OK:') || '';
    window.THF_CURL = CURL;
  }
  if (!CURL.trim()) { console.error('No cURL provided. Run again and paste it into the box.'); return; }

  const curl = CURL.replace(/\\\r?\n/g, ' ');
  const url = (curl.match(/curl\s+'([^']+)'/) || curl.match(/(https:\/\/[^\s']+graphql[^\s']*)/) || [])[1];
  if (!url) { console.error('Could not find the URL in that cURL.'); return; }

  const headers = {};
  for (const m of curl.matchAll(/-H\s+'([^:]+):\s*([^']*)'/g)) {
    const name = m[1].trim();
    if (/^x-/i.test(name) || /^(content-type|accept)$/i.test(name)) headers[name] = m[2].trim();
  }
  const bodyRaw = (curl.match(/--data-raw\s+'([^']*)'/) || [])[1];
  if (!bodyRaw) { console.error('Could not find the request body in that cURL.'); return; }

  const varsEnc = (bodyRaw.match(/(?:^|&)variables=([^&]*)/) || [])[1];
  let baseVars;
  try { baseVars = JSON.parse(decodeURIComponent(varsEnc)); }
  catch (e) { console.error('Could not read the variables from the body.', e); return; }

  function bodyWith(cursor) {
    const v = { ...baseVars, first: BATCH };
    if (cursor) v.after = cursor; else delete v.after;
    return bodyRaw.replace(/((?:^|&)variables=)[^&]*/, `$1${encodeURIComponent(JSON.stringify(v))}`);
  }

  let cursor = localStorage.getItem('thf_cursor') || null;
  let total = parseInt(localStorage.getItem('thf_count') || '0', 10) || 0;
  let part = parseInt(localStorage.getItem('thf_part') || '0', 10) || 0;
  console.log(cursor ? `Resuming (${total} already collected).` : 'Starting from the top.');

  let buffer = [];
  const esc = s => `"${String(s ?? '').replace(/"/g, '""')}"`;
  function download() {
    if (!buffer.length) return;
    part++; localStorage.setItem('thf_part', String(part));
    const csv = 'username,full_name,is_verified,has_pic\n' +
      buffer.map(r => [esc(r.username), esc(r.full_name), esc(r.is_verified), esc(r.has_pic)].join(',')).join('\n');
    const a = document.createElement('a');
    a.href = URL.createObjectURL(new Blob([csv], { type: 'text/csv' }));
    a.download = `followers_part${String(part).padStart(2,'0')}.csv`;
    document.body.appendChild(a); a.click(); a.remove(); URL.revokeObjectURL(a.href);
    console.log(`  saved ${a.download} (${buffer.length} rows)`);
    buffer = [];
  }

  async function fetchPage() {
    let wait = 30000;
    for (let i = 0; i < 6; i++) {
      const res = await fetch(url, { method:'POST', headers, body: bodyWith(cursor), credentials:'include' });
      let txt = (await res.text()).replace(/^for\s*\(;;\);/, '');
      let json; try { json = JSON.parse(txt); } catch (e) { json = null; }
      const conn = json?.data?.fetch__XDTUserDict?.followers;
      if (res.ok && conn) return conn;
      console.warn(`  throttled/empty (status ${res.status}); waiting ${Math.round(wait/1000)}s (${i+1}/6)`);
      await sleep(wait); wait = Math.min(wait*2, 300000);
    }
    return null;
  }

  while (!window.THF_STOP) {
    const conn = await fetchPage();
    if (!conn) { console.error('Stopped after repeated failures. Progress saved; wait, then paste again to resume.'); download(); return; }
    for (const e of conn.edges || []) {
      const n = e.node || {};
      buffer.push({ username:(n.username||'').toLowerCase(), full_name:n.full_name||'', is_verified:!!n.is_verified, has_pic:n.profile_pic_url?true:'' });
      total++;
    }
    cursor = conn.page_info?.end_cursor || null;
    localStorage.setItem('thf_cursor', cursor || ''); localStorage.setItem('thf_count', String(total));
    console.log(`  ${total} followers collected`);
    if (buffer.length >= CHUNK_ROWS) download();
    if (!conn.page_info?.has_next_page) {
      console.log(`Done. ${total} followers total.`); download();
      localStorage.removeItem('thf_cursor'); localStorage.removeItem('thf_count'); localStorage.removeItem('thf_part'); return;
    }
    await sleep(BASE_MS + Math.random()*JITTER_MS);
  }
  console.log('Stopped by you. Progress saved; paste again to resume.'); download();
})();

If it returns a "Page Not Found" page instead of a count, your captured request has gone stale, capture a fresh one and run it again. Session tokens expire, sometimes within the hour.

Step three

Open our tool. It runs entirely in your browser, nothing uploads anywhere, your follower list never leaves your machine. Drop your followers_part*.csv files onto the page, if you have a large following, there may be dozens of these. It merges them, removes duplicates, and shows only the accounts that trip at least one bot test, as clickable links, strongest first, with a button to download the flagged handles as a plain list.

This tool scores the accounts on the parameters that are a typical tell of a bot, and the parameters we have added. The tool will then output a list of suspected bots for you to work through.

Work down the list. The accounts at the top, the ones that trip several tests at once, are your near-certainties.

This will have false positives, you will need to use your own sense of judgement on this. It will take time to sift through, and we cannot recommend a method to tackle these accounts that won't be flagged by Meta, so we can't offer a suggestion at this time.

What this does not do

This catches crude bots and hopefully more polished ones, but it may miss some. As mentioned, this will also collect false positives. This is not a perfect method, and honestly, it's probably impossible to create such a perfect method, this is just the best that we could come up with.

This script cannot see follower counts, because the followers endpoint does not return them. This would have been a nice addition, and we are open to hearing from people on ideas on how to include follower counts. We hope to eventually make a more robust version of this that can live on as a browser extension, unfortunately, this is the best we can do for now.

That theoretical more robust version would also scan for the presence of profile photos on the accounts. The profile picture field is close to useless in this script, because Threads returns an image address for every account, including the ones using the default grey silhouette. Telling a real photo from the default requires inspecting the image address itself, which is another addition that may make it into a future version, but added too much complexity at this point.

Whatever number you get, the real figure may be higher, this really depends on how many normal accounts act similar to bots, and how many really sophisticated bots you have in your follower count.

If you have any issues, please contact us at contact@crustnews.com, and we will try our best to offer guidance.