Abstract
Bots constitute a significant portion of Internet traffic and are a source of various issues across multiple domains. Modern bots often become indistinguishable from real users, as they employ similar methods to browse the web, including using real browsers. We address the challenge of bot detection in high-traffic scenarios by analyzing three distinct detection methods. The first method operates on heuristics, allowing for rapid detection. The second method utilizes, well known, technical features, such as IP address, window size, and user agent. It serves primarily for comparison with the third method. In the third method, we rely solely on browsing behavior, omitting all static features and focusing exclusively on how clients behave on a website. In contrast to related work, we evaluate our approaches using real-world e-commerce traffic data, comprising 40 million monthly page visits. We further compare our methods against another bot detection approach, Botcha, on the same dataset. Our performance metrics, including precision, recall, and AUC, reach 98 percent or higher, surpassing Botcha.
Introduction
Bots now account for more than half of all internet traffic, driving issues ranging from price scraping and ticket scalping to election interference. The fundamental challenge in modern cybersecurity is that bots have become "human-mimetic." By utilizing real browsers and legitimate user-agent strings, they have become nearly indistinguishable from real users via traditional fingerprinting techniques.
Existing detection methods often fall into two traps: they are either too computationally expensive for high-traffic environments or they rely on "static" features (like IP addresses or window sizes) that bot operators can easily spoof. Furthermore, over-reliance on intrusive challenges like CAPTCHAs degrades the user experience for legitimate humans. The BOTracle framework seeks a passive, multi-layered approach that prioritizes behavioral patterns, which are significantly harder for bots to fake without sacrificing their operational efficiency.
The BOTracle Framework
To balance detection depth with computational speed, BOTracle employs a three-stage pipeline:
1. Heuristics (The Filter)
This stage acts as a fast first pass to identify "obvious" bots. It flags forged user agents (e.g., "python-request"), perfectly regular timing between hits (suggesting automation), and unrealistic browser window sizes (e.g., axes under 50 pixels). By filtering these simple cases early, the system conserves resources for more complex analysis.
2. Semi-Supervised Generative Adversarial Network (SGAN)
For ambiguous cases, the SGAN analyzes individual "hits" or requests. Unlike standard classifiers, the SGAN uses a discriminator that also functions as a classifier. This allows the model to learn from both labeled and unlabeled data—a crucial advantage in web security where "ground truth" labels are notoriously difficult to obtain from raw logs.
3. Deep Graph Convolutional Neural Network (DGCNN)
This is the most robust stage of the framework. It transforms a user's session into a Website Traversal (WT) Graph, where nodes represent sub-pages and edges represent navigational links. The DGCNN analyzes these graphs to identify non-human navigation patterns, such as exhaustive breadth-first searches or specific page-refresh frequencies that deviate from human browsing norms.
Experimental Setup
The researchers evaluated BOTracle using a massive, real-world dataset from a proprietary e-commerce platform generating $500M–$1B in annual revenue. The study utilized a subset of 1.4 million visits from a total pool of 40 million monthly page visits.
Establishing ground truth in real-world data is challenging. The authors utilized two strict proxies for labeling:
- Human Traffic: Identified as traffic originating from known internal employee accounts.
- Bot Traffic: Identified as traffic originating from known cloud provider IP ranges (e.g., AWS, Azure), which are standard environments for hosting bot scripts.
BOTracle was benchmarked against Botcha, a known bot detection framework, using this same dataset to ensure a fair comparison.
Key Results and Insights
BOTracle demonstrated high performance across all metrics, generally surpassing the Botcha baseline:
- SGAN Performance: Achieved a 98.95% accuracy and an AUROC of 0.9886 using technical features.
- DGCNN Performance: Achieved 98.45% accuracy and an AUROC of 0.9892 while relying strictly on behavioral navigation, proving that behavior alone is a powerful discriminator.
- Heuristic Efficiency: The initial heuristic layer achieved a recall of 0.9988, successfully catching the vast majority of simple bots before they reached the more resource-intensive AI stages.
The "Static Feature" Trap
A critical insight from the study is the vulnerability of technical features. While features like browser_height and browser_width were highly influential for the SGAN classifier, they are the easiest for bot developers to falsify. This highlights the necessity of moving toward behavioral analysis. Mimicking human browsing behavior (random pauses, non-linear navigation) is computationally expensive; if a bot is forced to act exactly like a human to avoid detection, it loses its primary advantages: speed and tirelessness.
Graph Efficiency
Surprisingly, the DGCNN performed exceptionally well even on very small graphs (1–3 nodes). Because WT graphs aggregate multiple interactions with the same page into a single node, they effectively capture "looping" behavior that simple sequence models might miss.
Limitations and Future Work
While BOTracle represents a significant step forward, several areas remain for future exploration. The use of cloud IP ranges as a bot proxy, while standard, may not capture sophisticated bots using residential proxies to appear as home users. Additionally, as generative AI improves, bots may become better at simulating human-like mouse movements and typing rhythms, requiring even more nuanced behavioral features.
Future work will focus on reducing detection latency—specifically, minimizing the number of user interactions required before a definitive "bot" or "human" label can be assigned—to further protect high-traffic e-commerce environments in real-time.
Summary updated