How the Martingale betting strategy works

Promises sure victory in theory, but we put the Martingale betting strategy to a practical test. Does doubling down work? Review with simulations and video.

The Martingale method originated in 18th-century France and remains one of the most well-known betting strategies to this day. Its popularity can be attributed to three things:

• It can be applied in almost any game of chance where increasing the bet is allowed per round. However, it is most commonly used in games like roulette, blackjack, or poker
• Its application is very simple, as it requires little calculation or attention during the game.
• Theoretically, it can guarantee victory.

How it works in roulette?

As we know, in roulette we can bet on whether the ball will land in a red or black slot. If we guess correctly, we win an amount equal to our bet, meaning if the bet is $100, then the winnings are also $100 (along with the bet, it totals $200, which we get back).

Let's assume that we bet $100 on red. According to the Martingale strategy, if we lose the bet, we double the stake in the next round, that is, we put $200 on red. This ensures that if red wins, we recover the $100 lost in the first round, and we also gain an extra $100. If black were to win again, we would once again double the stake, placing $400 on red. Essentially, we keep doubling our bet on red until it comes up. Once it does, we can restart the process, resetting the base bet back to $100.

Practical limitations

In practice, this method is mainly limited by two factors:

1. We don't have an infinite amount of money at our disposal. If we're very unlucky, we could lose bets over a long series, and eventually, we won't have enough to recover our losses. It's important to note that there have been recorded instances in history where a particular color came up 32 times in a row on a roulette wheel. Imagine if we were just playing with a starting bet of $100, by the 20th lost bet in a row, we would need to place $52 million.
2. The casino sets a limit on the maximum bet amount. So even if we had enough capital, due to this restriction, we can't endlessly increase our bets. Therefore, in case of a very long unlucky streak, we could lose a large amount of money.

Betting table

To help you with the use of this strategy, we have created an Excel spreadsheet where you can enter the size of your starting bet, and then find out how much more you have to bet in case of each loss. You can use this for roulette or a similar game where you can win back double your stake. Similarly, you can use the table below which assumes a $100 starting bet. The table also shows the probability for a loosing streak in European roulette (such as black/red bets).

Does it work long-term? Simulation

To answer the question, we've created a computer program that simulates 10,000 roulette spins and a simulated player who applies this strategy. You can also view the source code of this simulation in this article.

Having run the simulation, that is, the 10,000 roulette spins, 100 times, we found that this strategy was only able to result in a profit 11 times. In these cases, the player ended up with an amount between twice and six times their starting capital. However, in the majority of cases, that is, the remaining 89 times, the players' balance ran out well before the 10,000th round.

Conclusion

What can be generally said is that this strategy is capable of generating a positive balance in the short term. However, sooner or later, the player encounters a streak of bad luck, resulting in the loss of all their capital.

Simulation source code

You can run the Python code for the Martingale simulation. It is best suited to run in a Jupyter notebook environment, such as the free Google Colab notebook.

import random
import seaborn as sns
import matplotlib.pyplot as plt

mpockets = ["Red"] * 18 + ["Black"] * 18 + ["Green"] * 1
mrolls = []

def makeRandomRolls():
  global mrolls
  mrolls = []
  mi = 0
  while mi < 10000000:
    mi += 1
    mrolls.append(random.choice(mpockets))

def always_red_Martingale(bankroll, maxspin):  
    bankroll = 100
    bet = 1
    currentSpin = -1
    pockets = ["Red"] * 18 + ["Black"] * 18 + ["Green"] * 1
    bankroll_history = []
    roll_history = []
    betTrigger = False
    while (bankroll > 0) and (currentSpin < maxspin):
        currentSpin = currentSpin + 1
        roll = mrolls[currentSpin]
        roll_history.append(roll)

        if bet > bankroll:
          bet = bankroll
          #print('!!! BET Larger than bankrol. Setting max bet to: ' + str(bankroll))

        if betTrigger == True:
          if roll == "Red":
            #print('!!! Bet placed and Won. Bet was: ' + str(bet))
            bankroll += bet
            bet = 1
            betTrigger = False
          else:
            bankroll -= bet
            bet *= 2
            #print('!!! Bet placed and LOST. New bet is: ' + str(bet))

        if (currentSpin > 2) and \
        (roll_history[-1] == "Black") and \
        (roll_history[-2] == "Red"):
          betTrigger = True
        
        bankroll_history.append(bankroll)
    return bankroll_history

sns.set(rc={'figure.figsize':(18.7,8.27)})

MS = 10000
makeRandomRolls()

plt.plot(always_red_Martingale(bankroll=100,maxspin=MS), linewidth=2, label='Player using Martingale strategy, always bets on red (with 1 USD)')
   
plt.xlabel("Number of roulette spins", fontsize=18, fontweight="bold")
plt.ylabel("Balance (USD)", fontsize=18, fontweight="bold")
plt.xticks(fontsize=16, fontweight="bold")
plt.yticks(fontsize=16, fontweight="bold")
plt.title("How balance changes with each roulette spin (bet)", fontsize=22, fontweight="bold")
plt.legend(loc="upper left")