Poker Bot Betting Strategy: Sizing Raises by Street

Your poker bot betting strategy probably has one raise size: min-raise or pot. That's costing you chips. Street-by-street sizing, where you scale your raises based on board texture, position, and pot geometry, consistently outperforms static approaches by 2-4 bb/100 in 6-max games. Pairs well with opponent modeling for maximum effect.

Part of: The Complete Guide to Building an AI Poker Bot in 2026 — the full pillar covering frameworks, decision logic, equity, testing, and where to compete.

We've run over 50,000 hands on Open Poker's 10/20 No-Limit Hold'em tables across three seasons. The single biggest differentiator between top-quartile bots and middle-of-the-pack ones isn't hand selection or bluff frequency. It's bet sizing. A bot that raises 2.5x pre-flop and sizes 60-75% pot on the flop extracts more value from strong hands and folds out more weak ones than a bot that always min-raises or always pots it.

Why does static bet sizing lose chips?

Static sizing is predictable, and predictable means exploitable. If your bot always min-raises pre-flop (to 40 chips at 10/20 blinds), opponents get cheap looks at flops with speculative hands. If it always bets pot on every street, it overcommits chips with marginal holdings and builds pots it can't win.

The core problem: a single bet size carries zero information about hand strength. Opponents who track your patterns (and good bots do) learn that your 40-chip raise means the same thing as your 100-chip raise. Nothing.

Human poker pros solved this decades ago. Ed Miller's "The Course" (2015) popularized the concept of "street-by-street planning," where each bet size is chosen relative to the pot and your goal for the hand. Your bot should do the same thing.

What's the right pre-flop raise size?

Pre-flop sizing sets the tone for the entire hand. Too small and you let everyone in cheap. Too large and you only get action from hands that beat you.

The standard formula for a 6-max game at 10/20 blinds:

def preflop_raise_size(big_blind, position, num_limpers=0):
    """Calculate pre-flop raise-to amount.
 
    Standard: 2.5x BB from late position, 3x from early.
    Add 1 BB per limper who entered the pot.
    """
    multiplier = 3.0 if position in ("UTG", "HJ") else 2.5
    base = big_blind * multiplier
    limper_adjustment = big_blind * num_limpers
    return base + limper_adjustment

At 10/20 blinds, this gives you:

Why 2.5-3x instead of the minimum 2x? A 2023 analysis by PokerCoaching.com found that 2.5x open-raises from late position achieve the optimal balance between fold equity and pot building. Smaller opens let too many players see the flop. Larger opens narrow the field so much that you only get called by premium hands.

I tested this myself with two versions of the same bot on Open Poker: one min-raising (2x) and one using the position-adjusted formula above. Over 5,000 hands each, the position-adjusted bot won 1.8 bb/100 more. Not a huge edge per hand, but it compounds.

How should you size flop bets?

The flop is where bet sizing gets interesting. You've seen three community cards, the pot is established, and your bet needs to accomplish a specific goal: extract value, protect your hand, or set up a bluff on later streets.

The two key variables are pot size and board texture.

def flop_bet_size(pot, board_texture):
    """Calculate flop bet as a fraction of pot.
 
    Dry boards (unpaired, no draws): bet smaller, 33-50% pot.
    Opponents have fewer draws to call with, so big bets
    just fold out everything.
 
    Wet boards (flush/straight draws): bet larger, 66-75% pot.
    Charge draws the wrong price. A flush draw has ~35% equity
    on the flop; a 75% pot bet gives them only 30% pot odds.
    """
    if board_texture == "dry":
        return int(pot * 0.4)   # 40% pot
    elif board_texture == "wet":
        return int(pot * 0.7)   # 70% pot
    else:
        return int(pot * 0.55)  # 55% pot, default

Dry board example: Flop is K-7-2 rainbow. Pot is 100 chips. Your bot holds KQ. Bet 40 (40% pot). Opponents with weak pairs and high cards will call, but they're drawing nearly dead. Bigger bets just fold them out and you win less.

Wet board example: Flop is J-T-8 with two hearts. Pot is 100 chips. Your bot holds AA. Bet 70 (70% pot). Straight draws (Q9, 97) and flush draws need to pay a premium to chase. At 70% pot, a pure flush draw getting 30% pot odds needs 35% equity to call profitably. They're paying the wrong price.

The actions reference explains how to send raise amounts. Remember: the amount field is raise-to, not the increment.

How do turn and river sizing differ?

The turn and river are where stack-to-pot ratio (SPR) takes over. As the pot grows and stacks shrink relative to it, your bets should be calibrated to set up an all-in on the river if you want one, or to keep the pot small if you don't.

def turn_bet_size(pot, my_stack, want_all_in_river=False):
    """Calculate turn bet size based on river plan.
 
    If planning to go all-in on the river, size the turn bet
    so that a pot-sized river bet equals your remaining stack.
    Otherwise, bet 55-65% pot.
    """
    if want_all_in_river:
        # Work backward: river all-in means river_bet = remaining_stack
        # After turn bet: pot_after = pot + 2*turn_bet (you bet, they call)
        # River pot-size bet: remaining = pot + 2*turn_bet
        # remaining = my_stack - turn_bet
        # So: my_stack - turn_bet = pot + 2*turn_bet
        # Solving: turn_bet = (my_stack - pot) / 3
        turn_bet = max(1, int((my_stack - pot) / 3))
        return min(turn_bet, my_stack)
    return int(pot * 0.6)
 
 
def river_bet_size(pot, my_stack, hand_strength):
    """River sizing: polarized between big value bets and checks.
 
    Strong hands (top pair+): bet 70-100% pot for value.
    Bluffs: bet 70-100% pot (same size as value, so opponents
    can't distinguish).
    Medium hands: check or bet small (30% pot) for thin value.
    """
    if hand_strength == "strong":
        return int(pot * 0.8)
    elif hand_strength == "bluff":
        return int(pot * 0.8)  # Same size as value bets
    elif hand_strength == "medium":
        return int(pot * 0.3)
    return 0  # Check

The key insight on the river: your value bets and bluffs should be the same size. If you bet big only with strong hands and small only with bluffs, any opponent tracking bet sizes will exploit you instantly. This is one of the few spots where game theory directly applies to bot construction. The 2019 Pluribus paper (Brown & Sandholm, Science) demonstrates that balanced sizing across hand strengths is critical even in multiplayer settings.

What does a complete sizing strategy look like?

Here's the full decision function tying all four streets together. This plugs directly into your bot's your_turn handler on Open Poker, using the game rules format (10/20 blinds, raise-to amounts).

def calculate_bet_size(your_turn_msg, my_cards, my_position, hand_eval):
    """Complete street-by-street bet sizing.
 
    Args:
        your_turn_msg: The your_turn WebSocket message
        my_cards: Your hole cards, e.g. ["Ah", "Kd"]
        my_position: "UTG", "HJ", "CO", "BTN", "SB", "BB"
        hand_eval: Dict with "strength" (0-1) and "category"
                   ("strong", "medium", "bluff", "weak")
    """
    actions = {a["action"]: a for a in your_turn_msg["valid_actions"]}
    board = your_turn_msg.get("community_cards", [])
    pot = your_turn_msg["pot"]
    my_stack = your_turn_msg["your_stack"]
 
    if "raise" not in actions:
        return None  # Can't raise, fall back to call/check/fold logic
 
    min_raise = actions["raise"]["min"]
    max_raise = actions["raise"]["max"]
 
    # Pre-flop
    if len(board) == 0:
        size = preflop_raise_size(20, my_position)
        return max(min_raise, min(size, max_raise))
 
    # Flop
    if len(board) == 3:
        texture = classify_board_texture(board)
        size = flop_bet_size(pot, texture)
        return max(min_raise, min(size, max_raise))
 
    # Turn
    if len(board) == 4:
        go_big = hand_eval["strength"] > 0.75 or hand_eval["category"] == "bluff"
        size = turn_bet_size(pot, my_stack, want_all_in_river=go_big)
        return max(min_raise, min(size, max_raise))
 
    # River
    if len(board) == 5:
        size = river_bet_size(pot, my_stack, hand_eval["category"])
        if size == 0:
            return None  # Check instead
        return max(min_raise, min(size, max_raise))
 
    return min_raise

This is about 80 lines of sizing logic total. Not complex, not slow. It runs in microseconds. But it makes your bot's betting pattern street-aware instead of street-blind.

How much does street-aware sizing actually help?

Here's what we measured across Season 2 (March 2026) on Open Poker, comparing three sizing approaches over 10,000+ hands each:

The min-raise bot bleeds chips. It wins pots, but they're small, and it pays too much to see showdowns it loses. The pot-size bot wins bigger pots but overcommits with weak hands and gets exploited by tight players who only continue with strong holdings.

The street-aware bot hits the middle ground. It builds pots when ahead, charges draws correctly, and doesn't overcommit when the board gets scary. The 3.1 bb/100 edge compounds to roughly 620 chips per 1,000 hands at 10/20 blinds. Over a 2-week season, that's the difference between mid-table and the top ten on the leaderboard.

One thing we didn't expect: the biggest gains came on the flop, not the river. Texture-based flop sizing alone accounted for about 60% of the improvement. If you're only going to change one thing about your bot's betting, make it flop sizing. The turn and river adjustments matter, but they're refinements on top of that foundation.

How do you classify board texture?

The sizing functions above reference board texture. Here's a simple classifier. It's not perfect, but it catches the most common patterns:

def classify_board_texture(board):
    """Classify flop texture as dry, wet, or medium.
 
    Dry: no flush draw, no straight draw, unpaired.
    Wet: flush draw possible, or 3 cards within 4 ranks.
    Medium: everything else.
    """
    suits = [card[1] for card in board]
    ranks = "23456789TJQKA"
    rank_indices = sorted([ranks.index(card[0]) for card in board])
 
    flush_draw = len(set(suits)) <= 2  # Two+ same suit
    span = rank_indices[-1] - rank_indices[0]
    straight_draw = span <= 4  # Cards within 4-rank window
 
    if flush_draw or straight_draw:
        return "wet"
    if not flush_draw and span > 6:
        return "dry"
    return "medium"

A board like K-7-2 rainbow scores "dry" (span of 11, no flush draw). J-T-8 with two hearts scores "wet" (span of 3, flush draw). Q-8-3 with all different suits scores "medium." Your flop sizing adapts accordingly.

This classifier is intentionally simple. It doesn't account for paired boards, Broadway-heavy textures, or monotone flops. Those are worth handling as special cases once you've got the basics working. But even this three-bucket approach outperforms a single fixed percentage by a wide margin.

For a full walkthrough of building a bot from scratch, including WebSocket connection handling and the action loop, check the bot building overview.

Start with these sizing formulas, run 500 hands, and compare your win rate before and after. The numbers speak for themselves. Register your bot and join the current season, or read the actions reference first to get your raise messages right.

FAQ

Should my poker bot use the same bet size for value bets and bluffs? Yes. If your value bets are 80% pot and your bluffs are 40% pot, any opponent tracking sizes will fold to big bets and call small ones. Use the same sizing for both so your betting range stays balanced. On the river, 70-80% pot works well for both categories.

What's the best pre-flop raise size for a 6-max poker bot? 2.5x the big blind from late position (button, cutoff) and 3x from early position (UTG, hijack). Add one big blind per limper. At 10/20 blinds, that's 50 from the button and 60 from UTG. These numbers come from standard 6-max NLHE theory and match what we've seen perform best on Open Poker.

How do I know if a flop is "wet" or "dry"? A wet flop has flush draws (two or more cards of the same suit) or straight draws (three cards within a 4-rank span, like J-T-8). A dry flop has none of these, like K-7-2 rainbow. Wet flops need larger bets (66-75% pot) to charge draws. Dry flops need smaller bets (33-50% pot) because opponents have fewer reasons to call.

Does bet sizing matter more than hand selection? They're both critical, but in bot-vs-bot play on Open Poker, we've found that sizing creates a bigger edge once your hand selection is already reasonable. A bot with solid starting hand criteria but flat sizing finishes mid-pack. The same bot with street-aware sizing jumps to the top quartile.

Can I just use a GTO solver for bet sizing? You can, but it's overkill for most Open Poker opponents. GTO sizing assumes your opponents play optimally. Most bots don't. The heuristic approach in this post (position-adjusted pre-flop, texture-based flop, SPR-based turn/river) captures 80% of the benefit at a fraction of the complexity. Save the solver for when you're already in the top ten.