Reset: x/y where x=total resets performed.
y=maximum number of resets.
Avg price: average price of all matched bets.
Winning trades in a row: winning trades in a row since
the last reset.
Losing trades in a row: losing trades in a row since
the last reset.
Winning reset in a row: count of consecutive reset
with profit.
Losing reset in a row: count of consecutive reset
with loss.
Last trade: datestamp of the last trade.
Status: shows if there are issues with the strategy.
Initial Capital: 20 Trigger: Automatic Type: BACK Progression: Capital % Bets Per Trade: 1
This strategy is a good start to understand how automatic strategies work.
On the WIN market of all the downloaded horse races, one minute at the start, BACK the favourite with a price between 1.5 and 3.9.
The runner must have won its last race and the total amount of matched money on the runner must be greater than 1/2 of the total amount matched on the market.
The bet size is 1/100 of the current capital, offset to a minimum of 1/100 of the initial capital.
Max 3 open bets at the same time, in 3 different markets.
The BACK overround of the market must be fair (lower than 105).
If the bet remains unmatched the price is updated (every 5 seconds) to the current best BACK price, without going below 1.5.
Strategy suspends placing bets till the day after if it has lost more than 4 (currency units) in a day.
Variables used in the strategy:
@capital,
@id_favourite_[1-6],
@id_horse,
@initial_capital,
@form,
@runner_tam,
@tam
Initial Capital: 25 Trigger: Automatic Type: BACK Progression: Chasing Losses Bets Per Trade: 1
This strategy pretends to have a bankroll bigger than your bad luck!
One minute at the start, BACK the favourite with a price between 1.7 and 5.3, to win 1/500 of the initial capital plus all the losses accumulated with previous losing bets.
Only one bet at a time.
If the bet is unmatched the price is updated to the best BACK price at that moment.
The BACK overround of the market must be fair.
The strategy stops if it has won more than 50% of the initial capital.
Variables used in the strategy:
@capital,
@id_favourite_[1-6],
@id_horse,
@id_strategy,
@initial_capital,
@fees
Functions used in the strategy:
dbo.fn_StrategyProperty
Initial Capital: 25 Trigger: Automatic Type: LAY Progression: Chasing Losses Bets Per Trade: 1
This is the LAY version of the strategy Auto - Chase Losses BACK.
One minute at the start, LAY the second favourite with a price between 2.3 and 5.3, to win 1/500 of the initial capital plus all the losses accumulated with previous losing bets.
Only one bet at a time.
If the bet is unmatched the price is updated to the best LAY price at that moment.
The LAY overround of the market must be fair.
The strategy stops if it has won more than 50% of the initial capital.
Variables used in the strategy:
@capital,
@id_favourite_[1-6],
@id_horse,
@id_strategy,
@initial_capital,
@fees
Functions used in the strategy:
dbo.fn_StrategyProperty
Initial Capital: 50 Trigger: Automatic Type: BACK Progression: D'Alembert Bets Per Trade: 1
This strategy is the adaptation to horse racing of a famous roulette betting system.
The D'Alembert progression has the following rules:
Initial Capital: 100 Trigger: Automatic Type: BACK Progression: Labouchere Bets Per Trade: 1
A classic progression based on even odds. It shows a structured path to profit, but losses can spiral.
Labouchère starts with a sequence of numbers representing the profit target. It places bets with a size equal to the sum of the first and last numbers, crosses them out in case of a win, and adds the lost bet to the end in case of a loss. When the sequence is cleared, the round is won, and the profit equals the total sum of the sequence.
In this Labouchère implementation example, we BACK horses on the PLACE markets with a price between 1.9 and 2.1, using the following sequence of numbers: 0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.05, 0.04, 0.03, 0.02, 0.01. The first bet size is the sum of the first and last numbers (0.01 + 0.01 = 0.02). If the bet is won, these two amounts are crossed from the sequence, and the next bet size is the sum of the first and last remaining numbers in the sequence (0.02 + 0.02 = 0.04). If the bet is lost, the lost amount is appended to the sequence.
Bets are placed 40 seconds at the start. The number of runners must be fewer than 13. Only one open trade is allowed at a time. The overround must be fair.
The daily stop loss is set at half of the initial capital.
The strategy stops placing bets when it has completed 100 winning rounds before depleting the capital.
You can view the status of the sequence using the Labouchere Monitor.
Since bets are placed on prices between 1.9 and 2.1, the sum of the first and last numbers is not the stake, as previously stated for the sake of clarity, but rather the required winning amount.
Variables used in the strategy:
@id_strategy,
@initial_capital,
@fees
Functions used in the strategy:
dbo.fn_LabouchereSize
Initial Capital: 100 (1 x 100 rounds) Trigger: Automatic Type: BACK Progression: Reverse Labouchere Bets Per Trade: 1
It is the reverse progression of the Labouchere system applied to Greyhound betting. There is no loss chasing, only win accumulation with a trailing stop-win. The strategy needs to win at least two-thirds of the trades to be profitable, but in return, when there is a profit, it is a consistent one.
Like the standard Labouchere system, this variant places bets with a size equal to the sum of the first and last numbers, but in case of a loss, those numbers are crossed out; in case of a win, the won amount is added to the end. The round is lost when the sequence is cleared.
The initial sequence of stakes is : 0.05, 0.08, 0.13, 0.21, 0.21,0.13, 0.08, 0.05, for a total of 0.94.
The dbo.fn_LabouchereRevSize allows you to specify a trailing stop-win: when the total net winnings exceed a certain amount, the strategy can no longer use a specified percentage of the winnings. In this implementation, the triggering amount is 4, and the saved amount is 50% of the winnings.
There is no final stop-win, but the maximum bet size is capped at 200.
Bets are placed 2 minutes at the start. Only one open trade is allowed at a time. The overround must be fair.
You can view the status of the sequence using the Labouchere Monitor with the option 'Reverse Labouchere' checked.
Variables used in the strategy:
@id_strategy,
@initial_capital,
Functions used in the strategy:
dbo.fn_LabouchereRevSize
Initial Capital: 50 Trigger: Automatic Type: BACK Progression: Capital % Bets Per Trade: 1
This strategy is an example of betting on selections with a recursive name.
150 seconds at the start, on the market type 'FORECAST' and 'REV_FORECAST', place a BACK bet on all the combinations of runners with number 5-6-7.
When the market type is 'REV_FORECAST', six bets are placed with a size of 1/500 of the capital. If the market is 'FORECAST', three bets are placed with size 1/250 of the capital.
The strategy can play on maximum of 3 markets at the same time. Maximum daily loss is 5.
The strategy places bets only on combinations with a price equal or greater than 6.
Variables used in the strategy:
@capital,
@horse_name,
@initial_capital,
@market_type
Initial Capital: 15 Trigger: Automatic Type: BACK → LAY Progression: Capital % Bets Per Trade: 4
This strategy gets money from chaotic races.
On GB and IE WIN markets, one minute at the start, place three in-play persistent BACK bets on every runner with a price between 1.5 and 23. Maximum five runners played in a market. Maximum two markets played at the same time.
The first bet is placed at a price 290% greater than the actual best BACK price of the runner. The second bet at +590%, and the third bet a +1190%. As soon as the third bet is matched in-play, a fourth LAY bet is placed to hedge the position at price 1.25.
The bet size goes from a minimum of 1/500 to a maximum of 1/300 of the actual capital.
The strategy has a daily stop win of 10 times the initial capital.
Notes:
Initial Capital: 50 Trigger: Automatic Type: LAY Progression: Capital % Bets Per Trade: 1
This strategy takes advantage of the higher inertia of the favorites' price.
On GB and IE WIN markets, on runners with a pre-race price lower than 4, place a LAY bet if the price in-play overtakes 8.5.
The bet is placed at the current best LAY price, offset to a maximum price of 14. The responsability of the bet is equal to 1/25 of the initial capital.
The bet is deleted if it remains unmatched for more than 8 seconds. Maximum one bet per market, including deleted ones.
Only races longer than 1500 meters are played.
If you want to transform this strategy to a manual strategy, read how to do from the notes of Auto - InPlay - Crazy Finish.
Variables used in the strategy:
@id_horse,
@id_race,
@initial_capital
Functions used in the strategy:
dbo.fn_RaceHorseProperty,
dbo.fn_RaceProperty
Initial Capital: 100 Trigger: Automatic Type: LAY Progression: Fixed Amount Bets Per Trade: 1 max
Early price drops in a race, often happen without a logic reason.
The principle of this strategy is to place LAY bets, at extremely favorable prices for us, as soon as the race goes in-play.
These bets, each one with a responsability equal to 1/50 of the intial capital, are kept pending in the market only for a certain amount of seconds, that is proportional to the race distance (7 seconds every 1000 meters). Only races longer than 1200 meters are played.
Bets are placed on runners with a price between 2 and 13, which aren't the first favorite, at a price 50% lower than the last matched pre-race price.
A large number of bets is placed every day, but only a small percentage of them are matched, and those ones, statistically, should have a better value for us.
Notes:
Bankroll: 10 (0.5 initial capital x 20 rounds) Trigger: Automatic Type: BACK Progression: Masaniello Bets Per Trade: 1
Masaniello is a brilliant progression which uses a complex factorial algorithm to calculate the bet size. The progression was invented by Girolamo Cardano (pen name Masaniello) who was a physician, mathematician, philosopher, astrologer, and a gambler.
The goal of the progression is to get a certain number of wins on a certain number of events, keeping the profit as well the loss pre determined. Ipposnif uses a simplified version of the Masaniello considering only runners with similar price (in a range).
In this case we want to get 5 winners with a price between 4.2 and 4.8 on a total of 8 events. The chance to win is 1/36 considering an average price of 4.
The initial capital of the strategy (0.5) is the total amount spent in one Masaniello round.
'Max Reset' is the number of times we want to restart the progression when it loses as well it wins. In this case we want a maximum of 19 reset that means a total of 20 rounds.
Bets are placed in the timeframe that goes from 40 seconds at the start to two minutes after the programmed start time, only if the race is still not in-play and if the overround of the market is fair.
The bet is placed only if there is only one runner in the race with a price between 3.6 and 4.9.
The strategy stops if it has finished the rounds.
Notes:
Initial Capital: 2 (per day) Trigger: Automatic Type: BACK Progression: Masaniello Bets Per Trade: 1
This strategy is a variant of the strategy Auto - Masaniello BACK 5-8@4.
In this case we want to get 2 winners with a price between 4.2 and 4.8 on a total of 15 events. The return of a winning round is around 10% of the Initial Capital, considering an average price of 4. All the eventual winnings are capitalized in the next round.
There is no limit in the number of rounds (99999) and the strategy reset itself after every winning or losing round. In case of a losing round, the strategy suspends betting till the day after. The strategy stops if it has won more than 5 times the Initial Capital.
Variables used in the strategy:
@capital,
@id_strategy,
@initial_capital,
@bid_type,
@last_reset_historical_profit
Functions used in the strategy:
dbo.fn_MasanielloSize,
dbo.fn_StrategyProperty
Initial Capital: 50 Trigger: Automatic Type: LAY Progression: Capital % Bets Per Trade: 1
Outsiders' price has a high volatility that can be exploited by automatic strategies.
Ten minutes at the start, LAY a maximum of three outsiders trying to get matched on the BACK side of the market.
The gap between the best BACK price and the best LAY price must greater than 30%.
If the price moves and the bet is still umatched, the price is updated with an interval of 60 seconds.
The maximum LAY price allowed for a bet is 100.
Maximum three markets open at the same time (so a maximum of 9 open LAY bets at the same time).
The bet size is 1/1000 of the Initial Capital.
The strategy stops if it has won or lost more than 20% of the initial capital in one day.
Bets are placed only on Horse Racing WIN markets.
Variables used in the strategy:
@base_rate,
@best_back_price,
@best_lay_price,
@capital,
@initial_capital
Functions used in the strategy:
dbo.fn_PercDiff
Initial Capital: 50 Trigger: Automatic Type: BACK → LAY Progression: Fixed Amount Bets Per Trade: 3 max
Scalping and trading strategies have a lower variance and pay lower betfair fees compared to betting strategies.
From 16 to 6 minutes at the start, perform a trade with a BACK entry bet of size 1/20 of current capital and an exit bet of type LAY that hedges the current position 2 ticks below the entry bet price.
Trades are created if the WOM (Weight Of Money) is less than 0.28 and the gap between the best BACK price and the best LAY price is less than 3 ticks.
The entry bet is cancelled if it remains unmatched for more than 45 seconds or if the price drifts away for more than 5 ticks.
The third bet is placed to hedge the losses if the market is against us for more than 5 ticks or at 15 seconds at the start of the event.
A maximum of two runners on a maximum of three markets can be played at the same time.
WOM is calculated with the following formula (where Bx and Lx are the available stake amounts for the best 5 BACK and LAY prices):
(B1 + B2*0.5 + B3*0.25 + B4*0.12 + B5*0.06) / (B1 + B2*0.5 + B3*0.25 + B4*0.12 + B5*0.06 + (B1 + B2*0.5 + B3*0.25 + B4*0.12 + B5*0.06 + L1 + L2*0.5 + L3*0.25 + L4*0.12 + L5*0.06)
You can personalize this formula changing the SQL function fn_wom in the Ipposnif database.
Bets are placed only on Horse Racing GB/IE WIN markets.
The strategy suspends betting till the day after, if it has won or lost more than 20% of the Initial Capital in one day.
Variables used in the strategy:
@best_back_price,
@best_lay_price,
@id_horse,
@id_race,
@initial_capital
Functions used in the strategy:
dbo.fn_TickDiff,
dbo.fn_WOM
Bankroll: 20.80 (2 x 0.52 initial capital x 20 rounds) Trigger: Automatic Type: LAY Progression: Capital % Bets Per Trade: 1
Yankee is a gambling system which aim to produce big wins in a short time.
The two strategies, Place and Win, are meant to be run together, but you can decide to run only one of them. Each strategy has its own independence, but they cannot bet on different horses when they bet on the same market.
Both of them place bets on the runner with the lowest price greater than 1.50. One bet at one time.
A Yankee is a betting system in which the chosen runners, on different events (5 in this configuration), are combined together to form accumulators. The accumulators cover all the combinations of doubles, trebles, fold-4 and fold-5 of the events. One strategy creates WIN accumulators, the other creates PLACE accumulators.
In this configuration we have a round formed by 5 events that produces 26 different accumulators. You can read more about the Yankee combinations from the function dbo.fn_YankeeSize.
Each one of the accumulators has a cost of 1/26 of the round capital (26 x 0.02 = 0.52). In this configuration each one of the two strategy will play for a maximum of 20 rounds.
The round capital of these two strategies is set from the Options, in the Global Variable @global_08. In default it has a value of 0.52. So you can change the bet amounts of both the strategies, changing this single global variable.
If a historical profit (profit at the start of the round) is present, 1/8 of this profit is added to the next round capital.
Max daily loss is 5 times the default round capital plus 1/3 of the eventual historical profit.
Bet size is offset to produce a maximum win of 10000.
Variables used in the strategy:
@best_back_price,
@global_[1-8],
@id_horse,
@id_race_placed,
@id_race_win,
@id_strategy,
@initial_capital,
@last_reset_historical_profit
Functions used in the strategy:
dbo.fn_StrategyId,
dbo.fn_TradeCount,
dbo.fn_YankeeSize
Initial Capital: 1000 Trigger: Manual Type: BACK & LAY Progression: Arbitrary Bets Per Trade: 1
This strategy is the only resident system strategy. It cannot bet deleted and only a few parameters can be modified.
With the Free Hand strategy you can place BACK or LAY bets in the number you want, like you do with the Betfair website.
To place a bet insert the price and the size of the bet clicking the cell 'BACK' or 'LAY' in the grid of the runners.
A right-click opens a betting frame of the opposite Bid Type (BACK/LAY).
All the controls present in the betting frame are explained here.
To place another bet simply insert price and size of the new bet.
You can change the default size of the bet from the options.
This video will show how to use this strategy and how to cash out a position.
Initial Capital: 20 Trigger: Manual Type: BACK Progression: Capital % Bets Per Trade: 1
Classic Dutching variant, in which the responsability is pre determined instead of the eventual win.
Dutch the selected runners with BACK bets with a responsability of 1/20 of the initial capital.
To place the bets, first select the runners to 'dutch' using their checkbox, then trig the bets checking the market selector (top-right of the main screen, close to the strategies drop-down).
The hedge price is the best BACK price. Unmatched bets are kept in-play.
Only one bet is allowed on the same runner on the same market. If you want to dutch more sets of runners on the same market, you can clone the strategy in multiple copies and link them to Hot Buttons.
Variables used in the strategy:
@id_horse,
@id_race,
@id_strategy,
@initial_capital,
@is_market_selected
Functions used in the strategy:
dbo.fn_Dutching
Initial Capital: 20 Trigger: Manual Type: LAY Progression: Capital % Bets Per Trade: 1
This is the LAY version of the strategy Manual - Dutching BACK.
Dutch the selected runners with LAY bets to get a win of 1/50 of the initial capital.
Initial Capital: 250 Trigger: Manual Type: LAY → BACK Progression: Fixed Amount Bets Per Trade: 2 max
Laying losers in-play.
This strategy is a faster variant of the Manual - LAY Insured Input, and it is meant to be used in-play and with larger stakes.
Perform a trade with an entry LAY bet, with a liability equal to 1/5 of the initial capital, that is kept not hedged unless the price falls below 1/4 of the matched price. To start a trade simply check the runner.
The best LAY price of the runner must be lower than 50. If the price is higher than 50, a LAY bet is placed at 50/1 waiting to get matched for a maximum of 10 seconds.
Notes:
Initial Capital: 50 Trigger: Manual Type: LAY → BACK Progression: Fixed Amount Bets Per Trade: 2 max
Laying losers pre-race.
Perform a trade with an entry LAY bet, with a liability equal to 1/10 of the initial capital, that is kept not hedged unless the price falls below the inputted hedge price.
To start a trade simply insert the hedge price in the column 'Input'. The best LAY price of the runner must be lower than 20. If the price is higher than 20, a LAY bet is placed at 20/1 waiting to get matched for a maximum of 10 seconds.
This strategy is meant to be used pre-race.
Variables used in the strategy:
@best_back_price,
@input_price
Initial Capital: 20 Trigger: Manual Type: LAY Progression: Capital % Bets Per Trade: 1
This strategy gets money when two or more runners get involved in a "ding-dong" finish.
LAY the selected runners with a bet size equal to 1/20 the current capital at 1.51 price. The minimum bet size is 1.
To select all the runners at the same time use the checkbox in the header of the first column of the runner grid.
If two or more bets are matched there is a guaranteed profit.
Variables used in the strategy:
@capital
Initial Capital: 20 Trigger: Manual Type: BACK Progression: Fixed Amount Bets Per Trade: 1
Normally this strategy is cloned in different amounts, and linked to Hot Buttons.
BACK the runners checked by the user with a bet of size 1. When the bet is created, the checkbox is cleared, and the user can eventually check again the runner and place a new bet.
To increase the chance to get matched in-play, an adjustment of -10% is applied to the best BACK price.
Initial Capital: 20 Trigger: Manual Type: BACK Progression: Fixed Amount Bets Per Trade: 2
Double Or Bust! Normally this strategy is cloned in different amounts, and linked to Hot Buttons.
Perform a trade on the runners checked by the user with an entry bet of type BACK with size 2.
As soon as the entry bet is matched, the strategy creates an exit bet of type LAY that hedges the position with a 100% profit.
When the entry bet is created, the checkbox is cleared, and the user can eventually check again the runner and place a new bet.
To increase the chance to get matched in-play, an adjustment of -5 ticks is applied to the best BACK price.
Variables used in the strategy:
@id_trade
Functions used in the strategy:
dbo.fn_BetProperty
Initial Capital: 300 Trigger: Manual Type: BACK & LAY Progression: Fixed Amount Bets Per Trade: 1
Fastest way to place BACK and LAY bets.
With this strategy you can place BACK or LAY bets in the number you want with a single left or right-click.
To place a BACK bet, left click one of the columns that contain the BACK prices in the row corresponding to the wanted horse.
To place a LAY bet, left click one of the columns that contain the LAY prices.
Instead with a right-click on the price cells, you place a bet of the opposite type of the clicked cell.
The price will be the one of the clicked column, the size of the bet is specified in the Bet Size criteria.
Variables used in the strategy:
@manual_input_price
Initial Capital: 100 Trigger: Manual Type: BACK & LAY Progression: Arbitrary Bets Per Trade: 3 max
Scalping is a few ticks trading.
Perform a trade in which the entry bet is placed manually by the user (like in the strategy Manual - Free Hand) and as soon as it is matched, an hedge bet with 1 tick of gain is placed.
If the prices moves to the wrong direction for more than 4 ticks, the trade is hedged in loss.
Variables used in the strategy:
@best_back_price,
@best_lay_price,
@bid_type,
@id_trade,
@manual_input_size
Functions used in the strategy:
dbo.fn_BetProperty,
dbo.fn_TickDiff
Initial Capital: N/A Trigger: Schedule Type: BACK Progression: Capital % Bets Per Trade: 1
This strategy is a variant of the Auto - Yankee*5 Win BACK strategy. In this case, the selections are made manually by the user, and the accumulators consist of three selections, where doubles and trebles are placed.
The capital is 0.5 for each accumulator, plus 1/5 of the eventual positive profit of the strategy. Bet size is offset to a maximum of 500.
This strategy uses fn_AccumulatorSize, an improved function compared to the older Yankee version.
Variables used in the strategy:
@initial_capital
Functions used in the strategy:
dbo.fn_AccumulatorSize
Initial Capital: 20 Trigger: Schedule Type: BACK Progression: Capital % Bets Per Trade: 1
This strategy is a good start to understand how scheduling strategies work.
One minute at the start, BACK all the manually selected runners with a bet size of 1/100 of the current capital offset to a minimum of 1/100 of the initial capital. The bet price is the best BACK price. User can select runners on every market type.
Variables used in the strategy:
@capital,
@initial_capital
Initial Capital: 20 Trigger: Schedule Type: BACK Progression: Capital % Bets Per Trade: 1
How to implement a custom progression.
One minute at the start, on the WIN market, BACK one at one time, all the manually selected runners. The bet size follow the five steps of the custom progression in loss specified in the criteria 'Bet Size': 1, 2, 4, 7, 14. The value of one unit is 1/100 of the initial capital.
At the first winning bet the progression restarts from step 1. The strategy restarts from step 1 also if it gets five losses in a row.
The best BACK price of the runner must be between 1.8 and 3.0.
Variables used in the strategy:
@id_strategy,
@initial_capital
Functions used in the strategy:
dbo.fn_CustomProgression
Initial Capital: 50 Trigger: Schedule Type: BACK Progression: Capital % Bets Per Trade: 1
To stick a red flag to a horse, right-click the horse name → Flag Runner → Red. Once the flag has been sticked, it remains for all the horse's future races until the user removes it.
One minute at the start, on the WIN market, BACK with a stake of 1/100 of the current capital the runner with a red flag. If two or more red flags are present in the same race, the lowest price is played.
The bet size is offset to a minimum of 1/100 of the initial capital.
Minimum BACK price is 1.5. Maximum 5 bets, on different markets, at one time. Overround of the market must be fair.
Maximum daily loss is 10% of the actual capital.
Notes:
Initial Capital: 50 Trigger: Schedule Type: BACK Progression: Capital % Bets Per Trade: 1
This is the LAY version of the strategy Schedule - BACK Red Flags.
One minute at the start, on the WIN market, LAY with a responsability of 1/50 of the current capital, all the runners with a blue flag. Maximum LAY price is 11. If there are two or more blue flagged runners in the same race, the one with the highest price is chosen.
Maximum 5 bets, on different markets, at one time. Maximum daily loss is 10% of the actual capital.
Variables used in the strategy:
@capital,
@initial_capital
Initial Capital: 50 Trigger: Schedule Type: LAY → BACK Progression: Flat Bets Per Trade: 2
Classic Soccer strategy that shows how to automatically manage a trade in win as well in loss
This strategy can be used on all the sports that have a market with a selection called "The Draw".
One minute at the start, on the MATCH ODDS market of the events selected by the user, LAY the draw with a responsability equal to 10% of the initial capital. Maximum 5 matches played at the same time.
To select the events, you have to show the column Selected in the events grid.
LAY price of the draw must be between 3.00 and 3.9. Bets are placed only if the market's overround is fair.
After the bet is matched, if the BACK price falls below 1.98 the trade is hedged in loss, if the BACK price overcomes 4.5 the trade is hedged in profit.
The strategy suspends betting till the day after, if it has lost more than 20% of the Initial Capital in one day.
Variables used in the strategy:
@best_back_price,
@id_trade,
@initial_capital ,
@is_event_selected
Functions used in the strategy:
dbo.fn_BetProperty
Bankroll: 25 (5 initial capital x 5 rounds) Trigger: Schedule Type: BACK Progression: Masaniello Bets Per Trade: 1
This is a scheduling variant of the Auto - Masaniello BACK 5-8@4 and it is meant to be used on the Correct Score market of Soccer events.
The user must manually select the Correct Scores played by the strategy, and on 8 events, the user needs to catch two correct scores.
The capital used in one Masaniello round is 5 (in your currency) and the eventual minimum net winning is 150% of the invested amount. The strategy stops betting when it has finished the five rounds..
The price of reference is 6, so the user should select correct scores with a price between 6.4 and 9, which are the most common ones.
Variables used in the strategy:
@id_strategy,
@initial_capital,
@bid_type
Functions used in the strategy:
dbo.fn_MasanielloSize
Bankroll: 0.50 Initial Capital x 20 rounds = 10 Trigger: Schedule Type: BACK Progression: Accumulator Bets Per Trade: 1
Accumulators played on the Exchange have a much larger gain compared to accumulators played on the Sportbook.
One minute at the start, BACK the runners selected by the user, one at a time, using all the current capital. User can select runners on every market type.
The capital starts with 0.5 and all the winnings are capitalised.
The strategy resets itself every losing runner (the capital is lower than 0.03).
The strategy also resets if it has won more than 100 times the initial capital.
The reset is triggered a maximum of 19 times (20 rounds in total * 0.5 = 10 total risked capital).
Bets are placed only if the race is not in-play and if the overround of the race is fair.
The price is the best BACK price, updated every 5 seconds, with option market_on_close ON.
The bet size is offset, in any case, to a maximum of 50.
Variables used in the strategy:
@capital,
@initial_capital,
@last_check_bet_seconds
Bankroll: 2.00 Initial Capital x 10 rounds = 20 Trigger: Schedule Type: LAY Progression: Accumulator Bets Per Trade: 1
This is the LAY version of the strategy Schedule - Multiple BACK.
LAY the runners selected by the user, one at a time, using all the current capital of the strategy as liability. The capital starts with 2 and all the winnings are capitalised.
The strategy resets itself every winning runner (lost for us, the capital is lower than 0.03) or when it has won more than 5 times the initial capital. The reset is triggered a maximum of 9 times (10 rounds in total * 2 = 20 total risked capital).
Bets are placed only if the race is not in-play and if the overround of the race is fair.
The price is the best LAY price, updated every 5 seconds.
The bet size is offset, in any case, to a maximum of 50.
Variables used in the strategy:
@capital,
@initial_capital,
@last_check_bet_seconds
Initial Capital: 50 Trigger: Auto Type: BACK Progression: Flat Bets Per Trade: 1
BACK the runners from the tipping service as soon as they are downloaded. The temporary price is 1000 and the final price is the 'Market On Close' price (starting price).
The bet size is 1/50 of the Initial Capital.
Variables used in the strategy:
@id_horse,
@id_race,
@initial_capital
Functions used in the strategy:
dbo.fn_IsImportedTip
Initial Capital: 100 Trigger: Auto Type: BACK Progression: Decimal Fibonacci Bets Per Trade: 1
BACK the runners from the tipping service as soon as they are downloaded. The temporary price is 1000 and the final price is the 'Market On Close' price (starting price).
The stakes follow an original implementation of the Fibonacci progression.
Variables used in the strategy:
@capital,
@id_horse,
@id_race,
@initial_capital
Functions used in the strategy:
dbo.fn_FibonacciBiggest,
dbo.fn_IsImportedTip
Bankroll: 22 (1.1 initial capital x 20 rounds) Trigger: Auto Type: BACK Progression: Yankee Bets Per Trade: 1
One minute at the start, one at a time, BACK the runners from the tipping service following the Yankee-4 progression.
A maximum of 20 Yankee-4 rounds are played.
20% of the eventual historical net profit is invested in the next round.
Variables used in the strategy:
@id_horse,
@id_race,
@id_strategy,
@initial_capital,
@last_reset_historical_profit
Functions used in the strategy:
dbo.fn_IsImportedTip,
dbo.fn_YankeeSize
Initial Capital: 50 Trigger: Auto Type: LAY Progression: Fixed amount Bets Per Trade: 1
LAY the runners from the tipping service, as soon as they are downloaded, with a responsability equal to 1/50 of the initial Capital.
Variables used in the strategy:
@id_horse,
@id_race,
@initial_capital
Functions used in the strategy:
dbo.fn_IsImportedTip
Initial Capital: 5 each Round Trigger: Auto Type: LAY Progression: Flat Bets Per Trade: 1
One minute at the start, LAY the runners from the tipping service using a Masaniello progression 3 wins out of 4 events. The capital of a Masaniello round is 5 plus the eventual winnings accumulated in the previous rounds. The price of reference for the Masaniello function is 5, but the strategy will bet runners with a price lower than 8, adjusting the size to have the same responsability.
The strategy stops at the first won or lost round in the current day. There is no limit to the number of rounds played by the strategy, but maximum one round played every day.
Due to the responsability adjustment, the winnings could be lower than expected. So, in this Masaniello implementation, only the loss can be pre-determined and the win remains uncertain till the end of the progression.
Variables used in the strategy:
@best_lay_price,
@id_horse,
@id_race,
@id_strategy,
@initial_capital,
@last_reset_historical_profit
Functions used in the strategy:
dbo.fn_IsImportedTip,
dbo.fn_MasanielloSize,
dbo.fn_StrategyProperty
Initial Capital: 50 Trigger: Auto Type: LAY → BACK Progression: Capital % Bets Per Trade: 3 max
Perform a trade LAY → BACK on the runners from the tipping service with a liability of 1/25 of the actual capital.
The LAY bet, opening the trade, is placed as soon as the tips are downloaded. Bets are placed if there are more than 15 minutes at the start. The trade is hedged if the prices goes against us for more than 15% of the matched price, or if the prices goes in our favor for more than 25%. The trade is hedged in any case at 60 seconds at the start.
Variables used in the strategy:
@best_back_price,
@capital,
@id_horse,
@id_race,
@id_trade,
@overround_back,
@seconds_to_the_start
Functions used in the strategy:
dbo.fn_BetProperty,
dbo.fn_IsImportedTip,
dbo.fn_PercDiff