Before-the-off and In-play Price Speculation

Let me tell you about another trading technique which is apparently common enough to prove to be successful in many high-liquid markets.

I think it is well-known that since 10-15 minutes before the off prices start changing very intensively and when the market turns in-play they may change dramatically from very low values up to the highest “1000” level. This fact opens many opportunities to speculate on price movements – with a certain share of luck of course.

For example favourites are often prices slightly higher before the off than directly after the race starts off. Therefore you can back on a favourite before the off and then lay at a lower price to cover the stake and secure equal profit on all runners in the list. The formula is quite simple and is given in another article, “Off-Set Betting”.

On the contrary, runners that don’t have big hopes upon them can be priced much higher after the off, especially when the race comes to its end.

You can back and lay on a horse manually to test this theory, but very soon you’ll understand that making the necessary calculations in your mind will take the precious time that you’ll need to manage to grab the price. Betting itself will last for around a second – and even during this time the market can drift in a wrong direction.

So you’ll obviously need some software assistance in executing the series of bets. It will make all the computing in no time and as accurately as only a computer can do (sorry for the pun). Moreover, it will automatically recognize the required price proportion based on the data it receives from the exchange. The refresh rate of a couple of seconds will guarantee that it’ll react faster than you would, sitting in front of the browser.

So how exactly can MarketFeeder Pro help you with this technique? Using trigger betting of course! Setting up the necessary triggers in the first time is a matter of several minutes (well, not exactly – if you copy an example from our web site it’ll take a couple of seconds). Then you can copy the same triggers for different races and other markets, or just apply the same trigger to all of them.

While talking about trigger betting I assume that you’re acquainted with the term. If you’re not please take a while to read the following article:

What is Trigger Betting?

Let’s review several situations that offer you a chance to apply price speculation

1. Backing High, Laying Low

Principle: to back a selection (for instance the favourite) at a best back price available 1 minute before the off. When the market goes in-play wait until the price drops down to a certain value lower than the initial back price – for example, 2 ticks and lower. As soon as it happens lay on the runner to make equal profit on all runners in the market.
Stop-Loss: if the runner’s price grows even higher, 5 ticks and more, and it’s more than – say – 40 seconds since the off, lay it in order to save your money.

Below is the trigger code for the rule. The three triggers are ready to add to MarketFeeder Pro trigger table.

Settings to configure:
“Allow triggering/offset no sooner than … mins before the event’s start” – set to “1”
“Allow triggers/booking/offset with In-Running Markets” – enable
“Max attempts on failure” – set to “-1”

Trigger 1, in row 5

Cell: "1"
Condition: "is equal to"
Trigger Value: "1"
Action: "back"
Price: "best"
Amount: "10"
Market: select from the list
Selection: “Winner”
Active: "once idle & wait"

The figure "10" in the Amount column is your original back stake amount, so adjust it accordingly when you change the back stake.

Trigger 2

Cell: "Triggers Worked Out"
Condition: "is equal to"
Trigger Value: "5"
Action: "lay"
Price: "lay_price"
Amount: "IF(AND(profit_loss>0, lay_price < bm_backp-2*p_tick), bm_backp*bm_backa/lay_price, 0)"
Market: the same as above
Selection: "All Matching Selections"
Active: "once in-play & wait"

I highlighted 2*p_tick to make it stand out from the rest of the formula. If you want to modify the number of ticks, just replace "2" with something else.

Trigger 3

Cell: "Triggers Worked Out"
Condition: "is equal to"
Trigger Value: "5"
Action: "lay"
Price: "lay_price"
Amount: "IF(AND(NOW() – event_off > 0.0004628, bm_laya=0, lay_price >= bm_backp + 5*p_tick), 10, 0)"
Market: the same as above
Selection: "All Matching Selections"
Active: "once in-play & wait"

Here’s the screenshot of the three triggers set up (click on the image to open the screenshot in a separate window):

The first trigger is designed to simply back the favourite (or “Winner”) at the best available price. Cell, Condition and Trigger Value are making a condition that is always true. This means that the trigger will be executed without any condition, but the settings we have configured won’t let it do it until it’s 1 min before the off. Pay attention to the Active field – it tells MarketFeeder Pro to back only whenthe market is in idle mode (that is, hasn’t started yet), and only once.

The second trigger is intended to bet when the market turns in-play – it’s stated in its Active field. Its condition is looking back at the first trigger – and only if it has been executed will the second trigger attempt to bet. As you can see from its Action field it should lay. The Price field contains a pre-defined trigger variable, a keyword that returns the current lay price of the selection in question. So lay_price stands for the lay price of the runner.
Now we come straight to the Amount field which is most important here. It contains a formula with two Excel functions – “IF” and “AND”, and several pre-defined variables. Let’s review each of them:

- AND function may return either true or false. It returns true if all the expressions in its brackets result in “true”. If at least one of them is false, the function will return false. Read the tutorial on using AND function here.
- IF function returns the second argument if the first argument is true. Otherwise it returns the third argument. In our case it will return bm_backp*bm_backa/lay_price if the AND function is true, and 0 – if it’s false. Read the tutorial on using IF function here.
- profit_loss – a variable that contains P/L figure for this selection. If we backed on it, profit_loss will be positive, and if we layed – it’ll be negative. The condition “profit_loss>0” is intended to check if the back bet in the first trigger was matched. It could be unmatched out of many reasons: for instance if you did not have sufficient funds in your account at the moment.
- lay_price – shows the current best lay price of the selection.
- p_tick  - a price tick calculated for the current price range. The price tick can vary depending on what the current odds are. For instance, if the odds are 2.4, then p_tick will return 0.02, and if the odds are 8.0, then p_tick will be equal to 0.2.
- bm_backp - the variable that returns the price of the last matched back stake. So if Trigger 1 is matched, this variable will return the odds at which the bet was matched. Accordingly, the construction bm_backp - 2*p_tick will give us the price 2 ticks lower than that.
- bm_backa - the variable returning the amount of the last matched back stake.
- bm_laya - the amount of the latest matched lay stake.
So the meaning of the formula in the Amount field is: return a valid bet amount only if the back stake has been matched and the lay odds are less than the initial back odds minus 2 ticks.

The formula bm_backa*bm_backp/lay_price calculates how much you need to bet at the current lay price to make equal profit on all runners. It’s a simple proportion: back payout divided by the lay price. For instance, if you back 10 GBP at 4.2, and the lay odds are 4.0, you need to lay £10.5 to win £0.5 at any outcome.

So, the Amount column can return either some figure or zero. In the first case MarketFeeder Pro will lay, in the second case it will remember that the amount was invalid and try again and again – until the end of the event or until the off.

The “All Matching Selections” value in the Selection field indicates that the second trigger will lay exactly on the same runner that was traded in the first trigger.

Now, the last trigger is an implementation of “Stop-Loss” function. The idea is the same as in trigger 2, only Amount field contains a different condition:
- NOW() – event_off > 0.0004628. NOW is an Excel function that returns current date and time in Excel date/time format. In that format 0.0004628 means 40 seconds. Read here about Excel date/time format. And event_off is a trigger variable which remembers the time at which the event has started (the actual start of event).
- lay_price >= bm_backp + 5*p_tick – this formula is almost identical to that in trigger 2, only it becomes true if the price is 5 or more ticks higher than the initial one.
If all conditions are met the third trigger will lay £10 on the same runner to cover those £10 that you once backed.

If you’re confident in your choice of runner you may omit the stop-loss trigger.

If you are going to bet both back and lay stakes before the off, then you can use a built-in function called "Offset Betting" which has special stop-loss options and doesn't require any formula definitions.

2. Laying Low, Backing High

Principle: to lay a selection (for instance the third-priced runner) at a best lay price available 1 minute before the off. When the market goes in-play wait until the price leaps up to 4 ticks higher than the initial lay price. As soon as it happens back on the runner to make equal profit on all runners in the market.
Stop-Loss: if the runner’s price reaches 1.5, and it’s more than 40 seconds since the off, back it to minimize the loss.

The triggers would look like this:

Trigger 1, row 5
Cell: "1"
Condition: "is equal to"
Trigger Value: "1"
Action: "lay"
Price: "best"
Amount: "10"
Market: choose from the drop-down list
Selection: "Third Winner"
Active: "once idle & wait"

Trigger 2
Cell: "Triggers Worked Out"
Condition: "is equal to"
Trigger Value: "5"
Action: "back"
Price: "back_price"
Amount: "IF(AND(profit_loss<0, back_price>bm_layp+4*p_tick), bm_layp*bm_laya/back_price, 0)"
Market: the same as above
Selection: "All Matching Selections"
Active: "once in-play & wait"

Trigger 3
Cell: "Triggers Worked Out"
Condition: "is equal to"
Trigger Value: "5"
Action: "back"
Price: “best”
Amount: “IF(AND(NOW() – event_off > 0.0004628, back_matched=0, back_price<=1.5), -profit_loss/(back_price-1), 0)”
Market: the same as above
Selection: "All Matching Selections"
Active: "once in-play & wait"

The idea of this sequence of triggers is contrary to the above, but the way they are calculated is similar. In the second trigger we check if the current back offer is greater than the initial lay price plus 4 ticks. If yes, we back the amount that creates equal profit on all runners. If not, the programme will be waiting for such situation until the end of the race or until the stop-loss trigger is executed.

The stop-loss trigger will check if the back price is below 1.5, and if it is, will back the amount needed to cover the loss of that very selection.
You can see a new trigger variable here, profit_loss. It returns the current P/L for the selection, either positive or negative, exactly as you would see it on BetFair.
For example: we lay £10 at the odds of 3.0 on the third winner. The loss in this case is -20. If the current back price is 1.5 we need to back –profit_loss/(back_price-1) to cover that liability of £20. That makes £40. Indeed 40*(1.5-1) is £20 - and we cover the liability.

All the formulas are familiar to hedge traders. You can customize them to meet your special requirements. For example, you may want to speculate on a single runner and not pursue the goal to equalize your profit on all runners. In this case you will win more if the runner wins and lose nothing if it loses. To adjust the formula you will need to correct the Amount field in the second trigger and instead of bm_layp*bm_laya/back_price put in simply “10” – the same amount as you bet in the first trigger.

You can try this technique with very small amounts just to check how it works. And it does work!

Can you imagine how much time you would spend on making these calculations in your mind? Watching the clock, making computations on paper? Isn’t it simpler to key in the formulas once, and then apply them automatically to many races?

Talking of races - if you don't trade in races, but rather in football matches you can apply the same triggers to the game, but substituting event_off with last_suspend. The latter is a trigger variable too, but it shows the time of the latest market suspension.

One final remark. I would certainly recommend withdrawing from this technique in races that have mileage shorter than 1 mile. You will simply risk too much in this case.

Don't forget that for hedging before the off you can use a built-in "Offset Trading" functions that are easy to customize and include automated stop-loss options.