How to Make a Bot Checker 2026

[Blackhatpakistan]

A bot checker answers one question at platform scale: does this account behave like a human or like a farm — and every platform exposes enough signal to score the question without ever seeing the account's internals. Account age versus activity volume (three years of tenure and four posts read dormant-or-buyer; 10,000 followers and six days of tenure read bought), follower/following ratios against cohort norms, engagement-rate math (bought followers do not engage, the strongest public signal), posting-cadence entropy (humans post in irregular clusters; automation runs metronomes), and profile-completeness patterns (default avatars, handle-rewrites, bio-similarity clusters across followed accounts). This is bot-checker making decoded: the signal taxonomy per platform class, the scoring model that combines weak signals into usable classification, the mass API architecture (tier mapping, pagination, rate-limit survival), and the output classes that downstream consumers actually parse. Post your batch log — cleanest farm-map output gets pinned to Carding-method, first fifteen get the platform-weight calibration starter sets via PM.

TL;DR - The tool's core is a feature-extraction pipeline per account: fetch the account's public profile and recent-activity surface (API tier permitting), extract behavioral features, score against a weighted model, and classify (bot-likely, human-likely, suspicious-needs-review, inaccessible) with contributing signals recorded per account so the classification is auditable rather than a black-box score. The signal categories hold across platforms: age-activity coherence (creation-date vs activity volume and follower acquisition curve — sudden cliffs are bought-follower signatures), network structure (follower/following ratios against cohort norms, follower-quality sampling — accounts followed by bots with high probability are themselves in bot networks), engagement-rate math (likes-plus-comments as a percentage of follower count vs cohort baseline — bought followers do not engage), cadence entropy (humans cluster irregularly, automation shows metronome intervals), profile-similarity clustering (template bios, display-name pattern-matches across a follow-set). Scoring discipline: weak signals combine — no single feature classifies alone; each contributes a weighted component; totals cross thresholds calibrated against labeled sample sets; weights are platform-specific and ship as data, not code. Mass architecture: API-tier mapping per platform (which signals survive on the accessible tier vs which need authenticated), token-bucket pacing per credential, reservoir sampling over follower pagination (first-page bias misrepresents bot-network density), failure-mode taxonomy (private accounts classify inaccessible, never bot or human).

THE SIGNAL TAXONOMY

- Age-activity coherence: account creation-date against activity volume and follower acquisition curve — 10,000 followers accrued in a week versus over three years classify differently; sudden acquisition cliffs are bought-follower signatures; dormancy-to-activity transitions (years-old accounts suddenly posting at 10x historical rate) read compromised or sold; accounts created inside burst-windows (bot-farm onboarding clusters create timestamp-adjacent accounts at volume) detectable in aggregate even when each looks individually plausible.
- Network structure: follower/following ratio against cohort norms (human accounts typically follow under a few hundred with asymmetrical follower counts; inverted or near-1:1 at high counts read follow-back-farm membership); follower-quality sampling (random sample of the account's followers — high default-avatar density, high age-activity incoherence in the sample propagates the classification); follow-churn patterns where the platform exposes them (rapid follow/unfollow cycling is follow-for-follow automation's fingerprint).
- Engagement-rate math: likes-plus-comments as a percentage of follower count, compared against the account's own historical rate and the platform-cohort baseline for the account's size class — a 50,000-follower account with 3 likes per post runs orders of magnitude below cohort baseline, and the non-engagement is the single most reliable bought-follower signal available from public data; comment-section bot-signatures (emoji-spam accounts, copy-paste strings across many accounts' posts) where visible.
- Cadence entropy: posting-interval distribution (humans cluster irregularly — bursts and silence; automation shows low-entropy regular intervals — every 47 minutes, every 2 hours on the dot); content-similarity scanning where the activity surface exposes it (reposted-text clusters, identical caption templates — content-farm signatures); time-zone coherence (posting timestamps clustered in a single foreign timezone relative to the account's claimed geography — farm-floor schedules leaking through).
- Profile completeness and similarity: default-avatar flags, handle-rewrite history where visible (bot networks rotate handles to dodge bans — frequent rewrites on aged accounts read farm-operated), bio-text similarity clustering (identical or template bios across a follow-set — farm-onboarding templates), display-name pattern-matching (name-format clusters like "First Last 4-digits" that pattern across followed accounts).

CODE: FEATURE SCORER + CLASSIFIER

Weighted feature combination: each extracted feature contributes a signed score component weighted by its platform-specific discriminative power; the weighted sum crosses classification thresholds. The audit trail records every feature value and contribution — a bot-likely classification shows exactly which signals drove it.

# weighted feature scorer with platform-specific calibration

# weights ship as data — recalibrate as tactics shift without recompiling

TWITTER_WEIGHTS = {

    "engagement_rate_z":    -0.40,  # z-score vs cohort baseline (bought followers don't engage)

    "follower_sample_def":  -0.35,  # default-avatar density in follower sample

    "cadence_entropy":      -0.25,  # low entropy = metronome posting

    "network_ratio_z":      -0.15,  # inverted follow ratios

    "bio_template_match":   -0.10,  # bio matches farm template cluster

    "age_days":             -0.05,  # fresh accounts slightly suspicious

}

THRESHOLDS = {"bot_likely": -0.7, "human_likely": 0.2}  # between = suspicious

def score_account(features, weights):

    score = 0.0

    audit = []

    for feat, weight in weights.items():

        val = features.get(feat, 0.0)

        contribution = val * weight

        score += contribution

        audit.append((feat, val, round(contribution, 3)))

    if score <= THRESHOLDS["bot_likely"]:

        cls = "BOT_LIKELY"

    elif score >= THRESHOLDS["human_likely"]:

        cls = "HUMAN_LIKELY"

    else:

        cls = "SUSPICIOUS"

    return cls, round(score, 3), audit

# demo: bought-follower account vs organic account

bot_features = {

    "age_days": 41, "engagement_rate_z": -3.2, "follower_sample_def": 0.61,

    "cadence_entropy": 0.12, "network_ratio_z": 0.4, "bio_template_match": 1,

}

human_features = {

    "age_days": 1240, "engagement_rate_z": 0.8, "follower_sample_def": 0.04,

    "cadence_entropy": 0.71, "network_ratio_z": -0.2, "bio_template_match": 0,

}

cls, score, audit = score_account(bot_features, TWITTER_WEIGHTS)

print("A:", cls, score)

for f, v, c in audit:

    print("   ", f, "=", v, "->", c)

cls2, score2, _ = score_account(human_features, TWITTER_WEIGHTS)

print("B:", cls2, score2)

MASS API ARCHITECTURE

- API-tier mapping per platform: which signals need which tier — profile metadata (age, follower counts, avatar) usually sits on public or light-auth tiers; activity history and engagement details often sit on authenticated tiers with rate limits in the hundreds-to-thousands-per-hour band; the architecture's first design decision: which signals survive on the accessible tier (the checker's honest signal-subset for restricted platforms) versus which require the authenticated tier (full-signal mode where API access permits).
- Rate-limit survival: per-platform request budgets tracked against published and observed limits (the observed limits often differ from documentation), token-bucket pacing per credential, exponential backoff on 429-class responses with retry-after honored where present, multi-credential rotation for throughput beyond single-token budgets; the rate-limit budget is the batch-planning input — accounts-per-hour per platform comes directly from the accessible tier's limit, not from compute capacity.
- Pagination and sampling discipline: follower-sampling pulls a random reservoir sample over the follower list's pagination rather than the first page (first-page bias — the earliest followers are often the account's organic-era follows, misrepresenting the bot-network density further down); activity-window sampling pulls a fixed recent window with the account's historical window as a separate lighter pull where rate budget permits (the historical comparison is what makes engagement-rate and cadence-entropy honest per-account rather than one-snapshot guesses).
- Failure-mode taxonomy: private accounts and API-tier walls classify inaccessible (not bot, not human — the tool could not see enough signal to score honestly, and the record says so); token-expiry and auth-failures park the batch for credential refresh, never classified per-account; platform-side 429 storms rotate credentials and egress, with the run resumable from the last-completed account cursor.

CODE: RESERVOIR SAMPLER + RATE BUDGET PLANNER

Follower sampling pulls a uniform random sample over pagination (first-page bias misrepresents bot-network density); the rate-budget planner maps accessible-tier request limits into accounts-per-hour throughput before the batch runs.

# reservoir sampler over follower pagination + rate budget planner

import random

def reservoir_sample(follower_pages, sample_size=200):

    """Uniform random sample over paginated follower list.

    Pages arrive as lists of follower dicts; sampler does not

    need total count upfront."""

    reservoir = []

    seen = 0

    for page in follower_pages:

        for follower in page:

            seen += 1

            if len(reservoir) < sample_size:

                reservoir.append(follower)

            else:

                j = random.randint(0, seen - 1)

                if j < sample_size:

                    reservoir[j] = follower

    return reservoir, seen

def analyze_sample(sample):

    default_avatars = sum(1 for f in sample if f.get("default_avatar", False))

    incoherent = sum(1 for f in sample if f.get("age_activity_incoherent", False))

    n = len(sample)

    return {

        "sample_size": n,

        "default_avatar_density": round(default_avatars / n, 3),

        "incoherence_density": round(incoherent / n, 3),

    }

def plan_batch(rate_per_hour, sample_overhead=2):

    """Map API rate budget to accounts-per-hour.

    sample_overhead = extra requests per account for follower sample."""

    requests_per_account = 1 + sample_overhead  # profile + sample pages

    accounts_per_hour = rate_per_hour // requests_per_account

    return accounts_per_hour

# demo

pages = [[{"default_avatar": i % 3 == 0, "age_activity_incoherent": i % 5 == 0}

          for i in range(100)] for _ in range(10)]

sample, total = reservoir_sample(pages, 200)

stats = analyze_sample(sample)

print("sample:", stats, "| total followers seen:", total)

print("2500 req/hr ->", plan_batch(2500), "accounts/hr")

DETECTION LAYER

What runs against a bot checker: platform-side API rate limits (per-token budgets in the hundreds-to-thousands-per-hour band, observed limits often differ from documentation); authenticated-tier gating on activity history and engagement details; private-account walls (classify inaccessible, never force-score); platform-side bot-detection running against the checker's own API consumption pattern (high-volume profile scrapes from one credential read as automation, which is why multi-credential rotation and pacing discipline apply to the checker itself); and the calibration-set staleness problem — bot-farms evolve tactics against exactly the detection features the model weights, which is why the labeled-data refresh cadence (monthly per platform) is what keeps the classification surface honest against counter-adaptation.

OPSEC CHECKLIST

- Weights as data, not code: platform-specific weights ship as recalibratable data files — Instagram's engagement-rate economics differ from Twitter's, Discord's account-age signals differ from TikTok's; a universal-weight model misclassifies on every platform by fitting none.
- Reservoir-sample followers, never first-page: the first followers are the organic-era set (or the farm's seeding-wave), misrepresenting bot-network density; reservoir sampling over pagination gives a uniform random sample whose stats extrapolate honestly within known sampling error.
- Inaccessible is its own class: private accounts and API-walled profiles never force-scored — the record says "could not see enough signal" and parks for API-tier upgrade planning; misclassifying inaccessible as bot poisons every downstream consumer's accuracy metrics.
- Audit trail per classification: every feature value and score contribution recorded — lets downstream consumers weight the verdict against their own context and lets maintainers debug miscalibration cases directly against the feature values.
- Multi-credential rotation with token-bucket pacing: the checker's own API consumption pattern is visible to the platform — one credential hammering profile-fetches reads as automation; pace per credential, rotate across the pool.
- Calibration feedback loop: review-class human-adjudications (confirmed-bot vs confirmed-human on sampled cases) feed the next calibration pass — the model's weights drift as farms evolve, and the labeled-data refresh cadence is what keeps the surface honest.

TEST YOURSELF: SIX QUESTIONS

Score honestly: (1) name the five signal categories and which one is the strongest public bought-follower signal. (2) why does reservoir-sampling over follower pagination outperform reading the first page? (3) your scorer returns SUSPICIOUS for an account with cadence-entropy 0.3 and engagement-rate z-score -0.5 — what does the middle class protect against? (4) a platform's authenticated tier allows 800 requests/hour per credential and you have 5 credentials — what is the batch's theoretical accounts-per-hour ceiling before sampling overhead? (5) what does the audit trail record per classification, and who consumes it? (6) your Instagram weights file shows engagement-rate contribution dominating but a new farm tactic shifts to copy-paste comment spam — what recalibration move does the feedback loop prescribe? Zero to one: you read the TL;DR. Two to three: score your last batch's output classes against the audit trails and check the threshold calibration. Four plus: post your scoreboard with cluster-rollup counts.

POST YOUR LOG

Scoreboard format: platform, accounts processed, API-tier used (public/light-auth/authenticated), bot-likely count, human-likely count, review-queue count, inaccessible count, cluster-rollup views (interconnected bot-clusters surfaced, shared bio-templates, creation-date bursts within 72-hour windows), median engagement-rate on bot-likely class (the bought-follower economy visible in aggregate), wall time at rate budget. Field-log framing, own batches only. Cleanest farm-map output gets pinned to Carding-method, first fifteen posters get the platform-weight calibration starter sets via PM — default weight files for Instagram/Twitter/TikTok/Discord with labeled-sample sourcing method and the monthly refresh workflow.

FAQ

- Q: What does a bot checker actually check?

A: Public behavioral signals — account-age versus activity volume, follower/following ratios against cohort norms, engagement-rate math (bought followers do not engage, the strongest public signal), posting-cadence entropy (humans post irregularly, automation runs metronomes), and profile-similarity clustering — combined via platform-specific weighted scoring into bot-likely/human-likely/suspicious classifications with the contributing signals recorded per account.
- Q: Which signal is most reliable?

A: Engagement-rate versus cohort baseline for the account's follower-count class — bought followers do not like or comment, so accounts running orders-of-magnitude below baseline engagement at high follower counts carry the bought-follower signature directly in public data. Follower-sample default-avatar density is the close second (sampling the account's followers for bot-signatures — followed-by-bots propagates the classification).
- Q: Why reservoir-sample followers instead of reading the first page?

A: First-page bias — a follow-set's earliest followers are often the account's organic-era follows (or the farm's seeding-wave), misrepresenting the bot-network density that shows up deeper in the list; reservoir sampling over pagination gives a uniform random sample whose default-avatar and age-activity stats extrapolate honestly to the whole follow-set within known sampling error.
- Q: How do API rate limits shape the architecture?

A: The accessible tier's request budget directly sets accounts-per-hour throughput — the architecture maps which signals survive on the accessible tier versus which need authenticated tiers, runs token-bucket pacing per credential with multi-credential rotation for scale, honors 429 backoff, and batch-plans from the rate budget rather than compute capacity (the compute is never the bottleneck; the platform's request budget always is).
- Q: What is the suspicious class for?

A: Accounts with odd-but-possibly-organic patterns that fall between classification thresholds — real humans with unusual cadence, dormant accounts reactivating, small accounts with atypical ratios. The middle class exists so threshold-gaps do not misclassify ambiguous accounts as bots; the review queue's human-adjudications feed the next calibration pass.
- Q: Do platform differences matter in the model?

A: Entirely — Instagram's engagement-rate economics, Twitter's network-structure and cadence signatures, TikTok's content-farm similarity signals, Discord's fresh-account raid patterns each carry different discriminative power, so weights ship per-platform as recalibratable data rather than one universal model.

RELATED

OpenBullet Config Making 2026 - Complete Guide to Creating Configs

How CC Checkers Actually Work - Response Codes, CPM and Accuracy

Proxies for Carding 2026 - Complete Proxy Guide

Carding Tools 2026 - BIN Checkers & Validators