# Poker Bot Rings 🎰 How Card-Sharing Networks Extract $300k/Month From Your Tables

**URL:** <https://onehack.st/t/poker-bot-rings-how-card-sharing-networks-extract-300k-month-from-your-tables/317065>\
**Category:** Tutorials & Methods\
**Tags:** programming, tips-tricks, ai\
**Created:** [January 20, 2026, 4:52pm UTC](https://onehack.st/t/poker-bot-rings-how-card-sharing-networks-extract-300k-month-from-your-tables/317065 "2026-01-20T16:52:45Z")\
**Posts on this page:** 3\
**Page:** 1

<div class="post-metadata">

**Author:** ![SRZ](https://onehack.st/user_avatar/onehack.st/srz/32/146132_2.png) [@SRZ](https://onehack.st/u/SRZ)\
**Post date:** [January 20, 2026, 4:52pm UTC](https://onehack.st/t/poker-bot-rings-how-card-sharing-networks-extract-300k-month-from-your-tables/317065/1 "2026-01-20T16:52:45Z")

</div>

# 🎰 Poker Bot Rings: When Machines Share Cards and Humans Bleed

> **🗺 One-Line Flow:** Multiple bots at your table share hole cards in real time — they _never_ fight each other, they _only_ attack when you’re mathematically doomed.

 ![image](https://onehack.st/uploads/default/original/3X/d/c/dc7c103620397e24d8a1d4845974568dfff29238.png)

* * *

**Why this matters (zero skills required):**  
You’re not playing against 3 strangers. You’re playing against a hive mind that sees 3x the cards you do. They know what you _can’t_ have. They never waste chips on each other. And they’re extracting more money than the casino takes in rake. Understanding this is the difference between “bad luck” and “being farmed.”

* * *

## 🧠 The 30-Second Explanation

**Normal poker:**  
You see 2 cards. Your opponent sees 2 cards. Equal information.

**Bot ring poker:**  
3 bots at your table. Each shares their 2 cards with a central server.  
The server now sees **6 cards** instead of 2.  
They calculate your odds using a **46-card deck** while you use 52.

**The math advantage:**

- Normal player: 3.8% of the deck known
- 3-bot ring: 11.5% of the deck known
- Result: **15-25% permanent edge** over humans, every hand

* * *

## 💸 Why Bot Farms Out-Earn The House

> **The Math That Should Scare You**
>
> **The house takes:**
> 
> - 3-5% rake from every pot
> - Maybe $5 cap per hand
> - At $1/$2 stakes: ~$30-50/hour from a full table
> 
> **A 3-bot ring takes:**
> 
> - 10-15% EV edge over humans at the table
> - Never loses chips to each other (internal recycling)
> - Estimated $100-300k/month at mid-stakes alone
> 
> **Real numbers:**
> 
> > “From these 14 accounts, they are probably playing at least 1 million hands a month and crushing the games by at least 10bb/100 with rakeback. My guess is they’re making anywhere from $100-300k per month.”  
> > — FernandoCosta, 2+2 forums investigating GGPoker bots (October 2025)
> 
> **The PokerStars PLO scandal:**  
> The most infamous episode of 2015 saw PokerStars rocked by a PLO bot ring, which took a reputed $1.5 million from regular players at the mid-stakes tables.
> 
> **And the kicker:**  
> PokerStars collected nearly $2.5 million in rake from the probably-banned accounts during the time they were active – a million more than the profit earned by the cheaters themselves.
> 
> The house _still_ profited while players got robbed.

* * *

## 🎯 How The Scam Works (Step by Step)

> **Step 1: Multiple Accounts, One Brain**
>
> **The setup:**
> 
> ```auto
> Your Table (6-9 players)
> ├── Seat 1: You (human)
> ├── Seat 3: Bot A → reports Ah Kh to server
> ├── Seat 5: Human  
> ├── Seat 7: Bot B → reports Qc Jc to server
> ├── Seat 9: Bot C → reports 7d 7s to server
> └── Coordination Server (sees all 6 bot cards)
> 
> ```
> 
> Each bot runs from:
> 
> - Separate virtual machine
> - Unique IP address
> - Different “identity” (email, payment method)
> 
> To the poker site, they look like strangers from different cities.

> **Step 2: Cards Shared in Real Time**
>
> The moment cards are dealt, every bot phones home.
> 
> **What the server instantly knows:**
> 
> - Bot A: Ah Kh
> - Bot B: Qc Jc
> - Bot C: 7d 7s
> - **Dead cards:** Ah, Kh, Qc, Jc, 7d, 7s
> 
> **Why this matters:**  
> If you somehow knew that another player held something like ten-three offsuit then you would know your odds of winning the hand to be cut by something in the neighborhood of 40%.
> 
> Now multiply that by knowing **3 opponents’ cards** , not just one.

> **Step 3: They Never Bluff Each Other**
>
> **The golden rule:** Bots don’t extract value from teammates.
> 
> Soft play, that is, failing to bet or raise in a situation that would normally merit it, because you don’t want to cost your partner money.
> 
> **What this looks like:**
> 
> - Bot A flops a set
> - Bot B has top pair
> - Normal play: Bot A bets big, extracts maximum
> - **Bot ring play:** Bot A checks, lets it go cheap
> 
> Chips stay in the ring. Only humans bleed.

> **Step 4: The Squeeze — Trapping Humans**
>
> Whipsawing, where partners raise and reraise each other to trap players in between.
> 
> **How it works:**
> 
> ```auto
> Preflop:
> Bot A (early position): Raises to $10
> You (middle): Call with QQ (solid hand!)
> Bot B (late position): Re-raises to $35 ← COORDINATED
> 
> Now you're stuck between two "strong" hands.
> Pay $25 more or fold your queens.
> 
> ```
> 
> **What you don’t know:**
> 
> - Bot A will fold if you call (they KNOW Bot B’s cards are weak)
> - Bot B is squeezing with garbage
> - You’re being tax-farmed by math
> 
> A player raises a bet before the flop and waits for the victim to re-raise. After that, another player raises again, preventing the victim from being able to continue betting.

> **Step 5: Only Attack When You're Behind**
>
> **The decisive edge:**
> 
> When bots share cards, they calculate your range against a **reduced deck**.
> 
> Board: Ks 7c 2d
> 
> | Player | Hand | What Bots Know |
> | --- | --- | --- |
> | Bot A | Ah Kh | Top pair, ace kicker |
> | Bot B | Kd Qd | Top pair, weaker kicker |
> | Bot C | 7h 7s | Set of sevens |
> | You | ?? ?? | Your range is _narrower_ |
> 
> **Bot calculations:**
> 
> - 3 Kings accounted for → You can’t have KK
> - Both 7s accounted for → You can’t have 77
> - Your actual holdings are now predictable
> 
> **The result:**  
> They bet when you’re behind. They fold when you’re ahead.  
> Over thousands of hands, you get crushed.

* * *

## 📊 The Numbers From Real Investigations

> **Documented Bot Ring Busts**
>
> | Platform | Year | Bots/Accounts | Money Stolen | Source |
> | --- | --- | --- | --- | --- |
> | ACR Poker | 2024 | 51 bots | $116,415 | [JNandez investigation](https://twitter.com/JNandezPoker) |
> | PokerStars | 2015 | 36+ accounts | ~$1.5M | [PokerTube](https://www.pokertube.com/article/458-pokerstars-plo-bot-ring-under-investigation) |
> | GGPoker | 2025 | 14+ accounts | $100-300k/month | [GipsyTeam](https://www.gipsyteam.com/news/11-10-2025/ggpoker-bot-report-forums) |
> | PartyPoker | 2024 | 291 accounts | $71,771 refunded | partypoker blog |
> 
> **The ACR numbers:**  
> 51 suspected bots identified at $1/$2 PLO in 2023 – $116,415 stolen from legitimate players / customers of ACR – Bots held a 4.5 EV bb/100 winrate before rakeback.

> **The Russian Bot Factory (Bloomberg 2024)**
>
> Welcome to 2024, a time when artificial intelligence is on the rise. Let’s move to the chilly Russian city of Omsk, home to the Bot Farm Corporation.
> 
> **The scale:**  
> The company looks like a classic company, with different departments, employees and company parties. Supposedly, many employees have never encountered poker or cards at all.
> 
> **Their product:**  
> The group behind the bots even said that they were able to make amateur players so frustrated that 80 percent of them didn’t even play 1,000 hands and quit poker.
> 
> **The customer base:**  
> They have more than 10,000 customers and among them are said to be various professional players.
> 
> This isn’t bedroom hackers. It’s industrialized extraction.

* * *

### 🔧 Coordination Server Example (Card Sharing Protocol)

> **Complete WebSocket Coordination Server (Python)**
>
> ```python
> # coordination_server.py
> # FastAPI + WebSocket for real-time card sharing
> 
> from fastapi import FastAPI, WebSocket, WebSocketDisconnect
> from typing import Dict, List, Set
> import json
> import asyncio
> 
> app = FastAPI()
> 
> class TableCoordinator:
> def __init__ (self):
> self.tables: Dict[str, dict] = {}
> self.connections: Dict[str, List[WebSocket]] = {}
>     
> def get_or_create_table(self, table_id: str) -> dict:
> if table_id not in self.tables:
> self.tables[table_id] = {
> "cards": {}, # seat -> [card1, card2]
> "board": [],
> "pot": 0,
> "bots": set()
> }
> self.connections[table_id] = []
> return self.tables[table_id]
>     
> def report_hole_cards(self, table_id: str, seat: int, cards: List[str]):
> """Bot reports its hole cards to the coordinator."""
> table = self.get_or_create_table(table_id)
> table["cards"][seat] = cards
> table["bots"].add(seat)
>     
> def get_all_known_cards(self, table_id: str) -> List[str]:
> """Returns all cards known to the team (for dead card calculation)."""
> table = self.tables.get(table_id, {})
> known = []
> for seat, cards in table.get("cards", {}).items():
> known.extend(cards)
> known.extend(table.get("board", []))
> return known
>     
> def calculate_team_recommendation(self, table_id: str, requesting_seat: int) -> dict:
> """Calculates optimal action considering all teammate cards."""
> table = self.tables.get(table_id)
> if not table:
> return {"action": "FOLD", "reason": "no_table_data"}
>         
> my_cards = table["cards"].get(requesting_seat, [])
> dead_cards = self.get_all_known_cards(table_id)
>         
> # Calculate equity with dead cards removed
> # (In production, use OMPEval or pbots_calc)
> teammate_equities = []
> for seat, cards in table["cards"].items():
> if seat != requesting_seat:
> teammate_equities.append({
> "seat": seat,
> "cards": cards,
> # equity calculation would go here
> })
>         
> return {
> "my_cards": my_cards,
> "dead_cards": dead_cards,
> "teammates": teammate_equities,
> "action": "CALL", # placeholder for actual logic
> "reason": "coordinated_play"
> }
> 
> coordinator = TableCoordinator()
> 
> @app.websocket("/ws/{table_id}/{seat}")
> async def websocket_endpoint(websocket: WebSocket, table_id: str, seat: int):
> await websocket.accept()
> coordinator.connections.setdefault(table_id, []).append(websocket)
>     
> try:
> while True:
> data = await websocket.receive_text()
> message = json.loads(data)
>             
> if message["type"] == "HOLE_CARDS":
> # Bot reports its cards
> coordinator.report_hole_cards(
> table_id, 
> seat, 
> message["cards"]
> )
> # Broadcast to all bots at table
> for conn in coordinator.connections[table_id]:
> await conn.send_json({
> "type": "CARDS_UPDATE",
> "all_known": coordinator.get_all_known_cards(table_id)
> })
>             
> elif message["type"] == "REQUEST_ACTION":
> # Bot asks what to do
> recommendation = coordinator.calculate_team_recommendation(
> table_id, 
> seat
> )
> await websocket.send_json({
> "type": "ACTION_RECOMMENDATION",
> **recommendation
> })
>             
> elif message["type"] == "BOARD_UPDATE":
> coordinator.tables[table_id]["board"] = message["cards"]
>                 
> except WebSocketDisconnect:
> coordinator.connections[table_id].remove(websocket)
> 
> # Run with: uvicorn coordination_server:app --host 0.0.0.0 --port 8443
> 
> ```

> **Bot Client Example (Connects to Coordinator)**
>
> ```python
> # bot_client.py
> import asyncio
> import websockets
> import json
> 
> class CoordinatedBot:
> def __init__ (self, table_id: str, seat: int, server_url: str):
> self.table_id = table_id
> self.seat = seat
> self.server_url = f"{server_url}/ws/{table_id}/{seat}"
> self.ws = None
> self.known_cards = []
>     
> async def connect(self):
> self.ws = await websockets.connect(self.server_url)
> asyncio.create_task(self.listen())
>     
> async def listen(self):
> async for message in self.ws:
> data = json.loads(message)
> if data["type"] == "CARDS_UPDATE":
> self.known_cards = data["all_known"]
> print(f"[Seat {self.seat}] Team knows: {self.known_cards}")
> elif data["type"] == "ACTION_RECOMMENDATION":
> print(f"[Seat {self.seat}] Recommended: {data['action']}")
>     
> async def report_cards(self, cards: list):
> """Call when dealt hole cards."""
> await self.ws.send(json.dumps({
> "type": "HOLE_CARDS",
> "cards": cards
> }))
>     
> async def request_action(self):
> """Call when it's your turn."""
> await self.ws.send(json.dumps({
> "type": "REQUEST_ACTION"
> }))
> 
> # Usage:
> async def main():
> bot1 = CoordinatedBot("pokerstars_12345", seat=3, server_url="ws://localhost:8443")
> bot2 = CoordinatedBot("pokerstars_12345", seat=7, server_url="ws://localhost:8443")
>     
> await bot1.connect()
> await bot2.connect()
>     
> # When dealt cards:
> await bot1.report_cards(["Ah", "Kh"])
> await bot2.report_cards(["Qc", "Jc"])
>     
> # Now both bots know 4 cards total
> # Dead card equity calculation uses 48-card deck instead of 52
>     
> await asyncio.sleep(1)
> await bot1.request_action() # Gets coordinated recommendation
> 
> asyncio.run(main())
> 
> ```

* * *

> **Statistical Red Flags**
>
> AI Algorithms can identify the following patterns: Players who consistently play together at the same tables. This may include joining together, leaving tables together, and making suspicious gameplay decisions.
> 
> **What investigators look for:**
> 
> - Identical preflop frequencies
> - Same WTSD (Went To ShowDown) percentages
> - Never betting against each other
> - Folding strong hands to small bets from “partners”
> - Simultaneous login/logout
> 
> Collusion can often be detected by finding any of several detectable patterns (such as folding good hands to a small bet, as it is known that another player has a better hand).
> 
> **The 2+2 forum method:**  
> Players track statistical anomalies across thousands of hands, looking for accounts that behave identically or show impossible patterns (like always knowing when to fold the second-best hand).

> **How Sites Are Fighting Back**
>
> PokerStars’ new anti-cheating technology uses machine learning models trained on millions of hands to detect statistical anomalies. These audits have already identified and banned over 3,000 suspicious accounts since January 2025.
> 
> **Multi-layer detection:**  
> The new anti-cheating system uses a multi-layered approach to security. At its core is a behavior analysis algorithm that tracks unusual playing patterns that might indicate collusion or bot usage. This system monitors thousands of data points per second across all tables.
> 
> **Adaptive algorithms:**  
> When the system encounters an unfamiliar pattern, it doesn’t simply flag it—it incorporates this new information into its knowledge base. This means cheaters can’t simply make minor adjustments to bypass detection.
> 
> **But here’s the problem:**  
> Detection remains challenging, with sites employing secret anti-bot measures while players develop their own methods for identifying automated opponents. The financial incentives are substantial enough that sophisticated operations continue despite the risks.

* * *

## 🛠 Creator-Tier Resources: Build It Yourself

* * *

### 🤖 Ready-to-Run Bot Frameworks

> **dickreuter/Poker — The Gold Standard (2.3k ⭐)**
>
> **The most complete open-source poker bot.**  
> Works on: PartyPoker, PokerStars, GGPoker
> 
> ```bash
> git clone https://github.com/dickreuter/Poker.git
> cd Poker
> pip install -r requirements.txt
> 
> ```
> 
> **What’s inside:**
> 
> - OpenCV screen scraping (GUI mapper included)
> - Neural network card recognition
> - Monte Carlo equity calculation
> - Genetic algorithm decision making
> - Auto mouse movement
> - Strategy editor GUI
> 
> **Key files:**
> 
> - `poker/main.py` — Entry point
> - `poker/decisionmaker/` — Strategy logic
> - `poker/scraper/` — Table reading
> 
> **Pro tip:** Run poker client in VirtualBox, bot controls from outside. Avoids mouse conflicts.
> 
> 🔗 [github.com/dickreuter/Poker](https://github.com/dickreuter/Poker)  
> 🔗 [deepermind-pokerbot.com](http://www.deepermind-pokerbot.com) (binaries)

> **PokerGPT — GPT-4 Powered Bot**
>
> Uses GPT-4 for real-time decisions on PokerStars.
> 
> ```bash
> git clone https://github.com/HarperJonesGPT/PokerGPT.git
> 
> ```
> 
> **Why it matters:** LLM-powered bots are harder to pattern-detect than rule-based systems.
> 
> 🔗 [github.com/HarperJonesGPT/PokerGPT](https://github.com/HarperJonesGPT/PokerGPT)

> **PyPokerBot — Simple OpenCV + Tesseract**
>
> Lightweight bot using computer vision.
> 
> ```bash
> git clone https://github.com/gbencke/PyPokerBot.git
> pip install opencv-python pytesseract
> 
> ```
> 
> **Best for:** Learning how screen scraping works.
> 
> 🔗 [github.com/gbencke/PyPokerBot](https://github.com/gbencke/PyPokerBot)

> **MIT Pokerbots — Academic Framework (2026 updated)**
>
> Official MIT competition framework. Updated January 2026.
> 
> ```bash
> git clone https://github.com/mitpokerbots/engine-2026.git
> 
> ```
> 
> **Includes:**
> 
> - Game engine
> - Bot templates
> - Scrimmage server
> - Class resources
> 
> 🔗 [github.com/mitpokerbots](https://github.com/mitpokerbots)

* * *

### 🧮 Equity Calculators (Dead Card Support)

> **OMPEval — Fastest C++ Calculator**
>
> **Board cards and dead cards can be customized. Max 6 players. Uses multithreading automatically.**
> 
> ```cpp
> #include <omp/EquityCalculator.h>
> using namespace omp;
> 
> EquityCalculator eq;
> vector<CardRange> ranges{"QQ+,AKs", "A2s+", "random"};
> uint64_t board = CardRange::getCardMask("2c4c5h");
> uint64_t dead = CardRange::getCardMask("Jc"); // DEAD CARDS HERE
> 
> eq.start(ranges, board, dead, false);
> eq.wait();
> auto r = eq.getResults();
> 
> ```
> 
> **Speed:** 2-10x faster than Equilab per thread.
> 
> 🔗 [github.com/zekyll/OMPEval](https://github.com/zekyll/OMPEval)

> **pbots\_calc — MIT's Dead Card Calculator**
>
> **Built for collusion scenarios.**
> 
> ```bash
> # With dead cards (teammate has QcJc)
> ./calculator.sh AhKh:random --dead QcJc
> 
> ```
> 
> Supports common range syntax. The `--dead` flag is what makes card-sharing coordination work.
> 
> 🔗 [github.com/mitpokerbots/pbots\_calc](https://github.com/mitpokerbots/pbots_calc)

> **eval7 — Python Cython Speed**
>
> ```bash
> pip install eval7
> 
> ```
> 
> ```python
> import eval7
> 
> # Create deck, remove dead cards
> deck = eval7.Deck()
> dead_cards = [eval7.Card("Qc"), eval7.Card("Jc")]
> for card in dead_cards:
> deck.cards.remove(card) # Now calculating from 50-card deck
> 
> hand = [eval7.Card("Ah"), eval7.Card("Kh")]
> board = deck.sample(5)
> 
> ```
> 
> 🔗 [github.com/julianandrews/pyeval7](https://github.com/julianandrews/pyeval7)

> **poker-odds-calc — Node.js with Dead Cards**
>
> ```bash
> npm install poker-odds-calc
> 
> ```
> 
> ```bash
> poker-odds-calc -p AdKh -p AcKh -b 5sTd9c -d 2s2d # -d = dead cards
> 
> ```
> 
> 🔗 [github.com/siavashg87/poker-odds-calc](https://github.com/siavashg87/poker-odds-calc)

> **holdem-eval — CLI with Dead Cards**
>
> ```bash
> ./holdem-eval -b Ks5h2h -d 7d6d TT+,AJs+ random
> # -d 7d6d = teammate's cards removed from calculations
> 
> ```
> 
> Wrapper around OMPEval with full range support.
> 
> 🔗 [github.com/apometta/holdem-eval](https://github.com/apometta/holdem-eval)

> **deuces — Pure Python, 235k evals/sec**
>
> ```bash
> pip install deuces
> 
> ```
> 
> ```python
> from deuces import Card, Deck, Evaluator
> 
> evaluator = Evaluator()
> deck = Deck()
> 
> # Remove dead cards before sampling
> dead = [Card.new('Qc'), Card.new('Jc')]
> deck.cards = [c for c in deck.cards if c not in dead]
> 
> board = deck.draw(5)
> hand = deck.draw(2)
> score = evaluator.evaluate(board, hand)
> 
> ```
> 
> 🔗 [github.com/worldveil/deuces](https://github.com/worldveil/deuces)

* * *

### 📡 Coordination Servers (Real-Time Card Sharing)

> **casino-server — Node.js + Redis + Socket.io**
>
> **The backbone for multi-bot coordination.**
> 
> ```bash
> git clone https://github.com/floatinghotpot/casino-server.git
> cd casino-server
> npm install
> 
> ```
> 
> **Features:**
> 
> - WebSocket protocol with JS client API
> - Redis pub/sub for scaling
> - PM2 clustering for load balancing
> - Event logging
> 
> **Architecture:**
> 
> ```auto
> Bot A ─────┐
> Bot B ─────┼──► Redis ──► Coordination Logic ──► Action Commands
> Bot C ─────┘
> 
> ```
> 
> 🔗 [github.com/floatinghotpot/casino-server](https://github.com/floatinghotpot/casino-server)

> **node-poker-stack — Complete Poker Engine**
>
> ```bash
> git clone https://github.com/vampserv/node-poker-stack.git
> npm install
> 
> ```
> 
> **Features:**
> 
> - 10-player Texas Hold’em engine
> - WebSocket real-time communication
> - Backbone.js web client
> - Pluggable architecture
> 
> 🔗 [github.com/vampserv/node-poker-stack](https://github.com/vampserv/node-poker-stack)

> **pypoker — Python Redis Queue Architecture**
>
> ```bash
> git clone https://github.com/epifab/pypoker.git
> 
> ```
> 
> **Key insight:** Frontend clients communicate via WebSockets. Backend game services communicate via Redis queue. Completely decoupled — can be deployed on different servers.
> 
> ```json
> {
> "message_type": "connect",
> "server_id": "vegas123",
> "player": {"id": "bot_001", "name": "Bot1", "money": 1000.0}
> }
> 
> ```
> 
> 🔗 [github.com/epifab/pypoker](https://github.com/epifab/pypoker)

> **Derek Ries Botfarm — Complete Network Client**
>
> **A full async network client for poker with botfarm administration CLI.**
> 
> > “I developed a taskrunner that continuously ran tasks scheduled every x minutes, which basically amounted to automatically collecting free chips on a huge number of accounts in the botfarm. As well as a CLI that provided me an administrative route to control all those bots.”
> 
> **Stack:** Python / AsyncIO / aiohttp / WebSockets / Protocol Buffers / Redis
> 
> **Why network client \> screen scraping:**
> 
> > “A screen scraping method would be far too limited. Limited in the sense that I could only run a few bots at any one time because I’m limited by what fits on the screen.”
> 
> 🔗 [derekries.github.io/projects/pokerclient.html](https://derekries.github.io/projects/pokerclient.html)

* * *

### 👁 Screen Scraping & Card Recognition

> **OpenCV Playing Card Detector**
>
> ```bash
> git clone https://github.com/EdjeElectronics/OpenCV-Playing-Card-Detector.git
> 
> ```
> 
> Uses Raspberry Pi camera to identify playing cards. Adaptable to screen captures.
> 
> 🔗 [github.com/EdjeElectronics/OpenCV-Playing-Card-Detector](https://github.com/EdjeElectronics/OpenCV-Playing-Card-Detector)

> **poker-vision — Computer Vision for Cards**
>
> ```bash
> git clone https://github.com/MemDbg/poker-vision.git
> pip install opencv-python
> 
> ```
> 
> Uses image recognition + OCR to identify cards at a table.
> 
> 🔗 [github.com/MemDbg/poker-vision](https://github.com/MemDbg/poker-vision)

> **poker-hand-recognition — ML Card Classification**
>
> ```bash
> git clone https://github.com/predrag-njegovanovic/poker-hand-recognition.git
> pip install opencv-python keras tensorflow
> 
> ```
> 
> Uses neural networks for card recognition. More robust than template matching.
> 
> 🔗 [github.com/predrag-njegovanovic/poker-hand-recognition](https://github.com/predrag-njegovanovic/poker-hand-recognition)

* * *

### 🧠 AI Training Frameworks (CFR & Deep RL)

> **Deep-CFR — Scalable Deep Counterfactual Regret**
>
> **Used by researchers to train superhuman poker AI.**
> 
> ```bash
> git clone https://github.com/EricSteinberger/Deep-CFR.git
> cd Deep-CFR
> pip install -r requirements.txt
> python DeepCFR/leduc_example.py
> 
> ```
> 
> **What it does:** Trains Nash equilibrium strategies without expert knowledge. The bot learns to bluff.
> 
> 🔗 [github.com/EricSteinberger/Deep-CFR](https://github.com/EricSteinberger/Deep-CFR)

> **pycfr — Pure Python CFR**
>
> ```bash
> git clone https://github.com/tansey/pycfr.git
> 
> ```
> 
> ```python
> from pokercfr import CounterfactualRegretMinimizer
> cfr = CounterfactualRegretMinimizer(kuhn_rules)
> cfr.run(iterations=10000)
> nash_strategies = cfr.profile
> 
> ```
> 
> Supports vanilla CFR, Chance Sampling, Outcome Sampling, and Public Chance Sampling.
> 
> 🔗 [github.com/tansey/pycfr](https://github.com/tansey/pycfr)

> **HDCFR — Hierarchical Deep CFR**
>
> Skill-based poker AI with transfer learning.
> 
> ```bash
> git clone https://github.com/LucasCJYSDL/HDCFR.git
> 
> ```
> 
> 🔗 [github.com/LucasCJYSDL/HDCFR](https://github.com/LucasCJYSDL/HDCFR)

> **cfrx — JAX-Accelerated CFR**
>
> GPU-accelerated CFR using JAX.
> 
> ```bash
> pip install cfrx
> 
> ```
> 
> 🔗 [github.com/topics/counterfactual-regret-minimization](https://github.com/topics/counterfactual-regret-minimization)

> **poker\_ai (Fedden) — Open Source Pluribus**
>
> Pluribus implementation with WebSocket visualization.
> 
> ```bash
> git clone https://github.com/fedden/poker_ai.git
> 
> ```
> 
> 🔗 [github.com/fedden/poker\_ai](https://github.com/fedden/poker_ai)

* * *

### 🎭 Anti-Detection & Stealth

> **puppeteer-extra-plugin-stealth — Browser Fingerprint Evasion**
>
> ```bash
> npm install puppeteer-extra puppeteer-extra-plugin-stealth
> 
> ```
> 
> ```javascript
> const puppeteer = require('puppeteer-extra');
> const StealthPlugin = require('puppeteer-extra-plugin-stealth');
> puppeteer.use(StealthPlugin());
> 
> const browser = await puppeteer.launch({ headless: true });
> 
> ```
> 
> **What it patches:**
> 
> - Removes `navigator.webdriver` flag
> - Fixes `HeadlessChrome` in User-Agent
> - Adds `chrome.runtime`, `chrome.app`, `chrome.csi`
> - Fixes outer dimensions
> - Normalizes canvas fingerprint
> 
> 🔗 [github.com/berstend/puppeteer-extra](https://github.com/berstend/puppeteer-extra)

> **browser-fingerprinting — Evasion Research Bible**
>
> **Comprehensive analysis of bot protection systems with countermeasures.**
> 
> ```bash
> git clone https://github.com/niespodd/browser-fingerprinting.git
> 
> ```
> 
> Covers: FingerprintJS bypass, WebGL spoofing, AudioContext manipulation, native extension detection, and more.
> 
> 🔗 [github.com/niespodd/browser-fingerprinting](https://github.com/niespodd/browser-fingerprinting)

> **rebrowser-patches — Cloudflare/DataDome Bypass**
>
> Collection of patches for Puppeteer/Playwright to avoid detection.
> 
> ```bash
> git clone https://github.com/nicholasgriffintn/rebrowser-patches.git
> 
> ```
> 
> 🔗 [github.com/topics/puppeteer-extra](https://github.com/topics/puppeteer-extra)

> **Human-like Timing Randomization**
>
> ```python
> import random
> import time
> 
> def human_delay():
> """Bots that act instantly get caught."""
> base = random.uniform(1.5, 4.0)
> # 15% chance of "thinking harder"
> if random.random() < 0.15:
> base += random.uniform(2.0, 8.0)
> # 5% chance of distraction
> if random.random() < 0.05:
> base += random.uniform(10.0, 30.0)
> time.sleep(base)
> 
> def randomize_bet(optimal_bet):
> """Perfect bet sizes are suspicious."""
> variance = random.uniform(0.85, 1.15)
> return round(optimal_bet * variance, -1)
> 
> ```

* * *

### 📊 Hand History Parsing & Analysis

> **hhp — Multi-Room Parser (JS)**
>
> Parses PokerStars, Ignition, PartyPoker, Pacific (888).
> 
> ```bash
> npm install hhp
> 
> ```
> 
> ```javascript
> const { parse } = require('hhp');
> const hand = parse(handHistoryText);
> console.log(hand.players, hand.actions, hand.board);
> 
> ```
> 
> 🔗 [github.com/thlorenz/hhp](https://github.com/thlorenz/hhp)

> **poker-log-parser — Rust/Python Speed**
>
> ```bash
> pip install poker-log-parser
> 
> ```
> 
> Blazingly fast Rust core with Python bindings.
> 
> 🔗 [pypi.org/project/poker-log-parser](https://pypi.org/project/poker-log-parser/)

> **poker Python Library — PokerStars Parser**
>
> ```python
> from poker.room.pokerstars import PokerStarsHandHistory
> 
> hh = PokerStarsHandHistory(hand_text)
> hh.parse()
> 
> print(hh.players) # Player names, stacks, seats
> print(hh.hero) # Your cards
> print(hh.board) # Community cards
> 
> ```
> 
> 🔗 [poker.readthedocs.io](https://poker.readthedocs.io/en/latest/handhistory.html)

* * *

## 🛠 The Creator’s Toolkit: Build It Yourself

> _“Where curiosity meets creation — and every idea finds its hack.”_

This is where 1Hackers become **creators**. These aren’t just reading materials — they’re building blocks. Open-source code you can fork, modify, and run.

* * *

### 🔥 Core Bot Frameworks (Open Source)

> **Working Poker Bot Implementations**
>
> | Repository | What It Does | Stars | Language |
> | --- | --- | --- | --- |
> | [dickreuter/Poker](https://github.com/dickreuter/Poker) | **Production-ready bot** for PokerStars, PartyPoker, GGPoker. Screen scraping (OpenCV), genetic algorithms, Monte Carlo equity. Works today. | 2.3k+ | Python |
> | [OpenHoldem/openholdembot](https://github.com/OpenHoldem/openholdembot) | Mature, full-featured open source bot framework. Includes OpenScrape for table reading. Active community. | 200+ | C++ |
> | [fedden/poker\_ai](https://github.com/fedden/poker_ai) | MCCFR implementation for Texas Hold’em. CLI interface, trained models, lookup tables. | 1k+ | Python |
> | [gbencke/PyPokerBot](https://github.com/gbencke/PyPokerBot) | Simple bot with server/client architecture. Tesseract OCR + Flask API + Monte Carlo. Good starter project. | 100+ | Python |
> 
> **Why these matter:**  
> These aren’t tutorials — they’re **working code** that plays on real platforms. Study the screen scraping, decision engines, and anti-detection timing.

> **Multi-Player AI Frameworks (The Science)**
>
> | Repository | What It Does | Why It Matters |
> | --- | --- | --- |
> | [google-deepmind/open\_spiel](https://github.com/google-deepmind/open_spiel) | DeepMind’s framework for multi-agent RL in games. Supports poker variants, CFR, MCCFR. | The gold standard for research |
> | [datamllab/rlcard](https://github.com/datamllab/rlcard) | RL toolkit for card games. Blackjack, Leduc, Texas Hold’em, Dou Dizhu. Easy interfaces. | Plug-and-play environments |
> | [EricSteinberger/PokerRL](https://github.com/EricSteinberger/PokerRL) | Framework for multi-agent deep RL in poker specifically. | Designed for multi-bot training |
> 
> **Installation:**
> 
> ```bash
> pip install open_spiel # DeepMind's framework
> pip install rlcard # Rice/Texas A&M toolkit
> 
> ```

* * *

### ⚡ GTO Solvers (Free & Open Source)

> **Solve Poker Like the Pros — For Free**
>
> | Tool | Description | Link |
> | --- | --- | --- |
> | **TexasSolver** | Open-source, matches PioSolver results, free for personal use. GUI + Console. | [github.com/bupticybee/TexasSolver](https://github.com/bupticybee/TexasSolver) |
> | **WASM Postflop** | Browser-based GTO solver. Discounted CFR algorithm. No installation needed. | [wasm-postflop.pages.dev](https://wasm-postflop.pages.dev/) |
> | **Desktop Postflop** | Native port of WASM Postflop. Faster than browser version. | [github.com/b-inary/desktop-postflop](https://github.com/b-inary/desktop-postflop) |
> | **TexasHoldemSolverJava** | Java-based solver with Python API. Turn/river faster than PioSolver. | [github.com/bupticybee/TexasHoldemSolverJava](https://github.com/bupticybee/TexasHoldemSolverJava) |
> 
> **Why solvers matter for bot rings:**  
> GTO solutions tell each bot what the “perfect” play is. When combined with dead card knowledge, they compute _exactly_ when the human is behind.

* * *

### 🧮 Hand Evaluation Libraries

> **Fast Equity Calculation Code**
>
> | Library | Speed | Language | Link |
> | --- | --- | --- | --- |
> | **Treys** | 235k evals/sec (5 card) | Python 3 | [github.com/ihendley/treys](https://github.com/ihendley/treys) |
> | **Deuces** | Same engine, legacy | Python 2/3 | [github.com/worldveil/deuces](https://github.com/worldveil/deuces) |
> | **PokerStove** | 10M+ evals/sec | C++ | [github.com/andrewprock/pokerstove](https://github.com/andrewprock/pokerstove) |
> | **SKPokerEval** | 142k evals/sec (7 card) | C++ | [github.com/kennethshackleton/SKPokerEval](https://github.com/kennethshackleton/SKPokerEval) |
> | **PokerKit** | Most hand types supported | Python | [arxiv.org/pdf/2308.07327](https://arxiv.org/pdf/2308.07327) |
> 
> **Quick start (Python):**
> 
> ```python
> pip install treys
> 
> from treys import Card, Evaluator, Deck
> evaluator = Evaluator()
> board = [Card.new('Ah'), Card.new('Kd'), Card.new('Jc')]
> hand = [Card.new('Qs'), Card.new('Th')]
> print(evaluator.evaluate(board, hand)) # 1600 = straight
> 
> ```
> 
> **Dead card calculation:**  
> When you know opponent cards, simply remove them from the deck before running Monte Carlo simulations. This is the mathematical core of card-sharing advantage.

* * *

### 🎯 CFR Implementations (The Algorithm That Solved Poker)

> **Counterfactual Regret Minimization Code**
>
> | Repository | Description | Link |
> | --- | --- | --- |
> | **pycfr** | Clean Python CFR for Kuhn/Leduc poker. Great for learning. | [github.com/tansey/pycfr](https://github.com/tansey/pycfr) |
> | **CFR-Explained** | Annotated implementations with explanations. Best learning resource. | [github.com/brianberns/CFR-Explained](https://github.com/brianberns/CFR-Explained) |
> | **simple-poker-cfr** | Minimal CFR for simplified Hold’em | [github.com/ArmanMielke/simple-poker-cfr](https://github.com/ArmanMielke/simple-poker-cfr) |
> | **HDCFR** | Hierarchical Deep CFR (skill-based). Academic paper implementation. | [github.com/LucasCJYSDL/HDCFR](https://github.com/LucasCJYSDL/HDCFR) |
> 
> **Original papers:**
> 
> - [Regret Minimization in Games (Zinkevich 2007)](https://poker.cs.ualberta.ca/publications/NIPS07-cfr.pdf) — The foundational paper
> - [CFR Tutorial (LabML)](https://nn.labml.ai/cfr/index.html) — Interactive explanation

> **Pluribus Open-Source Attempts**
>
> The Facebook Pluribus paper sparked many implementation attempts:
> 
> | Fork | Notes |
> | --- | --- |
> | [fedden/poker\_ai](https://github.com/fedden/poker_ai) | Most complete, actively maintained |
> | [whatsdis/pluribus](https://github.com/whatsdis/pluribus) | Chrome extension approach for Bodog |
> | [keithlee96/pluribus-poker-AI](https://github.com/keithlee96/pluribus-poker-AI) | MCCFR + game engine integration |
> 
> **Key insight:**  
> Pluribus uses “depth-limited search” during play — it doesn’t solve the entire game, just the next few moves in real-time. This is how bots stay responsive.

* * *

### 📚 Academic Resources

> **Research Papers (Detection & Collusion)**
>
> | Paper | Authors | Key Contribution |
> | --- | --- | --- |
> | [Information-Theoretic Collusion Detection](https://proceedings.mlr.press/v180/bonjour22a.html) | Bonjour et al. (2022) | Mutual information between agent actions detects collusion |
> | [Automating Collusion Detection](https://poker.cs.ualberta.ca/publications/AAAI13.pdf) | U Alberta CPRG (2013) | “Collusion tables” capture advantage without assuming behavior |
> | [Can We Prevent Collusion?](https://www.researchgate.net/publication/31596956) | Smed et al. (2006) | Foundational collusion taxonomy |
> | [Multi-Agent RL Collusion Survey](https://openreview.net/pdf?id=Ylh8617Qyd) | OpenReview (2024) | Comprehensive survey of LLM multi-agent collusion risks |
> 
> **University Alberta Computer Poker Research Group:**  
> [poker.cs.ualberta.ca](https://poker.cs.ualberta.ca/) — Created Cepheus, Polaris, DeepStack. All publications available.

> **Landmark AI Papers**
>
> | AI | Paper | What It Did |
> | --- | --- | --- |
> | **Cepheus** | [Bowling et al. (2015)](http://science.sciencemag.org/content/347/6218/145) | “Essentially solved” heads-up limit Hold’em |
> | **DeepStack** | [Moravčík et al. (2017)](https://science.sciencemag.org/content/356/6337/508) | First AI to beat pros at heads-up no-limit |
> | **Libratus** | [Brown & Sandholm (2017)](https://science.sciencemag.org/content/359/6374/418) | Beat 4 pros over 120k hands |
> | **Pluribus** | [Brown & Sandholm (2019)](https://science.sciencemag.org/content/365/6456/885) | First AI to beat 6-player poker |

* * *

### 🔗 Curated Resource Lists

> **Awesome Lists & Community Hubs**
>
> | Resource | Description |
> | --- | --- |
> | [awesome-poker](https://github.com/apehex/awesome-poker) | ⭐ **Start here** — Curated list of poker tools, bots, research, competitions |
> | [GitHub poker topic](https://github.com/topics/poker) | All poker-tagged repos, sorted by activity |
> | [GitHub poker-bot topic](https://github.com/topics/poker-bot) | Bot-specific repositories |
> | [TwoPlusTwo Forums](https://forumserver.twoplustwo.com/) | Active community, bot-hunting threads |
> | [GipsyTeam News](https://www.gipsyteam.com/) | Russian poker news, regular bot exposés |
> 
> **Competitions (for training/testing):**
> 
> - [ACPC](http://www.computerpokercompetition.org/) — Annual Computer Poker Competition
> - [MIT Pokerbots](https://mitpokerbots.com/) — MIT’s annual bot competition
> - [PokerWars.io](https://pokerwars.io/) — Online bot testing platform

* * *

### 📊 Industry Analysis

> **Platform Security Reports**
>
> **PartyPoker Game Integrity (Official)**
> 
> - [Collusion Detection Methods](https://www.partypoker.com/blog/en/poker-collusion-what-is-it-and-how-do-we-detect-it.html)
> - [Bot Detection Approach](https://www.partypoker.com/blog/en/detecting-poker-bots-our-approach-and-insights.html)
> 
> **Bot Ring Investigations (Community)**
> 
> - [GGPoker 14-bot ring (Oct 2025)](https://www.gipsyteam.com/news/11-10-2025/ggpoker-bot-report-forums)
> - [ACR 51-bot PLO investigation (Jan 2024)](https://www.gipsyteam.com/news/08-02-2024/charlie-carrel-bot-accusations)
> - [PokerStars PLO ring ($1.5M)](https://www.pokertube.com/article/458-pokerstars-plo-bot-ring-under-investigation)
> 
> **Bloomberg Coverage (2024)**
> 
> - Bot Farm Corporation / Deeplay exposé
> - Industrial-scale operations in Omsk, Russia
> - 10,000+ customers including professional players

* * *

### 🧠 Quick Start Path

For a 1Hacker who wants to understand this space:

```auto
Week 1: Theory
├── Read awesome-poker README
├── Watch Pluribus paper summary videos
└── Run WASM Postflop in browser

Week 2: Code
├── pip install treys
├── Build equity calculator script
├── pip install rlcard && run tutorials

Week 3: Build
├── Clone dickreuter/Poker
├── Study OpenCV screen scraping
├── Modify decision engine

Week 4: Research
├── Read CFR-Explained repo
├── Run pycfr on Kuhn poker
└── Study DeepStack paper

```

* * *

_These are the building blocks. What you create with them is up to you._

* * *

## ⚠ What This Means For You

> **If You Play Online Poker**
>
> **Signs you might be at a bot ring table:**
> 
> - Same players always at your tables
> - Never see them bet into each other
> - Unusual fold patterns (strong hands folding to small bets)
> - All join/leave within minutes of each other
> - Robotic timing (no variance in decision speed)
> 
> **What you can do:**
> 
> - Report suspicious accounts to the site
> - Track patterns in your HUD
> - Avoid tables where the same 3+ players always appear
> - Play on sites with strong KYC (geofenced US sites have fewer bots)
> 
> In the United States, geofenced sites operating within individual states like Michigan appear to have fewer bot problems, likely due to stricter KYC (Know Your Customer) requirements and smaller player pools.

> **The Uncomfortable Truth**
>
> Perhaps more concerning than individual bots are coordinated bot networks where multiple AI players share information at the same table. This form of collusion creates an insurmountable advantage, as the bots effectively see each other’s cards while competing against human opponents.
> 
> **The cat-and-mouse never ends:**  
> When bot accounts get banned, operators simply create new identities and continue operations. This cat-and-mouse game has become a permanent feature of the online poker ecosystem.
> 
> You’re not paranoid. They’re out there. And they’re organized.

* * *

## 🎓 The Bottom Line

A coordinated bot ring sharing cards in real time creates an information asymmetry that humans cannot overcome through skill.

**The simple version:**

- You see 2 cards
- They see 6+ cards
- They never waste chips fighting each other
- They only attack when math says you lose

**The result:**  
They extract more than the house takes in rake — from a game designed to give the house its edge.

That’s not poker. That’s farming.

* * *

_Now you know how the machine works. What you do with that is your hack._

---

<div class="post-metadata">

**Author:** ![nikitin.sergey1998](https://onehack.st/user_avatar/onehack.st/nikitin.sergey1998/32/167665_2.png) [@nikitin.sergey1998](https://onehack.st/u/nikitin.sergey1998)\
**Post date:** [January 20, 2026, 8:36pm UTC](https://onehack.st/t/poker-bot-rings-how-card-sharing-networks-extract-300k-month-from-your-tables/317065/2 "2026-01-20T20:36:23Z")

</div>

Very detailed analysis, thank you.

---

<div class="post-metadata">

**Author:** ![adbenn91](https://onehack.st/user_avatar/onehack.st/adbenn91/32/152792_2.png) [@adbenn91](https://onehack.st/u/adbenn91)\
**Post date:** [January 21, 2026, 6:43am UTC](https://onehack.st/t/poker-bot-rings-how-card-sharing-networks-extract-300k-month-from-your-tables/317065/3 "2026-01-21T06:43:57Z")

</div>

I like your Job @SRZ Keep everyday giving us new

Really Amazing