IBKR API

https://www.interactivebrokers.com/campus/ibkr-api-page/
Admin
IBKR API provides comprehensive tools and documentation for developers to integrate with Interactive...
Tokens:5,982
Snippets:15
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### Python EClient and Application Setup

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Shows the initialization of the EClient class in Python and the setup of a main application class that inherits from both TestWrapper and TestClient.

```python
class TestClient(EClient):
     def __init__(self, wrapper):
         EClient.__init__(self, wrapper)
...
class TestApp(TestWrapper, TestClient):
	def __init__(self):
	TestWrapper.__init__(self)
         TestClient.__init__(self, wrapper=self)

```

--------------------------------

### C++: EReader Initialization and Start

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Demonstrates the initialization and starting of an EReader using C++ with `std::unique_ptr`. This is a common pattern for managing resources in C++ applications.

```cpp
m_pReader = std::unique_ptr<EReader>( new EReader(m_pClient, &m_osSignal) );
m_pReader->start();
```

--------------------------------

### Check Python TWS API Installation

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

This command verifies the installation of the 'ibapi' package, which is the Python client for the TWS API. It displays the installed version, confirming successful setup.

```bash
python -m pip show ibapi
```

--------------------------------

### Install Python TWS API Client

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

This command installs the Python client for the TWS API. It ensures that the necessary libraries are available for your Python environment to interact with the Trader Workstation.

```bash
python setup.py install
```

--------------------------------

### Resolve Python 'setuptools' ModuleNotFoundError

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

This snippet provides a solution for a common error encountered during Python API installation when 'setuptools' is missing or deprecated. It involves granting write permissions to the target folder and then using pip for installation.

```shell
sudo chmod -R 777 source/pythonclient
python3 -m pip install .
```

--------------------------------

### Install TWS API Python Client on Windows

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

This snippet demonstrates how to navigate to the Python client directory within the TWS API source and install it using setup.py. It assumes the API has been downloaded and extracted to the 'C:\TWS API\' directory.

```shell
cd "~/TWS API/source/pythonclient"
python3 setup.py install
```

--------------------------------

### Smart Components Callback Example (VB.NET)

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Example implementation of the EWrapper.smartComponents callback in VB.NET, used to process market depth exchange information.

```APIDOC
## EWrapper.smartComponents (VB.NET)

### Description
This callback function is invoked to provide information about smart components, which includes exchange details relevant to market depth data.

### Method
Callback

### Endpoint
N/A

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```vb.net
Public Sub smartComponents(reqId As Integer, theMap As Dictionary(Of Integer, KeyValuePair(Of String, Char))) Implements EWrapper.smartComponents
    Dim sb As New StringBuilder
    sb.AppendFormat("==== Smart Components Begin (total={0}) reqId = {1} ===={2}", theMap.Count, reqId, Environment.NewLine)
    For Each item In theMap
        sb.AppendFormat("bit number: {0}, exchange: {1}, exchange letter: {2}{3}", item.Key, item.Value.Key, item.Value.Value, Environment.NewLine)
    Next
    sb.AppendFormat("==== Smart Components Begin (total={0}) reqId = {1} ===={2}", theMap.Count, reqId, Environment.NewLine)
    Console.WriteLine(sb)
End Sub
```

### Response
#### Success Response (N/A)
This is a callback, no direct success response is returned.

#### Response Example
```
==== Smart Components Begin (total=2) reqId = 1 ====
bit number: 1, exchange: NASDAQ, exchange letter: N
bit number: 2, exchange: NYSE, exchange letter: Y
==== Smart Components Begin (total=2) reqId = 1 ====
```
```

--------------------------------

### Start Market Scan Subscription (Java)

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Starts a subscription to market scan results in Java using reqScannerSubscription. Takes a request ID, ScannerSubscription object, and filter values (null if not used).

```java
client.reqScannerSubscription(7002, scannerSubscription, null, FilterTagValues);
```

--------------------------------

### Net Liquidation Value Allocation Example (XML)

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

This XML snippet illustrates the setup for the Net Liquidation allocation method. It includes the group name, the default allocation method set to 'NetLiq', and a list of accounts identified by their account numbers.

```xml
<?xml version="1.0" encoding="UTF-8"?>
<ListOfGroups>
<Group>
<name>MyTestProfile2</name>
<defaultMethod>NetLiq</defaultMethod>
<ListOfAccts varName="list">
<Account>
<acct>DU6202167</acct>
</Account>
<Account>
<acct>DU6202168</acct>
</Account>
</ListOfAccts>
</Group>
</ListOfGroups>
```

--------------------------------

### C# EClientSocket Initialization and Wrapper

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Initializes an EClientSocket and its associated EReaderSignal in C#. This setup is fundamental for establishing a connection to the IB Gateway or TWS.

```csharp
EClientSocket clientSocket;
public readonly EReaderSignal Signal;
```

```csharp
public EWrapperImpl()
{
    Signal = new EReaderMonitorSignal();
    clientSocket = new EClientSocket(this, Signal);
}
```

--------------------------------

### Start Market Scan Subscription (C#)

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Starts a market scan subscription in C# using the reqScannerSubscription method. Parameters include request ID, ScannerSubscription object, and filter values.

```csharp
client.reqScannerSubscription(7002, scannerSubscription, null, filterTagValues);
```

--------------------------------

### VB.NET EClientSocket Initialization and Wrapper

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Initializes an EClientSocket and its associated EReaderSignal in VB.NET. This mirrors the C# setup for establishing API connections.

```vbnet
Public eReaderSignal As EReaderSignal
Public socketClient As EClientSocket
```

```vbnet
Sub New()
    eReaderSignal = New EReaderMonitorSignal
    socketClient = New EClientSocket(Me, eReaderSignal)
End Sub
```

--------------------------------

### Establish API Connection with Python

Source: https://context7.com/context7/interactivebrokers_campus_ibkr-api-page/llms.txt

Connects to TWS or IB Gateway using EClient.eConnect. Requires host, port, and client ID. Establishes a connection and starts a thread for message processing. Verifies connection status.

```python
from ibapi.client import EClient
from ibapi.wrapper import EWrapper
from ibapi.contract import Contract
import time
import threading

class TradingApp(EWrapper, EClient):
    def __init__(self):
        EClient.__init__(self, self)
        self.nextOrderId = None

    def nextValidId(self, orderId: int):
        print("NextValidId:", orderId)
        self.nextOrderId = orderId

    def connectAck(self):
        print("API Connection Established.")

    def error(self, reqId, errorCode, errorString, advancedOrderRejectJson=""):
        print(f"Error {errorCode}: {errorString}")

# Create application instance
app = TradingApp()

# Connect to TWS (127.0.0.1, port 7497, clientId 0)
app.connect("127.0.0.1", 7497, clientId=0)

# Start message processing thread
api_thread = threading.Thread(target=app.run, daemon=True)
api_thread.start()

# Wait for connection
time.sleep(2)

# Verify connection
if app.isConnected():
    print("Successfully connected to TWS")
else:
    print("Connection failed")
```

--------------------------------

### Error Handling in Python

Source: https://context7.com/context7/interactivebrokers_campus_ibkr-api-page/llms.txt

Demonstrates how to handle API errors, warnings, and informational messages using the `error` callback. It provides examples of handling specific error codes related to connection, data, and order issues. Robust error handling is crucial for API applications.

```python
from ibapi.client import EClient
from ibapi.wrapper import EWrapper

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

    def error(self, reqId, errorCode, errorString, advancedOrderRejectJson=""):
        print(f"Error. ReqId: {reqId}, Code: {errorCode}, Msg: {errorString}")

        # Handle specific error codes
        if errorCode == 502:
            print("Cannot connect to TWS. Ensure TWS is running with API enabled.")
        elif errorCode == 200:
            print("No security definition found for the request")
        elif errorCode == 201:
            print("Order rejected - order size exceeds maximum")
        elif errorCode == 321:
            print("Error validating request - Server error")
        elif errorCode == 2104:
            print("Market data farm connection is OK (informational)")
        elif errorCode == 2106:
            print("HMDS data farm connection is OK (informational)")
        elif errorCode == 2158:
            print("Sec-def data farm connection is OK (informational)")
        elif errorCode >= 2000 and errorCode < 3000:
            print("Informational/Warning message (non-critical)")

app = TradingApp()

try:
    app.connect("127.0.0.1", 7497, clientId=0)
    app.run()
except Exception as e:
    print(f"Connection error: {e}")
finally:
    if app.isConnected():
        app.disconnect()
```

--------------------------------

### Request Real-Time PnL using Python IB API

Source: https://context7.com/context7/interactivebrokers_campus_ibkr-api-page/llms.txt

This example illustrates how to subscribe to real-time profit and loss (PnL) updates for positions or accounts using the IB API. It utilizes `reqPnLSingle` for position-level PnL and `reqPnL` for account-level summaries. The `ibapi` library is required. PnL updates are streamed continuously until cancelled via `cancelPnLSingle` or `cancelPnL`.

```python
from ibapi.client import EClient
from ibapi.wrapper import EWrapper

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

    def pnlSingle(self, reqId: int, pos: int, dailyPnL: float,
                 unrealizedPnL: float, realizedPnL: float, value: float):
        print(f"PnLSingle. ReqId: {reqId}, Position: {pos}, "
              f"DailyPnL: {dailyPnL:.2f}, UnrealizedPnL: {unrealizedPnL:.2f}, "
              f"RealizedPnL: {realizedPnL:.2f}, Value: {value:.2f}")

    def pnl(self, reqId: int, dailyPnL: float, unrealizedPnL: float,
           realizedPnL: float):
        print(f"PnL. ReqId: {reqId}, DailyPnL: {dailyPnL:.2f}, "
              f"UnrealizedPnL: {unrealizedPnL:.2f}, RealizedPnL: {realizedPnL:.2f}")

    def nextValidId(self, orderId: int):
        # Request PnL for specific position (conId must be valid)
        self.reqPnLSingle(17001, "DU1234567", "", 265598)  # Example conId

        # Request account-level PnL
        self.reqPnL(17002, "DU1234567", "")

app = TradingApp()
app.connect("127.0.0.1", 7497, clientId=0)
app.run()

# To cancel PnL subscriptions:
# app.cancelPnLSingle(17001)
# app.cancelPnL(17002)
```

--------------------------------

### Request Contract Details using Python IBKR API

Source: https://context7.com/context7/interactivebrokers_campus_ibkr-api-page/llms.txt

Fetches detailed specifications for a given financial instrument. It requires a Contract object as input and returns contract details via the contractDetails callback. The example demonstrates requesting details for AAPL stock.

```python
from ibapi.contract import Contract
from ibapi.wrapper import EWrapper
from ibapi.client import EClient

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

    def contractDetails(self, reqId: int, contractDetails):
        print(f"Request ID: {reqId}")
        print(f"Symbol: {contractDetails.contract.symbol}")
        print(f"SecType: {contractDetails.contract.secType}")
        print(f"Exchange: {contractDetails.contract.exchange}")
        print(f"Currency: {contractDetails.contract.currency}")
        print(f"Long Name: {contractDetails.longName}")
        print(f"Min Tick: {contractDetails.minTick}")
        print(f"Trading Hours: {contractDetails.tradingHours}")

    def contractDetailsEnd(self, reqId: int):
        print(f"ContractDetailsEnd. ReqId: {reqId}")

    def nextValidId(self, orderId: int):
        # Create contract specification
        contract = Contract()
        contract.symbol = "AAPL"
        contract.secType = "STK"
        contract.exchange = "SMART"
        contract.currency = "USD"

        # Request contract details
        self.reqContractDetails(210, contract)

app = TradingApp()
app.connect("127.0.0.1", 7497, clientId=0)
app.run()
```

--------------------------------

### Request Historical Market Data using Python IBKR API

Source: https://context7.com/context7/interactivebrokers_campus_ibkr-api-page/llms.txt

Retrieves historical candlestick (OHLCV) data for a financial instrument. Supports various bar sizes, date ranges, and data types like trades, bid, ask, and midpoint. The example requests daily midpoint data for MSFT stock for the last month.

```python
from ibapi.client import EClient
from ibapi.wrapper import EWrapper
from ibapi.contract import Contract
from datetime import datetime

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

    def historicalData(self, reqId: int, bar):
        print(f"HistoricalData. ReqId: {reqId}, Date: {bar.date}, "
              f"Open: {bar.open}, High: {bar.high}, Low: {bar.low}, "
              f"Close: {bar.close}, Volume: {bar.volume}")

    def historicalDataEnd(self, reqId: int, start: str, end: str):
        print(f"HistoricalDataEnd. ReqId: {reqId}, Start: {start}, End: {end}")

    def nextValidId(self, orderId: int):
        # Define contract
        contract = Contract()
        contract.symbol = "MSFT"
        contract.secType = "STK"
        contract.exchange = "SMART"
        contract.currency = "USD"

        # Request 1 month of daily MIDPOINT data
        queryTime = datetime.now().strftime("%Y%m%d %H:%M:%S")
        self.reqHistoricalData(
            reqId=4102,
            contract=contract,
            endDateTime=queryTime,
            durationStr="1 M",
            barSizeSetting="1 day",
            whatToShow="MIDPOINT",
            useRTH=1,  # Regular trading hours only
            formatDate=1,  # Date format as string
            keepUpToDate=False,
            chartOptions=[]
        )

app = TradingApp()
app.connect("127.0.0.1", 7497, clientId=0)
app.run()

# To cancel ongoing historical data request:
# app.cancelHistoricalData(4102)
```

--------------------------------

### Get Historical Trading Session Schedule (C#)

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

This function retrieves historical trading session data. It takes a request ID, start and end datetimes, a time zone, and an array of HistoricalSession objects as input. The function logs the request details and iterates through the sessions to log each session's start, end, and reference date. No external dependencies are required beyond the IBKR API library.

```csharp
public void historicalSchedule(int reqId, string startDateTime, string endDateTime, string timeZone, HistoricalSession[] sessions) {
	Console.WriteLine($"Historical Schedule. ReqId: {reqId}, Start: {startDateTime}, End: {endDateTime}, Time Zone: {timeZone}");
	foreach (var session in sessions) {
		Console.WriteLine($"\tSession. Start: {session.StartDateTime}, End: {session.EndDateTime}, Ref Date: {session.RefDate}");
	}
}
```

--------------------------------

### Python TWS API Tutorial

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Reference to a tutorial series that demonstrates TWS API functionality using Python. The tutorial covers essential tasks like market data requests, order placement, and account information retrieval.

```python
# Python TWS API Tutorial
# Covers:
# - Downloading and running TWS/IB Gateway
# - Installing TWS API and updating Python Interpreter
# - Requesting Live and Historical Market Data
# - Placing and Monitoring Orders
# - Reviewing Individual Account Information
# - Handling Market Scanners
```

--------------------------------

### Navigate and List Files on Mac/Linux

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

This sequence of commands shows how to navigate to the Downloads folder, list its contents to identify the downloaded API zip file, and then unzip it into the home directory on a Unix-like system.

```shell
cd ~/Downloads
ls
```

```shell
sudo unzip twsapi_macunix.n.m.zip -d $HOME/
```

```shell
cd ~/IBJts
ls
```

--------------------------------

### Request Historical Ticks in Python

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Example of requesting historical ticks data using the reqHistoricalTicks method in Python. This call specifies the request ID, contract details, start and end times, number of ticks, data type, use of regular trading hours, and size update handling.

```python
self.reqHistoricalTicks(18001, contract, "20170712 21:39:33 US/Eastern", "", 10, "TRADES", 1, True, [])
```

--------------------------------

### Place Order to Model Portfolio (C#)

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

This C# example demonstrates how to initialize an `Order` object, populate the `Account` and `ModelCode` properties, and subsequently call `client.placeOrder` to execute an order against a specified model portfolio. The code includes comments for clarity.

```csharp
Order modelOrder = Order();
modelOrder.Account = "DF12345"; // master FA account number
modelOrder.ModelCode = "Technology"; // model for tech stocks first created in TWS
client.placeOrder(nextOrderId++, contract, modelOrder);
```

--------------------------------

### VB.NET: Starting a Message Processing Thread

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Illustrates how to initiate a thread for message processing in VB.NET, including setting it as a background thread and starting it conditionally based on server version.

```vbnet
'Once the messages are in the queue, an additional thread need to fetch them
Dim msgThread As Thread = New Thread(AddressOf messageProcessing)
msgThread.IsBackground = True
If (wrapperImpl.serverVersion() > 0) Then Call msgThread.Start()
```

--------------------------------

### TWS API Sample Application Locations

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

File paths for sample applications provided with the TWS API, useful for testing API functionality. Includes executables for C# and Java.

```csharp
~\TWS API\samples\CSharp\IBSampleApp\bin\Release\IBSampleApp.exe
```

```java
~\TWS API\samples\Java\ApiDemo.jar
```

--------------------------------

### Place Order to Model Portfolio (Java)

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

This Java snippet shows how to instantiate an `Order` object, set the `account` and `modelCode` properties, and then use the `client.placeOrder` method to send the order to a designated model portfolio. It includes comments explaining the purpose of each field.

```java
Order modelOrder = Order();
modelOrder.account("DF12345");  // master FA account number
modelOrder.modelCode("Technology"); // model for tech stocks first created in TWS
client.placeOrder(nextOrderId++, contract, modelOrder);
```

--------------------------------

### TWS API Version Check

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

File path to check the installed version of the TWS API. The version number is stored in a text file within the TWS API installation directory.

```plaintext
~\TWS API\API_VersionNum.txt
```

--------------------------------

### Python: Request Account Summary with NetLiquidation

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

This Python code demonstrates how to establish a connection to the Interactive Brokers API and request account summary data, specifically for 'NetLiquidation'. It includes the necessary EWrapper and EClient setup and the main execution flow.

```Python
from ibapi.client import *
from ibapi.wrapper import *
from ibapi.contract import Contract
import time

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

    def accountSummary(self, reqId: int, account: str, tag: str, value: str,currency: str):
        print("AccountSummary. ReqId:", reqId, "Account:", account,"Tag: ", tag, "Value:", value, "Currency:", currency)
    
    def accountSummaryEnd(self, reqId: int):
        print("AccountSummaryEnd. ReqId:", reqId)
    
app = TradeApp()
app.connect("127.0.0.1", 7496, clientId=1)

time.sleep(1)

app.reqAccountSummary(9001, "All", 'NetLiquidation')
app.run()
```

--------------------------------

### Market Data Tick Types - tickGeneric examples

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Examples for retrieving generic tick data using the tickGeneric function in IBApi. Covers Estimated IPO – Midpoint and Final IPO Price.

```python
def tickGeneric(self, reqId, tickType, value):
    # Estimated IPO – Midpoint (586)
    # Final IPO Price (586)
    pass
```

--------------------------------

### RT Volume Tick Data Example

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Example format for RT Volume tick data, representing last trade details and current day's volume information. Note that RT Volume is not supported for cryptocurrencies.

```text
701.28;1;1348075471534;67854;701.46918464;true
```

--------------------------------

### Place Order to Model Portfolio (VB.NET)

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

This VB.NET snippet shows the correct syntax for creating an `Order` object, setting its `Account` and `ModelCode` properties to target a model portfolio, and then using `client.placeOrder` to submit the order. It includes comments explaining the parameters.

```vbnet
Dim modelOrder As Order = Order ()
modelOrder.Account = "DF12345" 'master FA account number
modelOrder.ModelCode = "Technology" 'model for tech stocks first created in TWS
client.placeOrder(increment(nextOrderId), contract, modelOrder)
```

--------------------------------

### IB Dividends Tick Data Example

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Example format for IB Dividends tick data, providing comma-separated values for past and future dividends, next dividend date, and amount. Direct-routing may be necessary for dividend data.

```text
0.83,0.92,20130219,0.23
```

--------------------------------

### Exercise Options (Java)

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Provides a Java example for exercising an options contract via the EClient.exerciseOptions function. It shows how to pass the necessary parameters such as tickerId, contract details, quantity, account, and override flags. An empty string can be used for manual order time to indicate the current time.

```Java
client.exerciseOptions(5003, contract, 1, 1, "", 1, "");
```

--------------------------------

### Exercise Options (C#)

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Shows how to exercise an options contract in C# using the EClient.exerciseOptions function. The example demonstrates the correct parameter passing for tickerId, contract, exercise action, quantity, account, and override. Null values can be used for optional string parameters like manual order time.

```C#
client.exerciseOptions(5003, contract, 1, 1, null, 1, null);
```

--------------------------------

### Market Data Tick Types - tickOptionComputation examples

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Examples for retrieving option computation data using the tickOptionComputation function in IBApi. Demonstrates fetching delayed bid, ask, last, and model option greeks and implied volatility.

```python
def tickOptionComputation(self, reqId, tickType, impliedVolatility, delta, putOrCall, optionSqueeze, gamma, vega, theta, undPriceSensitivity):
    # Delayed Bid Option (80)
    # Delayed Ask Option (81)
    # Delayed Last Option (82)
    # Delayed Model Option (83)
    pass
```

--------------------------------

### Market Data Tick Types - tickSize examples

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Examples of retrieving size-related market data using the tickSize function in IBApi. Covers delayed volume, futures open interest, average option volume, and shortable shares.

```python
def tickSize(self, reqId, tickType, size):
    # Delayed Volume (74)
    # Futures Open Interest (86)
    # Average Option Volume (87)
    # Shortable Shares (89)
    pass
```

--------------------------------

### Place Pre-Borrow Order in Python

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Demonstrates how to configure Contract and Order objects to place a market order for a pre-borrowed security in Python. Requires the TWS API library.

```python
contract = Contract()
contract.symbol = symbol
contract.secType = "SBL"
contract.exchange = "PREBORROW"
contract.currency = "USD"

order = Order()
order.action = "BUY"
order.orderType = "MKT"
order.totalQuantity = quantity
```

--------------------------------

### Start Market Scan Subscription (C++)

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Initiates a market scan subscription in C++ via reqScannerSubscription. Requires a request ID, ScannerSubscription object, and optional filter TagValueListSPtr.

```cpp
m_pClient->reqScannerSubscription(7002, scannerSubscription, TagValueListSPtr(), filterTagValues);
```

--------------------------------

### Market Data Tick Types - tickString examples

Source: https://www.interactivebrokers.com/campus/ibkr-api-page/twsapi-doc

Examples of fetching string-based market data using the tickString function in IBApi. Includes RT Trade Volume, Last Exchange, Last Regulatory Time, and Delayed Last Timestamp.

```python
def tickString(self, reqId, tickType, value):
    # RT Trade Volume (375)
    # Last Exchange (84)
    # Last Regulatory Time (85)
    # Delayed Last Timestamp (88)
    pass
```
Tokens:
Raw