PyKiteConnect

https://kite.trade/docs/pykiteconnect/v4/
Admin
PyKiteConnect is a Python client library for the Kite Connect API, offering an easy-to-use...
Tokens:54,246
Snippets:374
Trust Score:9.2
Update:3 months ago
Show doc for...
Tokens:
Raw
### Tick Data Structure Example

Source: https://kite.trade/docs/pykiteconnect/v4

This example shows the structure of tick data received by the `on_ticks` callback, including instrument details, trade information, and market depth.

```python
[{
            'instrument_token': 53490439,
            'mode': 'full',
            'volume_traded': 12510,
            'last_price': 4084.0,
            'average_traded_price': 4086.55,
            'last_traded_quantity': 1,
            'total_buy_quantity': 2356,
            'total_sell_quantity': 2440,
            'change': 0.46740467404674046,
            'last_trade_time': datetime.datetime(2018, 1, 15, 13, 16, 54),
            'exchange_timestamp': datetime.datetime(2018, 1, 15, 13, 16, 56),
            'oi': 21845,
            'oi_day_low': 0,
            'oi_day_high': 0,
            'ohlc': {
                'high': 4093.0,
                'close': 4065.0,
                'open': 4088.0,
                'low': 4080.0
            },
            'tradable': True,
            'depth': {
                'sell': [{
                    'price': 4085.0,
                    'orders': 1048576,
                    'quantity': 43
                }, {
                    'price': 4086.0,
                    'orders': 2752512,
                    'quantity': 134
                }, {
                    'price': 4087.0,
                    'orders': 1703936,
                    'quantity': 133
                }, {
                    'price': 4088.0,
                    'orders': 1376256,
                    'quantity': 70
                }, {
                    'price': 4089.0,
                    'orders': 1048576,
                    'quantity': 46
                }],
                'buy': [{
                    'price': 4084.0,
                    'orders': 589824,
                    'quantity': 53
                }, {
                    'price': 4083.0,
                    'orders': 1245184,
                    'quantity': 145
                }, {
                    'price': 4082.0,
                    'orders': 1114112,
                    'quantity': 63
                }, {
                    'price': 4081.0,
                    'orders': 1835008,
                    'quantity': 69
                }, {
                    'price': 4080.0,
                    'orders': 2752512,
                    'quantity': 89
                }]
            }
        },
        ...,
        ...]

```

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

### Make HTTP GET Request

Source: https://kite.trade/docs/pykiteconnect/v4

An alias for sending a GET request to a specified route. Use this for retrieving data from the API.

```python
def _get(self, route, url_args=None, params=None, is_json=False):
        """Alias for sending a GET request."""
        return self._request(route, "GET", url_args=url_args, params=params, is_json=is_json)
```

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

### Get Instruments

Source: https://kite.trade/docs/pykiteconnect/v4

Fetches the list of available trading instruments.

```python
kite.instruments()
```

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

### orders

Source: https://kite.trade/docs/pykiteconnect/v4

Gets a list of all orders.

```APIDOC
## orders

### Description
Gets a list of all orders.

### Method
GET

### Endpoint
/orders

### Response
#### Success Response (200)
- **orders** (array) - A list of order objects.

### Response Example
```json
[
  {
    "order_id": "order123",
    "tradingsymbol": "RELIANCE",
    "exchange": "NSE",
    "transaction_type": "BUY",
    "quantity": 1,
    "product": "CNC",
    "order_type": "LIMIT",
    "status": "complete"
  },
  {
    "order_id": "order456",
    "tradingsymbol": "INFY",
    "exchange": "NSE",
    "transaction_type": "SELL",
    "quantity": 2,
    "product": "MIS",
    "order_type": "MARKET",
    "status": "open"
  }
]
```
```

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

### orders

Source: https://kite.trade/docs/pykiteconnect/v4

Get a list of all open orders.

```APIDOC
## orders

### Description
Get a list of all open orders.

### Method Signature
```python
def orders(self)
```
```

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

### Get User Profile

Source: https://kite.trade/docs/pykiteconnect/v4

Fetches the user's profile details.

```python
return self._get("user.profile")
```

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

### Get Mutual Fund Instruments

Source: https://kite.trade/docs/pykiteconnect/v4

Retrieve a list of available mutual fund instruments.

```python
def mf_instruments(self):
    """Get list of mutual fund instruments."""
    return self._parse_mf_instruments(self._get("mf.instruments"))
```

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

### Get Virtual Contract Note

Source: https://kite.trade/docs/pykiteconnect/v4

Calculate detailed charges order-wise for the order book. The `params` argument should be a list of orders for which to fetch charge details.

```python
def get_virtual_contract_note(self, params):
    """
    Calculates detailed charges order-wise for the order book
    - `params` is list of orders to fetch charges detail
    """
    return self._post("order.contract_note",
                      params=params,
                      is_json=True)

```

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

### Place Mutual Fund SIP

Source: https://kite.trade/docs/pykiteconnect/v4

Place a mutual fund Systematic Investment Plan (SIP). Configure amount, installments, frequency, and optional initial amount or installment day.

```python
def place_mf_sip(self,
                 tradingsymbol,
                 amount,
                 instalments,
                 frequency,
                 initial_amount=None,
                 instalment_day=None,
                 tag=None):
    """Place a mutual fund SIP."""
    return self._post("mf.sip.place", params={
        "tradingsymbol": tradingsymbol,
        "amount": amount,
        "initial_amount": initial_amount,
        "instalments": instalments,
        "frequency": frequency,
        "instalment_day": instalment_day,
        "tag": tag
    })

```

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

### mf_instruments

Source: https://kite.trade/docs/pykiteconnect/v4

Get the list of mutual fund instruments.

```APIDOC
## mf_instruments

### Description
Get the list of mutual fund instruments.

### Method
GET

### Endpoint
/mf.instruments

### Parameters
None

### Response
#### Success Response (200)
- **instruments** (list) - A list of mutual fund instruments.
```

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

### Get Mutual Fund Instruments

Source: https://kite.trade/docs/pykiteconnect/v4

Retrieves the list of available mutual fund instruments.

```python
kite.mf_instruments()
```

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

### Get List of Orders - Python

Source: https://kite.trade/docs/pykiteconnect/v4

Retrieves a list of all current orders. No parameters are required.

```python
def orders(self):
    """Get list of orders."""
    return self._format_response(self._get("orders"))
```

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

### profile

Source: https://kite.trade/docs/pykiteconnect/v4

Get user profile details.

```APIDOC
## profile

### Description
Get user profile details.

### Method Signature
`profile(self)`
```

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

### Get Virtual Contract Note

Source: https://kite.trade/docs/pykiteconnect/v4

Calculates detailed charges order-wise for the order book.

```APIDOC
## POST /order.contract_note

### Description
Calculates detailed charges for each order in the order book.

### Method
POST

### Endpoint
/order.contract_note

### Parameters
#### Request Body
- **params** (list) - A list of order objects for which to fetch charge details.
```

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

### Get Virtual Contract Note

Source: https://kite.trade/docs/pykiteconnect/v4

Calculates detailed charges order-wise for the order book. The `params` argument should be a list of orders for which to fetch charge details. This is useful for analyzing order-specific costs.

```python
def get_virtual_contract_note(
self,
    params)
Calculates detailed charges order-wise for the order book - `params` is list of orders to fetch charges detail
Show source ≡
def get_virtual_contract_note(self, params):
    """
    Calculates detailed charges order-wise for the order book
    - `params` is list of orders to fetch charges detail
    """
    return self._post("order.contract_note",
                      params=params,
                      is_json=True)
```

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

### Get Market Quotes

Source: https://kite.trade/docs/pykiteconnect/v4

Retrieve quote information for a list of instruments. Instruments should be in the format 'exchange:tradingsymbol'.

```python
def quote(self, *instruments):
    """
    Retrieve quote for list of instruments.
    - `instruments` is a list of instruments, Instrument are in the format of `exchange:tradingsymbol`. For example NSE:INFY
    """
    ins = list(instruments)
    # If first element is a list then accept it as instruments list for legacy reason
    if len(instruments) > 0 and type(instruments[0]) == list:
        ins = instruments[0]
    data = self._get("market.quote", params={"i": ins})
    return {key: self._format_response(data[key]) for key in data}
```

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

### Get Mutual Fund SIPs

Source: https://kite.trade/docs/pykiteconnect/v4

Retrieve a list of all mutual fund SIPs or specific information for a given SIP ID.

```python
def mf_sips(self, sip_id=None):
    """Get list of all mutual fund SIP's or individual SIP info."""
    if sip_id:
        return self._format_response(self._get("mf.sip.info", url_args={"sip_id": sip_id}))
    else:
        return self._format_response(self._get("mf.sips"))
```

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

### Get Auction Instruments

Source: https://kite.trade/docs/pykiteconnect/v4

Retrieves a list of instruments that are available for trading during an auction session.

```python
def get_auction_instruments(self):
        """ Retrieves list of available instruments for a auction session """
        return self._get("portfolio.holdings.auction")
```

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

### Get List of Orders

Source: https://kite.trade/docs/pykiteconnect/v4

Retrieves a list of all current orders. The response is formatted for easier handling.

```python
def orders(self):
        """Get list of orders."""
        return self._format_response(self._get("orders"))
```

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

### mf_sips

Source: https://kite.trade/docs/pykiteconnect/v4

Get a list of all mutual fund SIPs or individual SIP information.

```APIDOC
## mf_sips

### Description
Get a list of all mutual fund SIPs or individual SIP information.

### Method
GET

### Endpoint
/mf.sips or /mf.sip.info

### Parameters
#### Query Parameters
- **sip_id** (string) - Optional - The ID of a specific mutual fund SIP.

### Response
#### Success Response (200)
- **sips** (list or object) - A list of mutual fund SIPs or details of a specific SIP.
```

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

### Get Auction Instruments

Source: https://kite.trade/docs/pykiteconnect/v4

Retrieves a list of available instruments for an auction session. This method is used to fetch instruments participating in an auction.

```python
def get_auction_instruments(
self)
Retrieves list of available instruments for a auction session
Show source ≡
def get_auction_instruments(self):
    """ Retrieves list of available instruments for a auction session """
    return self._get("portfolio.holdings.auction")
```

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

### Get Instrument Quotes

Source: https://kite.trade/docs/pykiteconnect/v4

Retrieve quote information for a list of instruments. Instruments should be formatted as 'exchange:tradingsymbol'.

```python
def quote(self, *instruments):
    """
    Retrieve quote for list of instruments.

    - `instruments` is a list of instruments, Instrument are in the format of `exchange:tradingsymbol`. For example NSE:INFY
    """
    ins = list(instruments)

    # If first element is a list then accept it as instruments list for legacy reason
    if len(instruments) > 0 and type(instruments[0]) == list:
        ins = instruments[0]

    data = self._get("market.quote", params={"i": ins})
    return {key: self._format_response(data[key]) for key in data}
```

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

### Get Instrument OHLC and Market Depth

Source: https://kite.trade/docs/pykiteconnect/v4

Retrieve OHLC (Open, High, Low, Close) and market depth data for a list of instruments. Instruments should be formatted as 'exchange:tradingsymbol'.

```python
def ohlc(self, *instruments):
    """
    Retrieve OHLC and market depth for list of instruments.

    - `instruments` is a list of instruments, Instrument are in the format of `exchange:tradingsymbol`. For example NSE:INFY
    """
    ins = list(instruments)

    # If first element is a list then accept it as instruments list for legacy reason
    if len(instruments) > 0 and type(instruments[0]) == list:
        ins = instruments[0]

    return self._get("market.quote.ohlc", params={"i": ins})
```

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

### Initialize KiteConnect and Place an Order

Source: https://kite.trade/docs/pykiteconnect/v4

Demonstrates how to initialize the KiteConnect client, generate a session, and place a market order for a stock. Includes basic error handling for order placement.

```python
# -*- coding: utf-8 -*-
"""
Kite Connect API client for Python -- [kite.trade](https://kite.trade).

Zerodha Technology Pvt. Ltd. (c) 2021

License
-------
KiteConnect Python library is licensed under the MIT License

The library
-----------
Kite Connect is a set of REST-like APIs that expose
many capabilities required to build a complete
investment and trading platform. Execute orders in
real time, manage user portfolio, stream live market
data (WebSockets), and more, with the simple HTTP API collection

This module provides an easy to use abstraction over the HTTP APIs.
The HTTP calls have been converted to methods and their JSON responses
are returned as native Python structures, for example, dicts, lists, bools etc.
See the **[Kite Connect API documentation](https://kite.trade/docs/connect/v3/)**
for the complete list of APIs, supported parameters and values, and response formats.

Getting started
---------------
    #!python
    import logging
    from kiteconnect import KiteConnect

    logging.basicConfig(level=logging.DEBUG)

    kite = KiteConnect(api_key="your_api_key")

    # Redirect the user to the login url obtained
    # from kite.login_url(), and receive the request_token
    # from the registered redirect url after the login flow.
    # Once you have the request_token, obtain the access_token
    # as follows.

    data = kite.generate_session("request_token_here", api_secret="your_secret")
    kite.set_access_token(data["access_token"])

    # Place an order
    try:
        order_id = kite.place_order(variety=kite.VARIETY_REGULAR,
                                    tradingsymbol="INFY",
                                    exchange=kite.EXCHANGE_NSE,
                                    transaction_type=kite.TRANSACTION_TYPE_BUY,
                                    quantity=1,
                                    order_type=kite.ORDER_TYPE_MARKET,
                                    product=kite.PRODUCT_CNC,
                                    validity=kite.VALIDITY_DAY)

        logging.info("Order placed. ID is: {}".format(order_id))
    except Exception as e:
        logging.info("Order placement failed: {}".format(e.message))

    # Fetch all orders
    kite.orders()

    # Get instruments
    kite.instruments()

    # Place an mutual fund order
    kite.place_mf_order(
        tradingsymbol="INF090I01239",
        transaction_type=kite.TRANSACTION_TYPE_BUY,
        amount=5000,
        tag="mytag"
    )

    # Cancel a mutual fund order
    kite.cancel_mf_order(order_id="order_id")

    # Get mutual fund instruments
    kite.mf_instruments()

A typical web application
-------------------------
In a typical web application where a new instance of
views, controllers etc. are created per incoming HTTP
request, you will need to initialise a new instance of
Kite client per request as well. This is because each
individual instance represents a single user that's
authenticated, unlike an **admin** API where you may
use one instance to manage many users.

Hence, in your web application, typically:

- You will initialise an instance of the Kite client
- Redirect the user to the `login_url()`
- At the redirect url endpoint, obtain the
`request_token` from the query parameters
- Initialise a new instance of Kite client, use `generate_session()` to obtain the `access_token`
along with authenticated user data
- Store this response in a session and use the
stored `access_token` and initialise instances
of Kite client for subsequent API calls.

Exceptions
----------
Kite Connect client saves you the hassle of detecting API errors
by looking at HTTP codes or JSON error responses. Instead,
it raises aptly named **[exceptions](exceptions.m.html)** that you can catch.
"""

from __future__ import unicode_literals, absolute_import

from kiteconnect import exceptions
from kiteconnect.connect import KiteConnect
from kiteconnect.ticker import KiteTicker

__all__ = ["KiteConnect", "KiteTicker", "exceptions"]

```

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

### Get User Profile

Source: https://kite.trade/docs/pykiteconnect/v4

Get user profile details. This method makes a GET request to the user profile endpoint.

```python
def profile(self):
    """Get user profile details."""
    return self._get("user.profile")

```

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

### Initialize KiteConnect and Place an Order

Source: https://kite.trade/docs/pykiteconnect/v4

Demonstrates initializing the KiteConnect client, generating a session using a request token and secret, and placing a market order for an equity symbol. Includes error handling for order placement.

```python
import logging
from kiteconnect import KiteConnect

logging.basicConfig(level=logging.DEBUG)

kite = KiteConnect(api_key="your_api_key")

# Redirect the user to the login url obtained
# from kite.login_url(), and receive the request_token
# from the registered redirect url after the login flow.
# Once you have the request_token, obtain the access_token
# as follows.

data = kite.generate_session("request_token_here", api_secret="your_secret")
kite.set_access_token(data["access_token"])

# Place an order
try:
    order_id = kite.place_order(variety=kite.VARIETY_REGULAR,
                                tradingsymbol="INFY",
                                exchange=kite.EXCHANGE_NSE,
                                transaction_type=kite.TRANSACTION_TYPE_BUY,
                                quantity=1,
                                order_type=kite.ORDER_TYPE_MARKET,
                                product=kite.PRODUCT_CNC,
                                validity=kite.VALIDITY_DAY)

    logging.info("Order placed. ID is: {}".format(order_id))
except Exception as e:
    logging.info("Order placement failed: {}".format(e.message))
```

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

### Place Mutual Fund SIP

Source: https://kite.trade/docs/pykiteconnect/v4

Initiate a new mutual fund Systematic Investment Plan (SIP). Requires trading symbol, amount, number of installments, and frequency.

```python
def place_mf_sip(self,
                     tradingsymbol,
                     amount,
                     instalments,
                     frequency,
                     initial_amount=None,
                     instalment_day=None,
                     tag=None):
    """Place a mutual fund SIP."""
    return self._post("mf.sip.place", params={
        "tradingsymbol": tradingsymbol,
        "amount": amount,
        "initial_amount": initial_amount,
        "instalments": instalments,
        "frequency": frequency,
        "instalment_day": instalment_day,
        "tag": tag
    })
```

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

### Initialize and Connect KiteTicker

Source: https://kite.trade/docs/pykiteconnect/v4

Demonstrates how to initialize the KiteTicker client, define callbacks for connection events, and establish a connection. Ensure you have your API key and access token.

```python
import logging
from kiteconnect import KiteTicker

logging.basicConfig(level=logging.DEBUG)

# Initialise
kws = KiteTicker("your_api_key", "your_access_token")

def on_ticks(ws, ticks):
    # Callback to receive ticks.
    logging.debug("Ticks: {}".format(ticks))

def on_connect(ws, response):
    # Callback on successful connect.
    # Subscribe to a list of instrument_tokens (RELIANCE and ACC here).
    ws.subscribe([738561, 5633])

    # Set RELIANCE to tick in `full` mode.
    ws.set_mode(ws.MODE_FULL, [738561])

def on_close(ws, code, reason):
    # On connection close stop the event loop.
    # Reconnection will not happen after executing `ws.stop()`
    ws.stop()

# Assign the callbacks.
kws.on_ticks = on_ticks
kws.on_connect = on_connect
kws.on_close = on_close

# Infinite loop on the main thread. Nothing after this will run.
# You have to use the pre-defined callbacks to manage subscriptions.
kws.connect()
```

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

### Modify Mutual Fund SIP

Source: https://kite.trade/docs/pykiteconnect/v4

This function modifies an existing mutual fund SIP. You can update the amount, status, number of installments, frequency, or the installment day.

```python
def modify_mf_sip(self,
                  sip_id,
                  amount=None,
                  status=None,
                  instalments=None,
                  frequency=None,
                  instalment_day=None):
    """Modify a mutual fund SIP."""
    return self._put("mf.sip.modify",
                     url_args={"sip_id": sip_id},
                     params={
                         "amount": amount,
                         "status": status,
                         "instalments": instalments,
                         "frequency": frequency,
                         "instalment_day": instalment_day
                     })

```

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

### Establish WebSocket Connection

Source: https://kite.trade/docs/pykiteconnect/v4

Sets up the SSL context if required and initiates a WebSocket connection to the server. Includes optional logging for debugging.

```python
# Set SSL context
context_factory = None
if self.factory.isSecure and not disable_ssl_verification:
    context_factory = ssl.ClientContextFactory()

# Establish WebSocket connection to a server
connectWS(self.factory, contextFactory=context_factory, timeout=self.connect_timeout)

if self.debug:
    twisted_log.startLogging(sys.stdout)
```

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

### Get Account Margins

Source: https://kite.trade/docs/pykiteconnect/v4

Retrieves account balance and cash margin details. Optionally, specify a trading segment like 'equity' or 'commodity' to get segment-specific details.

```python
if segment:
    return self._get("user.margins.segment", url_args={"segment": segment})
else:
    return self._get("user.margins")
```

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

### modify_mf_sip

Source: https://kite.trade/docs/pykiteconnect/v4

Modify an existing mutual fund Systematic Investment Plan (SIP). Allows changes to the SIP amount, status, number of installments, frequency, and installment day.

```APIDOC
## modify_mf_sip

### Description
Modify a mutual fund SIP. Allows changes to the SIP amount, status, number of installments, frequency, and installment day.

### Method
PUT

### Endpoint
/mf.sip.modify

### Parameters
#### Path Parameters
- **sip_id** (string) - Required - The ID of the SIP to modify.

#### Query Parameters
- **amount** (float) - Optional - The new SIP amount.
- **status** (string) - Optional - The new status of the SIP (e.g., 'active', 'paused', 'cancelled').
- **instalments** (integer) - Optional - The new number of installments.
- **frequency** (string) - Optional - The new frequency of the SIP (e.g., 'daily', 'weekly', 'monthly').
- **instalment_day** (integer) - Optional - The new day of the month for the installment.

### Request Example
```json
{
  "amount": 5000,
  "status": "active",
  "instalments": 12,
  "frequency": "monthly",
  "instalment_day": 15
}
```

### Response
#### Success Response (200)
Details of the modified MF SIP.

#### Response Example
```json
{
  "status": "success",
  "data": {
    "sip_id": "sip123"
  }
}
```
```

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

### KiteConnect Client Initialization

Source: https://kite.trade/docs/pykiteconnect/v4

Initializes a new Kite Connect client instance with provided API key and optional parameters for authentication, configuration, and network settings.

```APIDOC
## KiteConnect Client Initialization

### Description
Initializes a new Kite Connect client instance. This is the primary step to interact with the Kite Connect API.

### Method
`__init__`

### Parameters
- **api_key** (string) - Required - Your unique API key issued by Kite.
- **access_token** (string) - Optional - The access token obtained after the login flow. Persist this for subsequent requests.
- **root** (string) - Optional - The API endpoint root. Defaults to the standard Kite Connect endpoint.
- **debug** (boolean) - Optional - If True, prints requests and responses to stdout for debugging. Defaults to False.
- **timeout** (integer) - Optional - Time in seconds to wait for a request to complete. Defaults to 7 seconds.
- **proxies** (dict) - Optional - Dictionary to configure request proxies. See Python requests documentation for usage.
- **pool** (dict) - Optional - Dictionary of parameters for request pools, accepted by HTTPAdapter.
- **disable_ssl** (boolean) - Optional - Disables SSL verification. Defaults to False.

### Request Example
```python
from kiteconnect import KiteConnect

kite = KiteConnect(api_key="YOUR_API_KEY")
```

### Response
This method initializes the client object. No direct response is returned, but the client is ready for API calls.
```

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

### Initialize Kite Connect Client

Source: https://kite.trade/docs/pykiteconnect/v4

Initializes a new Kite Connect client instance. Requires an API key and optionally an access token, root URI, debug mode, timeout, proxies, request pool, or SSL disabling.

```python
def __init__(
             api_key,
             access_token=None,
             root=None,
             debug=False,
             timeout=None,
             proxies=None,
             pool=None,
             disable_ssl=False):
    """
    Initialise a new Kite Connect client instance.
    - `api_key` is the key issued to you
    - `access_token` is the token obtained after the login flow in
        exchange for the `request_token` . Pre-login, this will default to None,
    but once you have obtained it, you should
    persist it in a database or session to pass
    to the Kite Connect class initialisation for subsequent requests.
    - `root` is the API end point root. Unless you explicitly
    want to send API requests to a non-default endpoint,
    this
    can be ignored.
    - `debug`, if set to True, will serialise and print requests
    and responses to stdout.
    - `timeout` is the time (seconds) for which the API client will wait for
    a request to complete before it fails. Defaults to 7 seconds
    - `proxies` to set requests proxy.
    Check [python requests documentation](http://docs.python-requests.org/en/master/user/advanced/#proxies) for usage and examples.
    - `pool` is manages request pools. It takes a dict of params accepted by HTTPAdapter as described here in [python requests documentation](http://docs.python-requests.org/en/master/api/#requests.adapters.HTTPAdapter)
    - `disable_ssl` disables the SSL verification while making a request.
    If set requests won't throw SSLError if its set to custom `root` url without SSL.
    """
    self.debug = debug
    self.api_key = api_key
    self.session_expiry_hook = None
    self.disable_ssl = disable_ssl
    self.access_token = access_token
    self.proxies = proxies if proxies else {}
    self.root = root or self._default_root_uri
    self.timeout = timeout or self._default_timeout
    # Create requests session by default
    # Same session to be used by pool connections
    self.reqsession = requests.Session()
    if pool:
        reqadapter = requests.adapters.HTTPAdapter(**pool)
        self.reqsession.mount("https://", reqadapter)
    # disable requests SSL warning
    requests.packages.urllib3.disable_warnings()

```

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

### KiteConnect Initialization

Source: https://kite.trade/docs/pykiteconnect/v4

Initializes a new KiteConnect client instance. It's recommended to initialize a single instance per api_key in production.

```APIDOC
## KiteConnect Initialization

### Description
Initializes a new KiteConnect client instance. It's recommended to initialize a single instance per api_key in production.

### Method
__init__

### Parameters
- **api_key** (string) - Required - Your API key.
- **access_token** (string) - Optional - The user's access token.
- **root** (string) - Optional - The root API endpoint. Defaults to https://api.kite.trade.
- **debug** (boolean) - Optional - Enable debug logging.
- **timeout** (integer) - Optional - Request timeout in seconds. Defaults to 7.
- **proxies** (dict) - Optional - Dictionary of proxies to use for requests.
- **pool** (object) - Optional - A requests.Session object for connection pooling.
- **disable_ssl** (boolean) - Optional - Disable SSL verification.
```

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

### KiteConnect Initialization

Source: https://kite.trade/docs/pykiteconnect/v4

Initializes the Kite Connect client with various configuration options. Key parameters include api_key, access_token, root URL, debug mode, timeout, proxies, and SSL verification settings.

```APIDOC
## KiteConnect(api_key, access_token=None, root=None, debug=False, timeout=None, proxies=None, pool=None, disable_ssl=False)

### Description
Initializes the Kite Connect client with API credentials and configuration settings.

### Parameters
- **api_key** (string) - Your unique API key.
- **access_token** (string, optional) - The access token obtained after a successful login flow. Defaults to None.
- **root** (string, optional) - The API endpoint root. Defaults to the standard Kite Connect endpoint.
- **debug** (boolean, optional) - If True, serializes and prints requests and responses to stdout. Defaults to False.
- **timeout** (integer, optional) - The time in seconds to wait for a request to complete. Defaults to 7 seconds.
- **proxies** (dict, optional) - Dictionary to set request proxies. Refer to python requests documentation for usage.
- **pool** (dict, optional) - Manages request pools. Takes a dict of params accepted by HTTPAdapter.
- **disable_ssl** (boolean, optional) - Disables SSL verification. Defaults to False.
```

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

### Modify Mutual Fund SIP

Source: https://kite.trade/docs/pykiteconnect/v4

Update an existing mutual fund SIP by providing the SIP ID and the fields to modify, such as amount, status, installments, frequency, or installment day.

```python
def modify_mf_sip(self,
                      sip_id,
                      amount=None,
                      status=None,
                      instalments=None,
                      frequency=None,
                      instalment_day=None):
    """Modify a mutual fund SIP."""
    return self._put("mf.sip.modify",
                     url_args={"sip_id": sip_id},
                     params={
                         "amount": amount,
                         "status": status,
                         "instalments": instalments,
                         "frequency": frequency,
                         "instalment_day": instalment_day
                     })
```

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

### Initialize Kite Connect with Session Pool

Source: https://kite.trade/docs/pykiteconnect/v4

Initializes the Kite Connect client, setting up a requests session with a custom pool for managing connections. SSL verification can be disabled if needed.

```python
from kiteconnect import KiteConnect
import requests

# Example initialization with a custom pool
# The pool parameter takes a dict of params accepted by HTTPAdapter
# as described here in python requests documentation: http://docs.python-requests.org/en/master/api/#requests.adapters.HTTPAdapter

pool = {
    "pool_connections": 10,
    "pool_maxsize": 10,
    "max_retries": 3,
    "backoff_factor": 0.1
}

kite = KiteConnect(api_key="your_api_key", pool=pool, disable_ssl=True)
```

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

### KiteConnect.connect

Source: https://kite.trade/docs/pykiteconnect/v4

Establishes a WebSocket connection with optional settings for threading, SSL verification, and proxy.

```APIDOC
## KiteConnect.connect

### Description
Establishes a websocket connection.

### Method
connect

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **threaded** (boolean) - Optional - A boolean indicating if the websocket client should run in threaded mode. Defaults to False.
- **disable_ssl_verification** (boolean) - Optional - Disables building the SSL context. Defaults to False.
- **proxy** (dictionary) - Optional - A dictionary with keys `host` and `port` which denotes the proxy settings.

### Request Example
```python
# Connect in threaded mode
kite.connect(threaded=True)

# Connect with proxy settings
proxy_settings = {
    "host": "localhost",
    "port": 8080
}
kite.connect(proxy=proxy_settings)
```

### Response
None

#### Success Response (200)
None

#### Response Example
None
```

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

### Connect and Subscribe to Ticks

Source: https://kite.trade/docs/pykiteconnect/v4

This snippet demonstrates how to initialize the KiteTicker, set up callbacks for ticks, connection, and disconnection, and then connect to the WebSocket. It subscribes to specific instrument tokens and sets the tick mode.

```python
#!python
import logging
from kiteconnect import KiteTicker

logging.basicConfig(level=logging.DEBUG)

# Initialise
kws = KiteTicker("your_api_key", "your_access_token")

def on_ticks(ws, ticks):
    # Callback to receive ticks.
    logging.debug("Ticks: {}".format(ticks))

def on_connect(ws, response):
    # Callback on successful connect.
    # Subscribe to a list of instrument_tokens (RELIANCE and ACC here).
    ws.subscribe([738561, 5633])

    # Set RELIANCE to tick in `full` mode.
    ws.set_mode(ws.MODE_FULL, [738561])

def on_close(ws, code, reason):
    # On connection close stop the event loop.
    # Reconnection will not happen after executing `ws.stop()`
    ws.stop()

# Assign the callbacks.
kws.on_ticks = on_ticks
kws.on_connect = on_connect
kws.on_close = on_close

# Infinite loop on the main thread. Nothing after this will run.
# You have to use the pre-defined callbacks to manage subscriptions.
kws.connect()


```

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

### order_history

Source: https://kite.trade/docs/pykiteconnect/v4

Get the history of an individual order.

```APIDOC
## order_history

### Description
Get the history of an individual order.

### Method Signature
```python
def order_history(self, order_id)
```

### Parameters
- **order_id** (string) - Required - The ID of the order to retrieve history for.
```

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

### KiteConnect Initialization

Source: https://kite.trade/docs/pykiteconnect/v4

Initializes the Kite Connect WebSocket client instance with API credentials and connection parameters.

```APIDOC
## KiteConnect __init__

### Description
Initializes the websocket client instance with API key, access token, and various connection and reconnection settings.

### Method
__init__

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Parameters
- **api_key** (string) - Required - The API key issued to you.
- **access_token** (string) - Required - The token obtained after the login flow in exchange for the `request_token`. This should be persisted for subsequent requests.
- **debug** (boolean) - Optional - Enables logs. Defaults to False.
- **root** (string) - Optional - The websocket API end point root. Defaults to the default URI.
- **reconnect** (boolean) - Optional - Enables WebSocket reconnection in case of network failure/disconnection. Defaults to True.
- **reconnect_max_tries** (integer) - Optional - Maximum number of reconnection attempts. Defaults to 50, with a maximum of 300.
- **reconnect_max_delay** (integer) - Optional - Maximum delay in seconds after which subsequent reconnection interval will become constant. Defaults to 60s, with a minimum acceptable value of 5s.
- **connect_timeout** (integer) - Optional - Maximum interval in seconds after which connection is considered as timeout. Defaults to 30s.

### Request Example
```python
from kiteconnect import KiteConnect

kite = KiteConnect(api_key="YOUR_API_KEY", access_token="YOUR_ACCESS_TOKEN")
```

### Response
None

#### Success Response (200)
None

#### Response Example
None
```

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

### Establish WebSocket Connection

Source: https://kite.trade/docs/pykiteconnect/v4

Establishes a WebSocket connection with optional threading, SSL verification disabling, and proxy settings. Custom headers for version 3 are included.

```python
def connect(self, threaded=False, disable_ssl_verification=False, proxy=None):
    """
    Establish a websocket connection.
    - `threaded` is a boolean indicating if the websocket client has to be run in threaded mode or not
    - `disable_ssl_verification` disables building ssl context
    - `proxy` is a dictionary with keys `host` and `port` which denotes the proxy settings
    """
    # Custom headers
    headers = {
        "X-Kite-Version": "3",  # For version 3
    }
    # Init WebSocket client factory
    self._create_connection(self.socket_url,
                            useragent=self._user_agent(),
                            proxy=proxy, headers=headers)
    # Set SSL context
    context_factory = None
    if self.factory.isSecure and not disable_ssl_verification:
        context_factory = ssl.ClientContextFactory()
    # Establish WebSocket connection to a server
    connectWS(self.factory, contextFactory=context_factory, timeout=self.connect_timeout)
    if self.debug:
        twisted_log.startLogging(sys.stdout)
    # Run in seperate thread of blocking
    opts = {}
    # Run when reactor is not running
    if not reactor.running:
        if threaded:
            # Signals are not allowed in non main thread by twisted so suppress it.
            opts["installSignalHandlers"] = False
            self.websocket_thread = threading.Thread(target=reactor.run, kwargs=opts)
            self.websocket_thread.daemon = True
            self.websocket_thread.start()
        else:
            reactor.run(**opts)

```

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

### mf_holdings

Source: https://kite.trade/docs/pykiteconnect/v4

Get the list of mutual fund holdings.

```APIDOC
## mf_holdings

### Description
Get the list of mutual fund holdings.

### Method
GET

### Endpoint
/mf.holdings

### Parameters
None

### Response
#### Success Response (200)
- **holdings** (list) - A list of mutual fund holdings.
```

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

### Initialize Kite Connect WebSocket Client

Source: https://kite.trade/docs/pykiteconnect/v4

Initializes the WebSocket client with API credentials and connection parameters. Supports optional reconnection and connection timeouts.

```python
def __init__(self, api_key, access_token, debug=False, root=None,
             reconnect=True, reconnect_max_tries=RECONNECT_MAX_TRIES, reconnect_max_delay=RECONNECT_MAX_DELAY,
             connect_timeout=CONNECT_TIMEOUT):
    """
    Initialise websocket client instance.
    - `api_key` is the API key issued to you
    - `access_token` is the token obtained after the login flow in
        exchange for the `request_token`.
    - `root` is the websocket API end point root.
    - `reconnect` is a boolean to enable WebSocket autreconnect in case of network failure/disconnection.
    - `reconnect_max_delay` in seconds is the maximum delay after which subsequent reconnection interval will become constant. Defaults to 60s and minimum acceptable value is 5s.
    - `reconnect_max_tries` is maximum number reconnection attempts. Defaults to 50 attempts and maximum up to 300 attempts.
    - `connect_timeout` in seconds is the maximum interval after which connection is considered as timeout. Defaults to 30s.
    """
    self.root = root or self.ROOT_URI
    # Set max reconnect tries
    if reconnect_max_tries > self._maximum_reconnect_max_tries:
        log.warning("`reconnect_max_tries` can not be more than {val}. Setting to highest possible value - {val} கிலோ.".format(
            val=self._maximum_reconnect_max_tries))
        self.reconnect_max_tries = self._maximum_reconnect_max_tries
    else:
        self.reconnect_max_tries = reconnect_max_tries
    # Set max reconnect delay
    if reconnect_max_delay < self._minimum_reconnect_max_delay:
        log.warning("`reconnect_max_delay` can not be less than {val}. Setting to lowest possible value - {val} கிலோ.".format(
            val=self._minimum_reconnect_max_delay))
        self.reconnect_max_delay = self._minimum_reconnect_max_delay
    else:
        self.reconnect_max_delay = reconnect_max_delay
    self.connect_timeout = connect_timeout
    self.socket_url = "{root}?api_key={api_key}"
        "&access_token={access_token}".format(
            root=self.root,
            api_key=api_key,
            access_token=access_token
        )
    # Debug enables logs
    self.debug = debug
    # Initialize default value for websocket object
    self.ws = None
    # Placeholders for callbacks.
    self.on_ticks = None
    self.on_open = None
    self.on_close = None
    self.on_error = None
    self.on_connect = None
    self.on_message = None
    self.on_reconnect = None
    self.on_noreconnect = None
    # Text message updates
    self.on_order_update = None
    # List of current subscribed tokens
    self.subscribed_tokens = {}

```

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

### connect

Source: https://kite.trade/docs/pykiteconnect/v4

Establishes a WebSocket connection. It supports threaded mode, disabling SSL verification, and proxy settings.

```APIDOC
## connect

### Description
Establishes a websocket connection. Supports threaded mode, disabling SSL verification, and proxy settings.

### Method
`connect`

### Parameters
- `threaded` (boolean) - Optional - Indicates if the websocket client should run in threaded mode.
- `disable_ssl_verification` (boolean) - Optional - Disables building the SSL context.
- `proxy` (dictionary) - Optional - A dictionary with keys `host` and `port` for proxy settings.
```

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

### mf_orders

Source: https://kite.trade/docs/pykiteconnect/v4

Get all mutual fund orders or individual order information.

```APIDOC
## mf_orders

### Description
Get all mutual fund orders or individual order information.

### Method
GET

### Endpoint
/mf.orders or /mf.order.info

### Parameters
#### Query Parameters
- **order_id** (string) - Optional - The ID of a specific mutual fund order.

### Response
#### Success Response (200)
- **orders** (list or object) - A list of mutual fund orders or details of a specific order.
```

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

### login_url

Source: https://kite.trade/docs/pykiteconnect/v4

Get the remote login URL for initiating the login flow.

```APIDOC
## login_url

### Description
Get the remote login URL to which a user should be redirected to initiate the login flow.

### Method
GET

### Endpoint
/api/login

### Parameters
None

### Response
#### Success Response (200)
- **login_url** (string) - The URL for initiating the login flow.
```

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

### mf_orders

Source: https://kite.trade/docs/pykiteconnect/v4

Get all mutual fund orders or individual order information.

```APIDOC
## mf_orders

### Description
Get all mutual fund orders or individual order information.

### Method Signature
```python
def mf_orders(self, order_id=None)
```

### Parameters
- **order_id** (string) - Optional - The ID of a specific mutual fund order to retrieve.
```

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

### Initialize PermissionException

Source: https://kite.trade/docs/pykiteconnect/v4/exceptions.m.html

Initializes the PermissionException with a message and an optional HTTP status code. Inherits from KiteException.

```python
def __init__(self, message, code=403):
    """Initialize the exception."""
    super(PermissionException, self).__init__(message, code)

```

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

### margins

Source: https://kite.trade/docs/pykiteconnect/v4

Get account balance and cash margin details for a particular segment.

```APIDOC
## margins

### Description
Get account balance and cash margin details for a particular segment.

### Method
GET

### Endpoint
/user.margins or /user.margins.segment

### Parameters
#### Query Parameters
- **segment** (string) - Optional - The trading segment (e.g., equity or commodity).

### Response
#### Success Response (200)
- **margins** (object) - Details about account balance and cash margins.
```

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

### Retrieve Portfolio Positions

Source: https://kite.trade/docs/pykiteconnect/v4

Fetches the current list of all open positions across different instruments.

```python
def positions(self):
        """Retrieve the list of positions."""
        return self._get("portfolio.positions")
```

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

### place_order

Source: https://kite.trade/docs/pykiteconnect/v4

Place an order for a tradable instrument.

```APIDOC
## place_order

### Description
Place an order.

### Method Signature
`place_order(self, variety, exchange, tradingsymbol, transaction_type, quantity, product, order_type, price=None, validity=None, validity_ttl=None, disclosed_quantity=None, trigger_price=None, iceberg_legs=None, iceberg_quantity=None, auction_number=None, tag=None, market_protection=None)`

### Parameters
- `variety` (string) - The variety of the order (e.g., REGULAR, AMO, ROBO, CO).
- `exchange` (string) - Name of the exchange.
- `tradingsymbol` (string) - Trading symbol of the instrument.
- `transaction_type` (string) - Type of transaction (BUY or SELL).
- `quantity` (integer) - Quantity to transact.
- `product` (string) - Product type (e.g., CNC, MIS, NRML, MTF).
- `order_type` (string) - Type of order (e.g., LIMIT, MARKET, SL, SLM).
- `price` (float, optional) - The price for LIMIT orders.
- `validity` (string, optional) - Order validity (e.g., DAY, IOC).
- `validity_ttl` (integer, optional) - Time To Live in minutes for validity.
- `disclosed_quantity` (integer, optional) - Disclosed quantity for Iceberg orders.
- `trigger_price` (float, optional) - Trigger price for SL or SLM orders.
- `iceberg_legs` (integer, optional) - Number of legs for an iceberg order.
- `iceberg_quantity` (integer, optional) - Quantity for an iceberg order.
- `auction_number` (string, optional) - Auction number for specific auction orders.
- `tag` (string, optional) - An optional tag for the order.
- `market_protection` (float) - Accepts `-1` for automatic market protection or a value greater than `0` up to `100` representing a percentage.
```

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

### Get Mutual Fund Holdings

Source: https://kite.trade/docs/pykiteconnect/v4

Retrieve a list of all mutual fund holdings.

```python
def mf_holdings(self):
    """Get list of mutual fund holdings."""
    return self._get("mf.holdings")
```

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

### Initialize TokenException

Source: https://kite.trade/docs/pykiteconnect/v4/exceptions.m.html

Initializes the TokenException with a message and an optional HTTP status code. Inherits from KiteException.

```python
def __init__(self, message, code=403):
    """Initialize the exception."""
    super(TokenException, self).__init__(message, code)

```

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

### Initialize OrderException

Source: https://kite.trade/docs/pykiteconnect/v4/exceptions.m.html

Initializes the OrderException with a message and an optional HTTP status code. Inherits from KiteException.

```python
def __init__(self, message, code=500):
    """Initialize the exception."""
    super(OrderException, self).__init__(message, code)

```
Tokens:
Raw