The Interactive Brokers Python native API is a feature that allows you to automatically trade via Python code (other languages are also supported).

Table of Contents

1. IB Python native API vs Third Party Libraries (IBridgePy, IbPy etc)
2. Setting up the IB native Python API
   1. TWS
   2. Testing the connection to the IB API
      1. Practical Example: Fetching Market Data

IB Python native API vs Third Party Libraries (IBridgePy, IbPy etc)

On the other hand, third-party libraries like IBridgePy and IbPy, while useful, are not officially supported by IB. A standout third-party option is IB-insync, which enhances the native API’s efficiency by using asynchronous methods for faster communication. It also simplifies data handling, making it a popular choice for traders looking for a more streamlined and responsive trading experience.

Setting up the IB native Python API

1. Opening Paper Account at IB - If your regular trading account has been approved and funded, you can use your Account Management page to open a Paper Trading Account which lets you use the full range of trading facilities in a simulated environment using real market conditions. ^[link]
2. Downloading the IB native API (Python) provides you with Python scripts that simplify connecting and communicating with the IB client (TWS or IB Gateway), which then links to IB’s servers. Other supported languages include Java, C++, and .NET. Additionally, IB offers integration with Microsoft’s ActiveX framework and DDE for connecting directly to Excel, giving developers a range of options to suit their preferred tools and environments.
   • http://interactivebrokers.github.io/ - API version 9.73 or higher is required, as anything before that does not have the necessary Python source files. Python version 3.1 or higher is also required.
3. Download the IB client (TWS or IB Gateway) – TWS is the default trading platform provided by Interactive Brokers, offering a comprehensive interface for trading. Alternatively, you can opt for the Interactive Brokers Gateway client, a lightweight solution designed for users who need a simpler, more streamlined connection to the IB server without the full TWS interface. Both options connect directly to IB’s servers and are compatible with the IB API.

   In the beginning, it’s recommended to use TWS when testing your script, as it provides a visual confirmation of any activity on your account, making it easier to track and debug your trades. Once you’re comfortable with the setup and your script is running smoothly, you can easily switch to IB Gateway, which is more lightweight and runs without the full graphical interface of TWS.

   • IB Trader Work Station (TWS)
   • IB Gateway
4. Choose your Python IDE

   When choosing a Python IDE for working with the IB API, consider these popular options based on your workflow and preferences:

   • PyCharm – A powerful and feature-rich IDE, ideal for professional developers. It offers advanced code completion, debugging, and testing features, making it great for complex projects.
   • VS Code – A lightweight and highly customizable editor with strong support for Python development. It has a vast marketplace of extensions, including those for Python, and excellent debugging capabilities.
   • Jupyter Notebooks – Perfect for those who prefer an interactive environment, especially for testing code snippets, analyzing data, and visualizing trading data in real-time.
   • Spyder – A great choice for scientific computing, with an integrated Python environment and excellent tools for code analysis, debugging, and execution, tailored for data-driven workflows.
5. Testing Connection

TWS

• https://interactivebrokers.github.io/tws-api/initial_setup.html

Testing the connection to the IB API

1. Install the IB API: Make sure you have the Interactive Brokers Python API installed.

1
2
3
4

$ apt-get install python3-setuptools
$ unzip twsapi_macunix.1019.04.zip
$ cd IBJts/source/pythonclient/
$ python3 setup.py install

Move the ibapi folder from the pythonclient folder and place it in the directory where we create our API access scripts.

2. Enable API Access in TWS: In TWS, go to Global Configuration → API → Settings, and enable the options to allow API connections:

3. Write a Basic Python Script: Here’s a simple script to test the connection to TWS or IB Gateway:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

from ibapi.client import EClient
from ibapi.wrapper import EWrapper
from ibapi.utils import iswrapper
import threading
import time


class IBApi(EWrapper, EClient):
    def __init__(self):
        EClient.__init__(self, self)

    @iswrapper
    def nextValidId(self, orderId):
        print(f"Connected! Next valid order ID: {orderId}")
        self.disconnect()


def run_loop():
    app.run()


# Create an instance of the IBApi class
app = IBApi()

# Start the connection to TWS or IB Gateway
app.connect("127.0.0.1", 7496, clientId=1)

# Start a separate thread to run the connection loop
api_thread = threading.Thread(target=run_loop, daemon=True)
api_thread.start()

# Wait for a few seconds to establish connection and print response
time.sleep(3)

4. Run the Script:

• Save the script as test_ib_connection.py.
• Ensure that TWS or IB Gateway is running on your machine.
• Run the script:

  1	python test_ib_connection.py

5. Verify Connection: If the connection is successful, you should see an output like:

   1	Connected! Next valid order ID: <some_number>

Practical Example: Fetching Market Data

1. Modify the script: Update your script to request live market data for a specific stock. In this example, we’ll request data for VXX.

   To obtain the details needed for the Contract object, follow these steps in TWS:

   1. Right-click on the underlying asset in your TWS watchlist.
   2. Select Description from the context menu.
   3. A pop-up window will appear, providing all the required information, including symbols, exchange, currency, and other relevant details for constructing the Contract object.
      This method ensures that you have the correct data for setting up a Contract object in your API scripts.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

from ibapi.client import EClient
from ibapi.wrapper import EWrapper
from ibapi.contract import Contract
 
import threading
import time
 
 
class IBapi(EWrapper, EClient):
    def __init__(self):
        EClient.__init__(self, self)
 
    def tickPrice(self, reqId, tickType, price, attrib):
        if tickType == 2 and reqId == 1:
            print('The current ask price is: ', price)
 
 
def run_loop():
    app.run()
 
 
app = IBapi()
app.connect('127.0.0.1', 7496, clientId=1)
 
# Start the socket in a thread
api_thread = threading.Thread(target=run_loop, daemon=True)
api_thread.start()
 
# Sleep interval to allow time for connection to server
time.sleep(1) 
 
# Create contract object
vxx_contract = Contract()
vxx_contract.symbol = 'VXX'
vxx_contract.secType = 'STK'
vxx_contract.exchange = 'SMART'
vxx_contract.currency = 'USD'
 
# Request Market Data
app.reqMktData(1, vxx_contract, '', False, False, [])
 
# Sleep interval to allow time for incoming price data
time.sleep(10) 
app.disconnect()

2. Explanation:

• We’ve defined a Contract object for VXX stock, specifying the symbol, security type, exchange, and currency.
• The method request_market_data() sends a request to IB for market data using reqMktData().

  In our case, we’re requesting live market data (the first parameter), which provides real-time price updates for the specified asset. However, the Interactive Brokers API offers various other data types and request options, all described in the official documentation.

• The tickPrice() method receives price updates and prints them to the console.

3. Run the Script: Once TWS or IB Gateway is running, execute the script again:

   1	python test_ib_market_data.py

4. Expected Output: You should see live market data for VXX printed in the console, something like:

   1	The current ask price is: <PRICE>

To explore additional options, refer to the Interactive Brokers API documentation, where you’ll find detailed descriptions of each feature, along with the required parameters for requesting them.

With this information, you can easily extend your script beyond live market data to cover more advanced use cases like backtesting with historical data, scanning the markets, or receiving financial news.

Client

Sources

This article is just an outline of the possibilities and it is more than advisable to focus on very detailed documentation afterwards.

• https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc/#api-introduction - I strongly recommend reading the entire documentation
• https://www.interactivebrokers.com/campus/trading-course/python-tws-api/
• https://www.interactivebrokers.com/campus/trading-lessons/python-receiving-market-data/
• https://www.ibkrguides.com/clientportal/aboutpapertradingaccounts.htm