IB-insync

https://ib-insync.readthedocs.io/
Admin
IB-insync is a Python library that simplifies working with the Interactive Brokers Trader...
Tokens:108,198
Snippets:1,007
Trust Score:8.3
Update:1 month ago
Show doc for...
Tokens:
Raw
### Watchdog Example Usage

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ibcontroller.html

Demonstrates how to use the Watchdog class to manage the connection and health of the IB TWS or Gateway application. It includes setting up event handlers and starting the watchdog.

```python
    .. code-block:: python

        def onConnected():
            print(ib.accountValues())

        ibc = IBC(974, gateway=True, tradingMode='paper')
        ib = IB()
        ib.connectedEvent += onConnected
        watchdog = Watchdog(ibc, ib, port=4002)
        watchdog.start()
        ib.run()

```

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

### IB Connection and Disconnection Example

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Demonstrates connecting to the IB TWS API on localhost and then disconnecting. This is a basic setup for testing connectivity.

```python
loop = util.getLoop()
    loop.set_debug(True)
    util.logToConsole(logging.DEBUG)
    ib = IB()
    ib.connect('127.0.0.1', 7497, clientId=1)
    ib.disconnect()
```

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

### Install ib-insync

Source: https://ib-insync.readthedocs.io/

Install the ib-insync library using pip. Ensure Python 3.6+ and a running TWS or IB Gateway (v1023+) with API port enabled.

```bash
pip install ib_insync

```

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

### Start API

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/client.html

Initiates the connection and startup sequence for the IB API client.

```python
self.send()
```

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

### Start Watchdog Runner

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ibcontroller.html

Initiates the Watchdog's asynchronous run loop, logging the start event and returning the created asyncio task.

```python
    def start(self):
        self._logger.info('Starting')
        self.startingEvent.emit(self)
        self._runner = asyncio.ensure_future(self.runAsync())
        return self._runner

```

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

### startApi

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/client.html

Starts the API connection. This method initiates the connection to the Interactive Brokers API.

```APIDOC
## startApi

### Description
Starts the API connection.

### Method
`startApi(self)`
```

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

### Asynchronous Start TWS/Gateway

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ibcontroller.html

Asynchronously starts the TWS or IB Gateway client. This is the underlying method called by `start()`.

```python
await ibc.startAsync()
```

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

### reqPnLSingle

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Starts a subscription for single PnL events. This method is blocking.

```APIDOC
## reqPnLSingle

### Description
Starts a subscription for single PnL events.

This method is blocking.

### Method
`reqPnLSingle(account: str, modelCode: str, conId: int)`

### Parameters
#### Path Parameters
- **account** (str) - Required - Subscribe to this account.
- **modelCode** (str) - Required - If specified, filter for this account model.
- **conId** (int) - Required - Contract identifier.
```

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

### startLoop

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/util.html

Initializes and starts a nested asyncio event loop, specifically designed for use within Jupyter notebooks.

```APIDOC
## startLoop()

### Description
Use nested asyncio event loop for Jupyter notebooks.
```

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

### Start a Live Subscription

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/wrapper.html

Registers a new live subscription, associating a request ID with a subscriber object and optionally a contract.

```python
def startSubscription(self, reqId, subscriber, contract=None):
        """Register a live subscription."""
        self._reqId2Contract[reqId] = contract
        self.reqId2Subscriber[reqId] = subscriber
```

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

### Initialize and start Watchdog

Source: https://ib-insync.readthedocs.io/api.html

Demonstrates setting up an IBC instance and a Watchdog to monitor an IB connection. The IB instance should not be connected manually as the Watchdog handles the connection lifecycle.

```python
def onConnected():
    print(ib.accountValues())

ibc = IBC(974, gateway=True, tradingMode='paper')
ib = IB()
ib.connectedEvent += onConnected
watchdog = Watchdog(ibc, ib, port=4002)
watchdog.start()
ib.run()
```

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

### PnLSingle Subscription

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Starts a subscription for profit and loss events for single positions. Returns a PnLSingle object that is kept live updated.

```APIDOC
## reqPnLSingle

### Description
Start a subscription for profit and loss events for single positions.

Returns a :class:`.PnLSingle` object that is kept live updated.
The result can also be queried from :meth:`.pnlSingle`.

### Method
(Implicitly POST or similar, as it initiates a subscription)

### Endpoint
(Not applicable for SDK method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
ib.reqPnLSingle(account='...', modelCode='...', conId=123)
```

### Response
#### Success Response (200)
- **PnLSingle** (object) - A PnLSingle object that is kept live updated.

#### Response Example
(PnLSingle object structure not detailed in source)
```

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

### Create Financial Instrument Contracts

Source: https://ib-insync.readthedocs.io/api.html

Examples of initializing various financial instrument types using the generic Contract class or specialized subclasses.

```python
Contract(conId=270639)
Stock('AMD', 'SMART', 'USD')
Stock('INTC', 'SMART', 'USD', primaryExchange='NASDAQ')
Forex('EURUSD')
CFD('IBUS30')
Future('ES', '20180921', 'GLOBEX')
Option('SPY', '20170721', 240, 'C', 'SMART')
Bond(secIdType='ISIN', secId='US03076KAA60')
Crypto('BTC', 'PAXOS', 'USD')
```

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

### Start TWS/Gateway with IBC

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ibcontroller.html

Starts the TWS or IB Gateway client application managed by IBC. This method is blocking and will run until the client is terminated.

```python
ibc.start()
```

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

### IBC Command Line Construction

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ibcontroller.html

Illustrates how the command line arguments are constructed for starting IBC, mapping dataclass fields to command-line options based on the operating system.

```python
args = dict(
    twsVersion=('', ''),
    gateway=('--gateway', '/Gateway'),
    tradingMode=('--mode=', '/Mode:'),
    twsPath=('--tws-path=', '/TwsPath:'),
    twsSettingsPath=('--tws-settings-path=', ''),
    ibcPath=('--ibc-path=', '/IbcPath:'),
    ibcIni=('--ibc-ini=', '/Config:'),
    javaPath=('--java-path=', '/JavaPath:'),
    userid=('--user=', '/User:'),
    password=('--pw=', '/PW:'),
    fixuserid=('--fix-user=', '/FIXUser:'),
    fixpassword=('--fix-pw=', '/FIXPW:'),
    on2fatimeout=('--on2fatimeout=', '/On2FATimeout:'),
)

# create shell command
cmd = [
    f'{self.ibcPath}\scripts\StartIBC.bat' if self._isWindows else
    f'{self.ibcPath}/scripts/ibcstart.sh']
for k, v in util.dataclassAsDict(self).items():
    arg = args[k][self._isWindows]
    if v:
        if arg.endswith('=') or arg.endswith(':'):
            cmd.append(f'{arg}{v}')
        elif arg:
            cmd.append(arg)
        else:
            cmd.append(str(v))
```

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

### Get Account Summary Async

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Retrieves account summary data. If no account is specified, it returns summaries for all accounts. Data is loaded on demand.

```python
if not self.wrapper.acctSummary:
            # loaded on demand since it takes ca. 250 ms
            await self.reqAccountSummaryAsync()
        if account:
            return [v for v in self.wrapper.acctSummary.values()
                    if v.account == account]
        else:
            return list(self.wrapper.acctSummary.values())
```

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

### Set Connection Options

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/client.html

Sets additional connection options for the client. For example, use '+PACEAPI' to enable request-pacing in TWS/gateway 974+.

```python
self.connectOptions = connectOptions.encode()
```

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

### reqPnL

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Starts a subscription for profit and loss events. Returns a :class:`.PnL` object that is kept live updated. The result can also be queried from `.pnl`.

```APIDOC
## reqPnL

### Description
Starts a subscription for profit and loss events.

Returns a :class:`.PnL` object that is kept live updated.
The result can also be queried from :meth:`.pnl`.

https://interactivebrokers.github.io/tws-api/pnl.html

### Method
`reqPnL(account: str, modelCode: str = '')`

### Parameters
#### Path Parameters
- **account** (str) - Required - Subscribe to this account.
- **modelCode** (str) - Optional - If specified, filter for this account model.
```

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

### startTicker

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/wrapper.html

Starts a tick request for a given contract and tick type, returning a Ticker object to receive tick data.

```APIDOC
## startTicker

### Description
Start a tick request that has the reqId associated with the contract. Return the ticker.

### Method
wrapper.startTicker(reqId: int, contract: Contract, tickType: Union[int, str])

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Returns
- Ticker: The Ticker object associated with the request.
```

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

### Start a New Request

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/wrapper.html

Initiates a new request and returns an asyncio.Future object associated with the request key and container. Used for tracking asynchronous operations.

```python
def startReq(self, key, contract=None, container=None):
        """
        Start a new request and return the future that is associated
        with the key and container. The container is a list by default.
        """
        future: asyncio.Future = asyncio.Future()
        self._futures[key] = future
        self._results[key] = container if container is not None else []
        if contract:
            self._reqId2Contract[key] = contract
        return future
```

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

### Get Scanner Data (Streaming)

Source: https://ib-insync.readthedocs.io/recipes.html

Sets up a streaming scanner subscription and processes incoming data through an event handler. The subscription is cancelled after a specified sleep duration.

```python
def onScanData(scanData):
    print(scanData[0])
    print(len(scanData))

sub = ScannerSubscription(
    instrument='FUT.US',
    locationCode='FUT.GLOBEX',
    scanCode='TOP_PERC_GAIN')
scanData = ib.reqScannerSubscription(sub)
scanData.updateEvent += onScanData
ib.sleep(60)
ib.cancelScannerSubscription(scanData)
```

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

### Download Historical Data - IB-insync

Source: https://ib-insync.readthedocs.io/

Connect to IB Gateway/TWS, define a contract, and request historical data. The data can be converted to a pandas DataFrame for analysis. Ensure pandas is installed.

```python
from ib_insync import *
# util.startLoop()  # uncomment this line when in a notebook

ib = IB()
ib.connect('127.0.0.1', 7497, clientId=1)

contract = Forex('EURUSD')
bars = ib.reqHistoricalData(
    contract, endDateTime='', durationStr='30 D',
    barSizeSetting='1 hour', whatToShow='MIDPOINT', useRTH=True)

# convert to pandas dataframe (pandas needs to be installed):
df = util.df(bars)
print(df)

```

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

### Start Nested Event Loop - ib_insync.util

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/util.html

Initializes a nested asyncio event loop, primarily intended for use within Jupyter notebooks. It calls `patchAsyncio()` to enable nested loop execution.

```python
def startLoop():
    """Use nested asyncio event loop for Jupyter notebooks."""
    patchAsyncio()
```

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

### Start a Ticker Request

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/wrapper.html

Initializes a ticker object for a given contract and tick type, associating it with a request ID. Handles creation of new tickers if they don't exist.

```python
def startTicker(
            self, reqId: int, contract: Contract, tickType: Union[int, str]):
        """
        Start a tick request that has the reqId associated with the contract.
        Return the ticker.
        """
        ticker = self.tickers.get(id(contract))
        if not ticker:
            ticker = Ticker(
                contract=contract, ticks=[], tickByTicks=[],
                domBids=[], domAsks=[], domTicks=[])
            self.tickers[id(contract)] = ticker
        self.reqId2Ticker[reqId] = ticker
        self._reqId2Contract[reqId] = contract
        self.ticker2ReqId[tickType][ticker] = reqId
        return ticker
```

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

### Context Manager for IBC

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ibcontroller.html

Use the IBC controller as a context manager to automatically start and terminate the TWS/Gateway client. Ensure the correct event loop is set for Windows.

```python
import asyncio
asyncio.set_event_loop(asyncio.ProactorEventLoop())

with IBC(976, gateway=True, tradingMode='live',
        userid='edemo', password='demouser') as ibc:
    IB.run()

```

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

### useQt

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/util.html

Configures and runs a combined Qt and asyncio event loop, supporting various Qt libraries.

```APIDOC
## useQt(qtLib: str = 'PyQt5', period: float = 0.01)

### Description
Run combined Qt5/asyncio event loop.

### Parameters
* `qtLib` (str): Name of Qt library to use:

  * PyQt5
  * PyQt6
  * PySide2
  * PySide6
* `period` (float): Period in seconds to poll Qt.
```

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

### Retrieve Minimum Price Increments and Market Rules

Source: https://ib-insync.readthedocs.io/recipes.html

Fetches contract details for a Forex pair to get market rule IDs, then requests the details for each market rule. This helps understand price increment rules.

```python
usdjpy = Forex('USDJPY')
cd = ib.reqContractDetails(usdjpy)[0]
print(cd.marketRuleIds)

rules = [
    ib.reqMarketRule(ruleId)
    for ruleId in cd.marketRuleIds.split(',')]
print(rules)
```

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

### FlexReport Initialization

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/flexreport.html

Initialize a FlexReport object by downloading a report using a token and queryId, or by loading an existing report from a file path.

```python
report = FlexReport(token='945692423458902392892687', queryId='272555')
```

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

### getReqId

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/client.html

Get a new unique request ID for API requests.

```APIDOC
## getReqId

### Description
Get a new unique request ID for API requests.

### Signature
getReqId() -> int
```

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

### Request PnL Subscription

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Starts a subscription for profit and loss events, returning a live-updated PnL object. The result can also be queried from `.pnl`. Subscribe to a specific account and optionally filter by model code.

```python
reqId = self.client.getReqId()
self.wrapper.pnlKey2ReqId[key] = reqId
pnl = PnL(account, modelCode)
self.wrapper.reqId2PnL[reqId] = pnl
self.client.reqPnL(reqId, account, modelCode)
return pnl
```

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

### startSubscription

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/wrapper.html

Registers a live subscription with a request ID and an optional contract.

```APIDOC
## startSubscription

### Description
Register a live subscription.

### Method
wrapper.startSubscription(reqId, subscriber, contract=None)
```

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

### Fetch Consecutive Historical Data (1 min bars)

Source: https://ib-insync.readthedocs.io/recipes.html

Fetches historical 1-minute bar data for a stock, starting from the most recent data and going backward in time until no more data is returned. Saves the data to a CSV file. Requires `util.startLoop()` when used in a notebook.

```python
import datetime
from ib_insync import *

ib = IB()
ib.connect('127.0.0.1', 7497, clientId=1)

contract = Stock('TSLA', 'SMART', 'USD')

dt = ''
barsList = []
while True:
    bars = ib.reqHistoricalData(
        contract,
        endDateTime=dt,
        durationStr='10 D',
        barSizeSetting='1 min',
        whatToShow='MIDPOINT',
        useRTH=True,
        formatDate=1)
    if not bars:
        break
    barsList.append(bars)
    dt = bars[0].date
    print(dt)

# save to CSV file
allBars = [b for bars in reversed(barsList) for b in bars]
df = util.df(allBars)
df.to_csv(contract.symbol + '.csv', index=False)
```

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

### _endReq

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/wrapper.html

Completes a previously started request by setting the result or exception on its associated future.

```APIDOC
## _endReq

### Description
Finish the future of corresponding key with the given result. If no result is given then it will be popped of the general results.

### Method
wrapper._endReq(key, result=None, success=True)
```

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

### Get User Info

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Retrieves the White Branding ID of the user. This is a blocking method.

```python
ib.reqUserInfo()
```

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

### reqMktDepthExchanges

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Get those exchanges that have have multiple market makers (and have ticks returned with marketMaker info).

```APIDOC
## reqMktDepthExchanges

### Description
Get those exchanges that have have multiple market makers (and have ticks returned with marketMaker info).

### Parameters
None

### Method
Not applicable (Python method)

### Endpoint
Not applicable (Python method)
```

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

### Get All Tickers

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Retrieves a list of all available tickers. This includes tickers for all contracts that have been requested.

```python
def tickers(self) -> List[Ticker]:
    """Get a list of all tickers."""
    return list(self.wrapper.tickers.values())
```

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

### Request Account Summary Async

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Initiates a request for account summary details. This method fetches a comprehensive list of account tags.

```python
tags = (
            'AccountType,NetLiquidation,TotalCashValue,SettledCash,AccruedCash,BuyingPower,EquityWithLoanValue,PreviousDayEquityWithLoanValue,GrossPositionValue,RegTEquity,RegTMargin,SMA,InitMarginReq,MaintMarginReq,AvailableFunds,ExcessLiquidity,Cushion,FullInitMarginReq,FullMaintMarginReq,FullAvailableFunds,FullExcessLiquidity,LookAheadNextChange,LookAheadInitMarginReq,LookAheadMaintMarginReq,LookAheadAvailableFunds,LookAheadExcessLiquidity,HighestSeverity,DayTradesRemaining,DayTradesRemainingT+1,DayTradesRemainingT+2,DayTradesRemainingT+3,DayTradesRemainingT+4,Leverage,$LEDGER:ALL')
        self.client.reqAccountSummary(reqId, 'All', tags)
        return future
```

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

### Get All Executions

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Retrieves a list of all executions from the current session. Each execution is derived from a fill.

```python
def executions(self) -> List[Execution]:
    """List of all executions from this session."""
    return list(fill.execution for fill in self.wrapper.fills.values())
```

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

### TimeBars Initialization

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ticker.html

Initializes TimeBars with a timer event and an optional source. It connects to the timer and initializes an empty BarList.

```python
def __init__(self, timer, source=None):
        Op.__init__(self, source)
        self._timer = timer
        self._timer.connect(self._on_timer, None, self._on_timer_done)
        self.bars = BarList()
```

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

### Get All Orders

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Retrieves a list of all orders from the current session. This includes both open and closed orders.

```python
def orders(self) -> List[Order]:
    """List of all orders from this session."""
    return list(
        trade.order for trade in self.wrapper.trades.values())
```

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

### dataclassNonDefaults(obj)

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/util.html

For a dataclass instance, get the fields that are different from the default values and return them as a dictionary.

```APIDOC
## dataclassNonDefaults(obj)

### Description
For a ``dataclass`` instance get the fields that are different from the default values and return as ``dict``.

### Parameters
#### Arguments
* **obj**: The dataclass instance to inspect.
```

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

### Create Specialized Contracts with Contract

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/contract.html

Demonstrates creating various specialized contract types (Stock, Forex, Future, Option, Bond, Crypto) using the generic Contract class with keyword arguments. This is useful for initializing contracts when the specific type is known.

```python
Contract(conId=270639)
Stock('AMD', 'SMART', 'USD')
Stock('INTC', 'SMART', 'USD', primaryExchange='NASDAQ')
Forex('EURUSD')
CFD('IBUS30')
Future('ES', '20180921', 'GLOBEX')
Option('SPY', '20170721', 240, 'C', 'SMART')
Bond(secIdType='ISIN', secId='US03076KAA60')
Crypto('BTC', 'PAXOS', 'USD')
```

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

### startReq

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/wrapper.html

Initiates a new request to the broker and returns an asyncio.Future object that will be resolved when the request is completed.

```APIDOC
## startReq

### Description
Start a new request and return the future that is associated with the key and container. The container is a list by default.

### Method
wrapper.startReq(key, contract=None, container=None)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Returns
- asyncio.Future: A future object associated with the request key.
```

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

### IBC Class

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ibcontroller.html

The IBC class provides methods to start and terminate TWS/IBG. It can be used as a context manager.

```APIDOC
## Class IBC

Programmatic control over starting and stopping TWS/Gateway using IBC.

### Parameters

* **twsVersion** (int): Required. The major version number for TWS or gateway.
* **gateway** (bool): Optional. True for gateway, False for TWS. Defaults to False.
* **tradingMode** (str): Optional. 'live' or 'paper'.
* **userid** (str): Optional. IB account username.
* **password** (str): Optional. IB account password.
* **twsPath** (str): Optional. Path to the TWS installation folder.
* **twsSettingsPath** (str): Optional. Path to the TWS settings folder.
* **ibcPath** (str): Optional. Path to the IBC installation folder.
* **ibcIni** (str): Optional. Path to the IBC configuration file.
* **javaPath** (str): Optional. Path to Java executable.
* **fixuserid** (str): Optional. FIX account user id (gateway only).
* **fixpassword** (str): Optional. FIX account password (gateway only).
* **on2fatimeout** (str): Optional. What to do if 2-factor authentication times out; Can be 'restart' or 'exit'.

### Methods

#### `start()`

Launches TWS/IBG.

#### `terminate()`

Terminates TWS/IBG.

#### `startAsync()`

Asynchronous method to launch TWS/IBG.

#### `__enter__()`

Enters the runtime context related to this object. Calls `start()`.

#### `__exit__(*_exc)`

Exits the runtime context related to this object. Calls `terminate()`.

### Example Usage

```python
import asyncio

# For Windows, set the event loop
if sys.platform == 'win32':
    asyncio.set_event_loop(asyncio.ProactorEventLoop())

from ib_insync import IBC, IB

# Initialize IBC
ibc = IBC(976, gateway=True, tradingMode='live',
            userid='edemo', password='demouser')

# Start TWS/Gateway
ibc.start()

# Connect to IB
IB.run()

# When done, terminate TWS/Gateway
ibc.terminate()
```
```

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

### Request Contract Details

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Gets a list of contract details that match the given contract. This method is blocking.

```APIDOC
## reqContractDetails

### Description
Get a list of contract details that match the given contract. If the returned list is empty then the contract is not known; If the list has multiple values then the contract is ambiguous.

The fully qualified contract is available in the the ContractDetails.contract attribute.

This method is blocking.

### Method
(Implicitly GET or similar, as it retrieves data)

### Endpoint
(Not applicable for SDK method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```python
contract_details = ib.reqContractDetails(contract=my_contract)
```

### Response
#### Success Response (200)
- **List[ContractDetails]** (list) - A list of contract details.

#### Response Example
(ContractDetails object structure not detailed in source)
```

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

### Account Download End

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/wrapper.html

Placeholder method called when account data download is complete. It currently does nothing.

```python
def accountDownloadEnd(self, _account: str):
        pass
```

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

### Get All Fills

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Retrieves a list of all fills from the current session. A fill represents a completed part of an order.

```python
def fills(self) -> List[Fill]:
    """List of all fills from this session."""
    return list(self.wrapper.fills.values())
```

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

### Initialize IBC Controller

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ibcontroller.html

Instantiate the IBC controller with required parameters like TWS version and gateway settings. It's recommended to set sensitive credentials in a secured IBC config file.

```python
ibc = IBC(976, gateway=True, tradingMode='live',
    userid='edemo', password='demouser')
```

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

### Get Open Orders

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Retrieves a list of all currently open orders. Orders that are in a 'Done' state are excluded.

```python
def openOrders(self) -> List[Order]:
    """List of all open orders."""
    return [trade.order for trade in self.wrapper.trades.values()
            if trade.orderStatus.status not in OrderStatus.DoneStates]
```

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

### IBC and Watchdog Initialization

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ibcontroller.html

This snippet shows how to initialize the IBC (Interactive Brokers Controller) and the Watchdog class for managing IB connections. It's used to set up a connection with specific parameters like client ID, gateway usage, and trading mode. This is typically the entry point for applications using the controller.

```python
if __name__ == '__main__':
    ibc = IBC(1012, gateway=True, tradingMode='paper')
    ib = IB()
    app = Watchdog(ibc, ib, appStartupTime=15)
    app.start()
    IB.run()
```

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

### TimeBars _on_timer method

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ticker.html

Handles timer events to finalize the current bar, emit it, and start a new one.

```python
def _on_timer(self, time):
        if self.bars:
            bar = self.bars[-1]
            if isNan(bar.close) and len(self.bars) > 1:
                bar.open = bar.high = bar.low = bar.close = \
                    self.bars[-2].close
            self.bars.updateEvent.emit(self.bars, True)
            self.emit(bar)
        self.bars.append(Bar(time))
```

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

### Get News Bulletins

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Retrieves a list of IB news bulletins. These are official announcements and news from Interactive Brokers.

```python
def newsBulletins(self) -> List[NewsBulletin]:
    """List of IB news bulletins."""
    return list(self.wrapper.msgId2NewsBulletin.values())
```

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

### Connect to IB Gateway/TWS (Async)

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Asynchronously connects to the Interactive Brokers TWS or Gateway. Allows specifying host, port, clientId, timeout, readonly mode, and account.

```python
await ib.connectAsync(host='127.0.0.1', port=7497, clientId=1, timeout=4, readonly=False, account='', raiseSyncErrors=False)
```

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

### Use Qt with Asyncio - ib_insync.util

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/util.html

Combines a Qt event loop with the asyncio event loop, allowing both to run concurrently. It supports various Qt bindings (PyQt5, PyQt6, PySide2, PySide6) and allows configuration of the polling period.

```python
def useQt(qtLib: str = 'PyQt5', period: float = 0.01):
    """
    Run combined Qt5/asyncio event loop.

    Args:
        qtLib: Name of Qt library to use:

          * PyQt5
          * PyQt6
          * PySide2
          * PySide6
        period: Period in seconds to poll Qt.
    """
    def qt_step():
        loop.call_later(period, qt_step)
        if not stack:
            qloop = qc.QEventLoop()
            timer = qc.QTimer()
            timer.timeout.connect(qloop.quit)
            stack.append((qloop, timer))
        qloop, timer = stack.pop()
        timer.start(0)
        qloop.exec() if qtLib == 'PyQt6' else qloop.exec_()
        timer.stop()
        stack.append((qloop, timer))
        qApp.processEvents()  # type: ignore

    if qtLib not in ('PyQt5', 'PyQt6', 'PySide2', 'PySide6'):
        raise RuntimeError(f'Unknown Qt library: {qtLib}')
    from importlib import import_module
    qc = import_module(qtLib + '.QtCore')
    qw = import_module(qtLib + '.QtWidgets')
```

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

### TickBars Initialization

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ticker.html

Initializes TickBars with a tick count and an optional source. It sets up the bar count and an empty BarList.

```python
def __init__(self, count, source=None):
        Op.__init__(self, source)
        self._count = count
        self.bars = BarList()
```

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

### Get News Ticks

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Retrieves a list of ticks containing headline news. The full article content can be fetched using `reqNewsArticle`.

```python
def newsTicks(self) -> List[NewsTick]:
    """
    List of ticks with headline news.
    The article itself can be retrieved with :meth:`.reqNewsArticle`.
    """
    return self.wrapper.newsTicks
```

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

### Get Pending Tickers

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Retrieves a list of tickers that have pending ticks or depth of market (DOM) ticks. These are tickers that are actively updating.

```python
def pendingTickers(self) -> List[Ticker]:
    """Get a list of all tickers that have pending ticks or domTicks."""
    return list(self.wrapper.pendingTickers)
```

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

### run

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/util.html

Runs the asyncio event loop.

```APIDOC
## run(*awaitables: Awaitable, timeout: Optional[float] = None)

### Description
By default run the event loop forever. When awaitables (like Tasks, Futures or coroutines) are given then run the event loop until each has completed and return their results. An optional timeout (in seconds) can be given that will raise asyncio.TimeoutError if the awaitables are not ready within the timeout period.

### Method
N/A (Python function)

### Parameters
* **awaitables** (Awaitable) - One or more awaitable objects (Tasks, Futures, coroutines) to run.
* **timeout** (Optional[float], optional) - A timeout in seconds. Defaults to None.

### Returns
- If no awaitables are provided, runs the event loop forever (or until interrupted).
- If awaitables are provided, returns the results of the completed awaitables.
```

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

### Request Smart Components - ib_insync Client

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/client.html

Requests smart component information for a given BBO (Best Bid Offer) exchange. Requires a request ID and the exchange identifier.

```python
self.send(83, reqId, bboExchange)
```

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

### Request News Providers - ib_insync Client

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/client.html

Requests a list of available news providers. This is a simple request with no parameters.

```python
self.send(85)
```

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

### Get Realtime Bars

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Retrieves a list of all live updated bars. This includes both 5-second real-time bars and live updated historical bars.

```python
def realtimeBars(self) -> List[Union[BarDataList, RealTimeBarList]]:
    """
    Get a list of all live updated bars. These can be 5 second realtime
    bars or live updated historical bars.
    """
    return list(self.wrapper.reqId2Subscriber.values())
```

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

### Get Managed Account Names

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/client.html

Retrieves the list of account names that are currently under management. Requires an active connection to the IB gateway or TWS.

```python
return self._accounts
```

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

### ib_insync.util.run

Source: https://ib-insync.readthedocs.io/api.html

Runs the event loop, optionally waiting for specific awaitables to complete.

```APIDOC
## ib_insync.util.run(*awaitables, timeout=None)

### Description
Runs the event loop. If awaitables are provided, it runs until they complete or the timeout is reached.

### Parameters
- **awaitables** (Tasks/Futures/coroutines) - Optional - Awaitables to wait for.
- **timeout** (float) - Optional - Timeout in seconds.
```

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

### Get New Request ID

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/client.html

Generates and returns a new unique request ID for API calls. Raises a ConnectionError if the client is not connected.

```python
return self._reqIdSeq
```

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

### Get Scanner Parameters and Data (Blocking)

Source: https://ib-insync.readthedocs.io/recipes.html

Retrieves all available scanner parameters and then fetches scanner data for a specific subscription. This method is blocking.

```python
allParams = ib.reqScannerParameters()
print(allParams)

sub = ScannerSubscription(
    instrument='FUT.US',
    locationCode='FUT.GLOBEX',
    scanCode='TOP_PERC_GAIN')
scanData = ib.reqScannerData(sub)
print(scanData)
```

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

### exerciseOptions

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Exercises an options contract. This method is blocking.

```APIDOC
## exerciseOptions

### Description
Exercise an options contract.

### Method Signature
```python
exerciseOptions(contract: Contract, exerciseAction: int, exerciseQuantity: int, account: str, override: int)
```

### Parameters
* **contract** (Contract) - The option contract to be exercised.
* **exerciseAction** (int) - 
    * 1 = exercise the option
    * 2 = let the option lapse
* **exerciseQuantity** (int) - Number of contracts to be exercised.
* **account** (str) - Destination account.
* **override** (int) - 
    * 0 = no override
    * 1 = override the system's natural action

### External Documentation
https://interactivebrokers.github.io/tws-api/options.html
```

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

### Request All Open Orders Async

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Fetches all open orders, potentially including those not directly managed by the current client session. Use with caution.

```python
future = self.wrapper.startReq('openOrders')
        self.client.reqAllOpenOrders()
        return future
```

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

### FlexReport Topics Extraction

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/flexreport.html

Get the set of topics that can be extracted from a loaded FlexReport. This helps in identifying available data categories within the report.

```python
print(report.topics())
```

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

### Asynchronous Connection and Event Handling

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ibcontroller.html

This snippet demonstrates the core logic for maintaining an asynchronous connection to the IB gateway. It includes event handlers for timeouts, errors, and disconnections, along with a mechanism for probing the connection to detect hard timeouts. Use this for applications requiring continuous, resilient connectivity.

```python
        def onTimeout(idlePeriod):
            if not waiter.done():
                waiter.set_result(None)

        def onError(reqId, errorCode, errorString, contract):
            if errorCode in {100, 1100} and not waiter.done():
                waiter.set_exception(Warning(f'Error {errorCode}'))

        def onDisconnected():
            if not waiter.done():
                waiter.set_exception(Warning('Disconnected'))

        while self._runner:
            try:
                await self.controller.startAsync()
                await asyncio.sleep(self.appStartupTime)
                await self.ib.connectAsync(
                    self.host, self.port, self.clientId, self.connectTimeout,
                    self.readonly, self.account, self.raiseSyncErrors)
                self.startedEvent.emit(self)
                self.ib.setTimeout(self.appTimeout)
                self.ib.timeoutEvent += onTimeout
                self.ib.errorEvent += onError
                self.ib.disconnectedEvent += onDisconnected

                while self._runner:
                    waiter: asyncio.Future = asyncio.Future()
                    await waiter
                    # soft timeout, probe the app with a historical request
                    self._logger.debug('Soft timeout')
                    self.softTimeoutEvent.emit(self)
                    probe = self.ib.reqHistoricalDataAsync(
                        self.probeContract, '', '30 S', '5 secs',
                        'MIDPOINT', False)
                    bars = None
                    with suppress(asyncio.TimeoutError):
                        bars = await asyncio.wait_for(probe, self.probeTimeout)
                    if not bars:
                        self.hardTimeoutEvent.emit(self)
                        raise Warning('Hard timeout')
                    self.ib.setTimeout(self.appTimeout)

            except ConnectionRefusedError:
                pass
            except Warning as w:
                self._logger.warning(w)
            except Exception as e:
                self._logger.exception(e)
            finally:
                self.ib.timeoutEvent -= onTimeout
                self.ib.errorEvent -= onError
                self.ib.disconnectedEvent -= onDisconnected
                await self.controller.terminateAsync()
                self.stoppedEvent.emit(self)
                if self._runner:
                    await asyncio.sleep(self.retryDelay)
```

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

### reqUserInfoAsync

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Requests user information. Returns an awaitable that resolves to the user information.

```APIDOC
## reqUserInfoAsync

### Description
Requests user information. Returns an awaitable that resolves to the user information.

### Method
`def reqUserInfoAsync(self) `

### Returns
- An awaitable that resolves to the user information.
```

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

### run(*awaitables, timeout=None)

Source: https://ib-insync.readthedocs.io/api.html

Runs the event loop. If awaitables are provided, it runs until they complete or a timeout is reached.

```APIDOC
## run(*awaitables, timeout=None)

### Description
Runs the event loop. By default, it runs forever. If awaitables are provided, it runs until each has completed and returns their results. Raises asyncio.TimeoutError if the timeout is reached.

### Parameters
- **awaitables** (Any) - Optional - Tasks, Futures, or coroutines to run.
- **timeout** (float) - Optional - Timeout in seconds.
```

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

### Get Asyncio Event Loop - ib_insync.util

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/util.html

Retrieves the current asyncio event loop for the thread. This function is a convenient wrapper around `asyncio.get_event_loop_policy().get_event_loop()`.

```python
def getLoop():
    """Get the asyncio event loop for the current thread."""
    return asyncio.get_event_loop_policy().get_event_loop()
```

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

### timeit

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/util.html

A context manager for timing code execution.

```APIDOC
## timeit(title='Run')

### Description
Context manager for timing.

### Method
N/A (Python class)

### Parameters
* **title** (str, optional) - A title for the timing output. Defaults to 'Run'.

### Usage
```python
with timeit('My Operation'):
    # Code to time
```

### Returns
None (prints timing to console upon exiting the context)
```

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

### BarList Initialization

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ticker.html

Initializes a BarList, which is a list of Bar objects, and sets up an update event.

```python
def __init__(self, *args):
        super().__init__(*args)
        self.updateEvent = Event('updateEvent')
```

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

### Get Ticker by Contract

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Retrieves the ticker for a specific contract. The contract must have been previously requested using `reqMktData`. The ticker might not be immediately available.

```python
def ticker(self, contract: Contract) -> Optional[Ticker]:
    """
    Get ticker of the given contract. It must have been requested before
    with reqMktData with the same contract object. The ticker may not be
    ready yet if called directly after :meth:`.reqMktData`.

    Args:
        contract: Contract to get ticker for.
    """
    return self.wrapper.tickers.get(id(contract))
```

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

### Get Dataclass Fields with Non-Default Values

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/util.html

Returns a dictionary of fields from a dataclass instance that have values different from their default values. Excludes empty lists.

```python
from ib_insync.util import dataclassNonDefaults

# Assuming 'my_dataclass_instance' is an instance of a dataclass
# non_default_fields = dataclassNonDefaults(my_dataclass_instance)
```

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

### Client Class Methods

Source: https://ib-insync.readthedocs.io/api.html

The Client class provides methods for managing connections, requesting market data, placing orders, and retrieving account information.

```APIDOC
## Client Methods

- `Client.serverVersion()`
- `Client.run()`
- `Client.isConnected()`
- `Client.isReady()`
- `Client.connectionStats()`
- `Client.getReqId()`
- `Client.updateReqId()`
- `Client.getAccounts()`
- `Client.setConnectOptions()`
- `Client.connect()`
- `Client.connectAsync()`
- `Client.disconnect()`
- `Client.send()`
- `Client.sendMsg()`
- `Client.reqMktData()`
- `Client.cancelMktData()`
- `Client.placeOrder()`
- `Client.cancelOrder()`
- `Client.reqOpenOrders()`
- `Client.reqAccountUpdates()`
- `Client.reqExecutions()`
- `Client.reqIds()`
- `Client.reqContractDetails()`
- `Client.reqMktDepth()`
- `Client.cancelMktDepth()`
- `Client.reqNewsBulletins()`
- `Client.cancelNewsBulletins()`
- `Client.setServerLogLevel()`
- `Client.reqAutoOpenOrders()`
- `Client.reqAllOpenOrders()`
- `Client.reqManagedAccts()`
- `Client.requestFA()`
- `Client.replaceFA()`
- `Client.reqHistoricalData()`
- `Client.exerciseOptions()`
- `Client.reqScannerSubscription()`
- `Client.cancelScannerSubscription()`
- `Client.reqScannerParameters()`
- `Client.cancelHistoricalData()`
- `Client.reqCurrentTime()`
- `Client.reqRealTimeBars()`
- `Client.cancelRealTimeBars()`
- `Client.reqFundamentalData()`
- `Client.cancelFundamentalData()`
- `Client.calculateImpliedVolatility()`
- `Client.calculateOptionPrice()`
- `Client.cancelCalculateImpliedVolatility()`
- `Client.cancelCalculateOptionPrice()`
- `Client.reqGlobalCancel()`
- `Client.reqMarketDataType()`
- `Client.reqPositions()`
- `Client.reqAccountSummary()`
- `Client.cancelAccountSummary()`
- `Client.cancelPositions()`
- `Client.verifyRequest()`
- `Client.verifyMessage()`
- `Client.queryDisplayGroups()`
- `Client.subscribeToGroupEvents()`
- `Client.updateDisplayGroup()`
- `Client.unsubscribeFromGroupEvents()`
- `Client.startApi()`
- `Client.verifyAndAuthRequest()`
- `Client.verifyAndAuthMessage()`
- `Client.reqPositionsMulti()`
- `Client.cancelPositionsMulti()`
- `Client.reqAccountUpdatesMulti()`
- `Client.cancelAccountUpdatesMulti()`
- `Client.reqSecDefOptParams()`
- `Client.reqSoftDollarTiers()`
- `Client.reqFamilyCodes()`
- `Client.reqMatchingSymbols()`
- `Client.reqMktDepthExchanges()`
- `Client.reqSmartComponents()`
- `Client.reqNewsArticle()`
- `Client.reqNewsProviders()`
- `Client.reqHistoricalNews()`
- `Client.reqHeadTimeStamp()`
- `Client.reqHistogramData()`
- `Client.cancelHistogramData()`
- `Client.cancelHeadTimeStamp()`
- `Client.reqMarketRule()`
- `Client.reqPnL()`
- `Client.cancelPnL()`
- `Client.reqPnLSingle()`
- `Client.cancelPnLSingle()`
- `Client.reqHistoricalTicks()`
- `Client.reqTickByTickData()`
- `Client.cancelTickByTickData()`
- `Client.reqCompletedOrders()`
- `Client.reqWshMetaData()`
- `Client.cancelWshMetaData()`
- `Client.reqWshEventData()`
- `Client.cancelWshEventData()`
- `Client.reqUserInfo()`
```

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

### connectAsync

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Establishes an API connection to the Interactive Brokers TWS or Gateway. It handles initial data synchronization for positions, orders, and account details.

```APIDOC
## connectAsync

### Description
Establishes an API connection to the Interactive Brokers TWS or Gateway. It handles initial data synchronization for positions, orders, and account details.

### Method
`async def connectAsync(self, host: str, port: int, clientId: int, timeout: float)`

### Parameters
- **host** (str) - The hostname or IP address of the TWS or Gateway.
- **port** (int) - The port number for the connection.
- **clientId** (int) - A unique client ID for this connection.
- **timeout** (float) - The timeout in seconds for the connection and initial requests.

### Returns
- `IB` - The IB instance after successful connection and synchronization.
```

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

### connect

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/client.html

Connect to a running TWS or IB gateway application.

```APIDOC
## connect

### Description
Connect to a running TWS or IB gateway application.

### Parameters
- **host** (str) - Host name or IP address.
- **port** (int) - Port number.
- **clientId** (int) - ID number to use for this client; must be unique per connection.
- **timeout** (Optional[float]) - If establishing the connection takes longer than ``timeout`` seconds then the ``asyncio.TimeoutError`` exception is raised. Set to 0 to disable timeout. Defaults to 2.0.
```

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

### Request User Info Async

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Asynchronously requests user information. This method initiates a request and returns an Awaitable that will resolve with the user's details.

```python
reqId = self.client.getReqId()
        future = self.wrapper.startReq(reqId)
        self.client.reqUserInfo(reqId)
        return future
```

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

### Get WSH Meta Data Async

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Asynchronously retrieves WSH (Websocket Handler) metadata. It first cancels any existing metadata request before initiating a new one and awaiting its completion.

```python
if self.wrapper.wshMetaReqId:
            self.cancelWshMetaData()
        self.reqWshMetaData()
        future = self.wrapper.startReq(
            self.wrapper.wshMetaReqId, container='')
        await future
        return future.result()
```

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

### Get Wall Street Horizon Metadata (Blocking)

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

A blocking convenience method to retrieve Wall Street Horizon metadata as a JSON string. Requires a Wall Street Horizon subscription.

```python
# Get the list of available filters and event types:
meta = ib.getWshMetaData()
print(meta)
```

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

### Request Open Orders Async

Source: https://ib-insync.readthedocs.io/_modules/ib_insync/ib.html

Fetches all currently open orders. This is a standard method for retrieving active orders.

```python
future = self.wrapper.startReq('openOrders')
        self.client.reqOpenOrders()
        return future
```
Tokens:
Raw