Building Our First Betfair Bot IV - Talking to the API and storing your bets

*EDIT: In this piece, I originally said you needed to use the paid API to place bets; this is no longer the case*

In the last missive, I wrote about how we want to store data. In theory, we could use Betfair itself to store data – and pull everything we need on an ad hoc basis. So: if we want to see which bets are open, we'd query Betfair, and it would return a list of betIDs. But, this comes with two major problems: speed and cost. Betfair can charge as much as 0.5p for certain data intensive API calls: you need some pretty amazing programming and trading skills to overcome those costs.

So, our 'bot needs to store as much information locally as possible. And this means a (very simple) database – in our case SQLite. In today's missive, we're going to put a bet on, and then store it in our database.

The first thing we'll need is a programming language. I am going to be a little Windows-centric and use IronPython – the Microsoft implementation of Python 2.6. You'll also need this zip file: betfairdatabase.zip. This contains the following files:

betfair.py

lib.py

betfair.dll

→ these are the IronPython / Resolver Betfair libraries

SystemData.SQLite.dll

→ The .NET ADO SQLite connector

bettinghistory.s3db

→ An empty SQLite database

database.py

→ our database library

What we'd like to achieve (ultimately) is to put bets on, and then put them in a table that looks something like this:

After you've installed IronPython, it's time to have a play. For simplicities sake, copy the contents of the above folder into your IronPython directory. Now, run 'ipy.exe', which you'll find in the selfsame directory. You should get something that looks like this:

OK: Let's import the database module:

>>> import database

And create a new database connection object:

>>> dc = database.database()

Open the database file, so we can interact with it:

>>> dc.open('bettinghistory.s3db')

OK: so, what can we do with our database connection? Well, firstly we can record our betting activities. Let's set-up and record a bet:

>>> import betfair

>>> betfairGateway = betfair.BetfairGateway('username', 'password', productId = 22)

OK

(This assumes you have a Betfair paid API subscription. If you don't, you'll be reading, rather than doing.)

>>> betfairMarket = betfairGateway.GetMarketById(20692870)

We've set up a betfairMarket object for the winner of the World Cup 2010 (which, slightly surprisingly, Spain is the favourite to win.)

Shall we see who the runners are?

>>> for runner in betfairMarket.GetRunners()

... print runner, runner.Id, runner.Back

...

The screen should look something like this:

Now, I'm working on the theory that – if England moves out to 10-1 (11.0 in Betfair speak) – then I want some of that action. (Of course, the current price is 7.0, so that isn't very likely right now... but still...) To do this we have to get hold of the Betfair runner (selection) object:

>>> selection = betfairMarket.getRunner(27)

(We've gotten the selectionID by looking at the print-out above, and entering it manually. You'd probabaly want to iterate over GetRunners() until you got the object you wanted... but this will do for now.) And let's check we have the right object:

>>> selection, selection.Back

(England, 7.0)

Perfect: that looks like the right object, and we need to pass this object to the betfairGateway if we want to put a bet on:

>>> response = betfairGateway.Back(selection, 11, 2)

OK

The first thing we pass is the selection object, the second the desired odds, and finally the amount (in this case, the £2 minimum).

Now, the Betfair bet response object is a complex beast, but the only bit that is really of interest to us is the array of results. Let's pull it out:

>>> betsArray = response.betResults

And see how many bet objects it contains:

>>> len(betsArray)

1

No great surprise here: the bet we've put into the system is so far out the money I'd be surprised if there was more than one object: that of an unmatched bet. (If you were to offer to back England at 6, with £100,000, then you would get an awful lot of bet objects in return: one covering the bets matched at 7.0, one at 6.9, etc.

But let's take a look at the bet object we've gotten here:

>>> bet = betsArray[0]

Ha ha! Now we (finally) have an object with the details of our bet. Let's see if it was succesfully placed into the system (i.e. that the market is still live, and we still have money in our account):

>>> bet.success

True

Excellent. We've placed the bet. That's a good start. Was it matched?

>>> bet.sizeMatched

0.0

No surprise: it wasn't matched. It's sitting in the Betfair system waiting for someone to offer 10-1 on England. Finally, before we call it a wrap for the evening, let's store this bet in our database:

>>> dc.openBet(bet, 20692870, 27, 200, 11, 'BACK')

The openBet method takes the following paramaters: bet object, marketID, selectionID, amount (in pence), odds (a float), type (either 'BACK' or 'LAY').

Tomorrow – or in a few days – we'll play a little more with putting bets into the system, and reading the responses. But, hey, pat yourself on the back, you've just put some money on England to win the World Cup :-)