schwab-py

https://schwab-py.readthedocs.io/en/latest
Admin
An unofficial Python API wrapper for Charles Schwab's trading platform, providing access to market...
Tokens:41,635
Snippets:493
Trust Score:8.3
Update:3 months ago
Show doc for...
Tokens:
Raw
### Set up virtual environment

Source: https://schwab-py.readthedocs.io/en/latest/contributing.html

Commands to install and activate a virtual environment for development.

```bash
pip install virtualenv
virtualenv -v virtualenv
source virtualenv/bin/activate
```

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

### Verify installation

Source: https://schwab-py.readthedocs.io/en/latest/getting-started.html

Checks if the package is correctly installed by attempting to import it in Python.

```python
import schwab

```

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

### Install development requirements

Source: https://schwab-py.readthedocs.io/en/latest/contributing.html

Install the project dependencies including development-specific packages.

```bash
pip install ".[dev]"
```

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

### Install schwab-py

Source: https://schwab-py.readthedocs.io/en/latest/getting-started.html

Installs the library using pip within an active virtual environment.

```bash
pip install schwab-py

```

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

### Install schwab-py

Source: https://schwab-py.readthedocs.io/en/latest/_sources/getting-started.rst.txt

Installs the schwab-py library from PyPi using pip. This command should be run after activating your virtual environment.

```shell
pip install schwab-py
```

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

### StreamClient.login

Source: https://schwab-py.readthedocs.io/en/latest/streaming.html

Performs the initial stream setup, including fetching streaming information, initializing the socket, and authenticating the connection.

```APIDOC
## async StreamClient.login(websocket_connect_args=None)

### Description
Performs initial stream setup by fetching streaming information, initializing the socket, and sending an authentication request.

### Parameters
- **websocket_connect_args** (dict) - Optional - Additional arguments to pass to the websocket connect call.
```

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

### Create and Activate Virtual Environment

Source: https://schwab-py.readthedocs.io/en/latest/_sources/getting-started.rst.txt

Installs virtualenv, creates a virtual environment named 'my-venv', and activates it. This is a prerequisite for installing schwab-py.

```shell
pip install virtualenv
virtualenv -v my-venv
source my-venv/bin/activate
```

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

### Verify schwab-py Installation

Source: https://schwab-py.readthedocs.io/en/latest/_sources/getting-started.rst.txt

Imports the schwab library to confirm that the installation was successful. This is the final step before proceeding to authentication.

```python
import schwab
```

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

### Generate Token via CLI

Source: https://schwab-py.readthedocs.io/en/latest/auth.html

Use the installed script to fetch and save a new authentication token to a file.

```bash
usage: schwab-generate-token.py [-h] --token_file TOKEN_FILE --api_key API_KEY --app_secret APP_SECRET --callback_url CALLBACK_URL [--browser BROWSER]

Fetch a new token and write it to a file

options:
  -h, --help            show this help message and exit

required arguments:
  --token_file TOKEN_FILE
                        Path to token file. Any existing file will be overwritten
  --api_key API_KEY
  --app_secret APP_SECRET
  --callback_url CALLBACK_URL
  --browser BROWSER     Manually specify a browser in which to start the login flow. See here for available options:
                        https://docs.python.org/3/library/webbrowser.html#webbrowser.register
```

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

### Receive Book Snapshots with StreamClient

Source: https://schwab-py.readthedocs.io/en/latest/_sources/streaming.rst.txt

Example demonstrating how to receive book snapshots for a given symbol using the StreamClient. Assumes prior authentication and token creation. Ensure you are running this during regular trading hours for visible results.

```python
from schwab.auth import easy_client
from schwab.client import Client
from schwab.streaming import StreamClient

import asyncio
import json

# Assumes you've already created a token. See the authentication page for more
# information.
client = easy_client(
        api_key='YOUR_API_KEY',
        app_secret='YOUR_APP_SECRET',
        callback_url='https://127.0.0.1',
        token_path='/path/to/token.json')
stream_client = StreamClient(client, account_id=1234567890)

async def read_stream():
    await stream_client.login()
 
    def print_message(message):
      print(json.dumps(message, indent=4))

    # Always add handlers before subscribing because many streams start sending 
    # data immediately after success, and messages with no handlers are dropped.
    stream_client.add_nasdaq_book_handler(print_message)
    await stream_client.nasdaq_book_subs(['GOOG'])

    while True:
        await stream_client.handle_message()

asyncio.run(read_stream())
```

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

### Place Equity Buy Limit Order

Source: https://schwab-py.readthedocs.io/en/latest/_sources/order-templates.rst.txt

Example of placing an equity buy limit order for GOOG, specifying quantity, price, duration, and session. Requires an authenticated client.

```python
from schwab.orders.equities import equity_buy_limit
from schwab.orders.common import Duration, Session

client = ... # See "Authentication and Client Creation"

client.place_order(
    1000,  # account_id
    equity_buy_limit('GOOG', 1, 1250.0)
        .set_duration(Duration.GOOD_TILL_CANCEL)
        .set_session(Session.SEAMLESS)
        .build())

```

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

### Simple Equity Limit Order Spec

Source: https://schwab-py.readthedocs.io/en/latest/_sources/order-builder.rst.txt

Example of a spec for a limit order to buy shares of an equity. This is the format returned by equity_buy_limit.

```JSON
{
    "session": "NORMAL",
    "duration": "DAY",
    "orderType": "LIMIT",
    "price": "190.90",
    "orderLegCollection": [
        {
            "instruction": "BUY",
            "instrument": {
                "assetType": "EQUITY",
                "symbol": "MSFT"
            },
            "quantity": 1
        }
    ],
    "orderStrategyType": "SINGLE"
}
```

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

### Example of Incorrect Composite Order Construction

Source: https://schwab-py.readthedocs.io/en/latest/_sources/order-templates.rst.txt

Demonstrates the incorrect way to construct composite orders by placing constituent orders first. This approach leads to execution failures. Always use OrderBuilder to defer execution.

```python
order_one = c.place_order(config.account_id, 
                    option_buy_to_open_limit(trade_symbol, contracts, safety_ask)
                    .set_duration(Duration.GOOD_TILL_CANCEL)
                    .set_session(Session.NORMAL)
                    .build())

order_two = c.place_order(config.account_id, 
                    option_sell_to_close_limit(trade_symbol, half, double)
                    .set_duration(Duration.GOOD_TILL_CANCEL)
                    .set_session(Session.NORMAL)
                    .build())

# THIS IS BAD, DO NOT DO THIS
exec_trade =  c.place_order(config.account_id, first_triggers_second(order_one, order_two))
```

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

### Raw Stream Data Example

Source: https://schwab-py.readthedocs.io/en/latest/streaming.html

Example of the raw JSON structure returned by the API, containing numerical keys that require decoding.

```json
{
  "service": "CHART_EQUITY",
  "timestamp": 1715908546054,
  "command": "SUBS",
  "content": [{
        "seq": 0,
        "key": "MSFT",
        "1": 779,
        "2": 421.65,
        "3": 421.79,
        "4": 421.65,
        "5": 421.755,
        "6": 26.0,
        "7": 1715903940000,
        "8": 19859
    }]
}
```

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

### Get schwab-py Version

Source: https://schwab-py.readthedocs.io/en/latest/_sources/help.rst.txt

You can check your installed schwab-py version by executing this command in a Python shell. Ensure you are using the latest version before seeking help.

```python
print(schwab.__version__)
```

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

### Raw Streaming Data with Numerical Labels

Source: https://schwab-py.readthedocs.io/en/latest/_sources/streaming.rst.txt

Example of a raw JSON response from a streaming service, featuring numerical labels for data fields. This format requires manual decoding or knowledge of the API's documentation.

```json
{
    "service": "CHART_EQUITY",
    "timestamp": 1715908546054,
    "command": "SUBS",
    "content": [{
          "seq": 0,
          "key": "MSFT",
          "1": 779,
          "2": 421.65,
          "3": 421.79,
          "4": 421.65,
          "5": 421.755,
          "6": 26.0,
          "7": 1715903940000,
          "8": 19859
      }]
  }
```

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

### Get Equity Order Book Exchange

Source: https://schwab-py.readthedocs.io/en/latest/_sources/streaming.rst.txt

Demonstrates how to determine the exchange for a given equity symbol using the search instruments endpoint. This is useful for identifying which Level Two order book stream to subscribe to.

```python
r = c.search_instruments(['GOOG'], projection=c.Instrument.Projection.FUNDAMENTAL)
assert r.status_code == httpx.codes.OK, r.raise_for_status()
print(r.json()['GOOG']['exchange'])  # Outputs NASDAQ
```

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

### Utils.__init__(client, account_hash)

Source: https://schwab-py.readthedocs.io/en/latest/util.html

Initializes a new Utils instance with a client and a specific account hash for order operations.

```APIDOC
## Utils.__init__(client, account_hash)

### Description
Creates a new Utils instance. This object assumes the user wants to work with a single account hash at a time.

### Parameters
- **client** (object) - Required - The schwab-py client instance.
- **account_hash** (string) - Required - The account hash to be used for operations.
```

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

### Build documentation

Source: https://schwab-py.readthedocs.io/en/latest/contributing.html

Generate project documentation using Sphinx.

```bash
sphinx-build docs/ docs-build
```

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

### Create and activate a virtual environment

Source: https://schwab-py.readthedocs.io/en/latest/getting-started.html

Sets up a new virtual environment named my-venv in the current directory.

```bash
pip install virtualenv
virtualenv -v my-venv
source my-venv/bin/activate

```

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

### Create a client with easy_client

Source: https://schwab-py.readthedocs.io/en/latest/auth.html

Use this method for a simplified authentication flow that automatically handles token loading or browser-based login. It is suitable for most desktop and notebook environments.

```python
from schwab.auth import easy_client

# Follow the instructions on the screen to authenticate your client.
c = easy_client(
        api_key='APIKEY',
        app_secret='APP_SECRET',
        callback_url='https://127.0.0.1',
        token_path='/tmp/token.json')

resp = c.get_price_history_every_day('AAPL')
assert resp.status_code == httpx.codes.OK
history = resp.json()
```

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

### Initialize and use a synchronous Schwab client

Source: https://schwab-py.readthedocs.io/en/latest/client.html

Uses the auth package to create a client and fetch price history. Ensure only one client instance is used per token file.

```python
from schwab.auth import client_from_manual_flow

# Follow the instructions on the screen to authenticate your client.
c = easy_client(
        api_key='APIKEY',
        app_secret='APP_SECRET',
        callback_url='https://127.0.0.1',
        token_path='/tmp/token.json')

resp = c.get_price_history_every_day('AAPL')
assert resp.status_code == httpx.codes.OK
history = resp.json()
```

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

### Receive Book Snapshots for Equities

Source: https://schwab-py.readthedocs.io/en/latest/streaming.html

Demonstrates the end-to-end workflow for initializing the stream client, logging in, adding a message handler, and subscribing to a symbol.

```python
from schwab.auth import easy_client
from schwab.client import Client
from schwab.streaming import StreamClient

import asyncio
import json

# Assumes you've already created a token. See the authentication page for more
# information.
client = easy_client(
        api_key='YOUR_API_KEY',
        app_secret='YOUR_APP_SECRET',
        callback_url='https://127.0.0.1',
        token_path='/path/to/token.json')
stream_client = StreamClient(client, account_id=1234567890)

async def read_stream():
    await stream_client.login()

    def print_message(message):
      print(json.dumps(message, indent=4))

    # Always add handlers before subscribing because many streams start sending
    # data immediately after success, and messages with no handlers are dropped.
    stream_client.add_nasdaq_book_handler(print_message)
    await stream_client.nasdaq_book_subs(['GOOG'])

    while True:
        await stream_client.handle_message()

asyncio.run(read_stream())
```

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

### Relabeled Stream Data Example

Source: https://schwab-py.readthedocs.io/en/latest/streaming.html

The same data structure after the API has automatically replaced numerical labels with descriptive strings.

```json
{
  "service": "CHART_EQUITY",
  "timestamp": 1715908546054,
  "command": "SUBS",
  "content": [{
        "seq": 0,
        "key": "MSFT",
        "SEQUENCE": 779,
        "OPEN_PRICE": 421.65,
        "HIGH_PRICE": 421.79,
        "LOW_PRICE": 421.65,
        "CLOSE_PRICE": 421.755,
        "VOLUME": 26.0,
        "CHART_TIME_MILLIS": 1715903940000,
        "CHART_DAY": 19859
    }]
}
```

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

### Define a Stream Message Handler

Source: https://schwab-py.readthedocs.io/en/latest/streaming.html

Handlers must accept a single argument representing the received stream message. This example prints the message content as formatted JSON.

```python
import json

def sample_handler(msg):
    print(json.dumps(msg, indent=4))
```

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

### Create Schwab Client with Easy Client

Source: https://schwab-py.readthedocs.io/en/latest/_sources/auth.rst.txt

Use this method to create a client that attempts to authenticate appropriately for your running context. It handles token loading, browser-based login flows, or manual flows based on the environment.

```python
from schwab.auth import easy_client

# Follow the instructions on the screen to authenticate your client.
c = easy_client(
        api_key='APIKEY',
        app_secret='APP_SECRET',
        callback_url='https://127.0.0.1',
        token_path='/tmp/token.json')

resp = c.get_price_history_every_day('AAPL')
assert resp.status_code == httpx.codes.OK
history = resp.json()
```

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

### Create and Use Async HTTP Client

Source: https://schwab-py.readthedocs.io/en/latest/_sources/client.rst.txt

Instantiates an asynchronous client for higher-performance API usage. This approach increases application complexity but allows for non-blocking operations. Requires API key, redirect URI, token path, and asyncio=True.

```python
from schwab.auth import client_from_manual_flow

async def main():
    c = easy_client(
            api_key='APIKEY',
            redirect_uri='https://localhost',
            token_path='/tmp/token.json',
            asyncio=True)

    resp = await c.get_price_history_every_day('AAPL')
    assert resp.status_code == httpx.codes.OK
    history = resp.json()

if __name__ == '__main__':
    import asyncio
    asyncio.run_until_complete(main())
```

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

### Complex Trigger OCO Order Spec

Source: https://schwab-py.readthedocs.io/en/latest/_sources/order-builder.rst.txt

Example of a spec for a standing order to enter a long position that triggers a one-cancels-other (OCO) order to exit the position. This demonstrates advanced order strategies.

```JSON
{
    "session": "NORMAL",
    "duration": "GOOD_TILL_CANCEL",
    "orderType": "LIMIT",
    "price": "1310.00",
    "orderLegCollection": [
        {
            "instruction": "BUY",
            "instrument": {
                "assetType": "EQUITY",
                "symbol": "GOOG"
            },
            "quantity": 1
        }
    ],
    "orderStrategyType": "TRIGGER",
    "childOrderStrategies": [
        {
            "orderStrategyType": "OCO",
            "childOrderStrategies": [
                {
                    "session": "NORMAL",
                    "duration": "GOOD_TILL_CANCEL",
                    "orderType": "LIMIT",
                    "price": "1400.00",
                    "orderLegCollection": [
                        {
                            "instruction": "SELL",
                            "instrument": {
                                "assetType": "EQUITY",
                                "symbol": "GOOG"
                            },
                            "quantity": 1
                        }
                    ]
                },
                {
                    "session": "NORMAL",
                    "duration": "GOOD_TILL_CANCEL",
                    "orderType": "STOP_LIMIT",
                    "stopPrice": "1250.00",
                    "orderLegCollection": [
                        {
                            "instruction": "SELL",
                            "instrument": {
                                "assetType": "EQUITY",
                                "symbol": "GOOG"
                            },
                            "quantity": 1
                        }
                    ]
                }
            ]
        }
    ]
}
```

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

### Initialize and use an asynchronous Schwab client

Source: https://schwab-py.readthedocs.io/en/latest/client.html

Enables high-performance API usage by setting the asyncio keyword to True in the client constructor.

```python
from schwab.auth import client_from_manual_flow

async def main():
    c = easy_client(
            api_key='APIKEY',
            redirect_uri='https://localhost',
            token_path='/tmp/token.json',
            asyncio=True)

    resp = await c.get_price_history_every_day('AAPL')
    assert resp.status_code == httpx.codes.OK
    history = resp.json()

if __name__ == '__main__':
    import asyncio
    asyncio.run_until_complete(main())
```

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

### easy_client(api_key, app_secret, callback_url, token_path)

Source: https://schwab-py.readthedocs.io/en/latest/auth.html

A helper method to create a client automatically based on the current environment, handling token loading or the login flow as needed.

```APIDOC
## easy_client(api_key, app_secret, callback_url, token_path)

### Description
Creates a client by automatically determining the environment. It loads an existing token if available or initiates the login flow.

### Parameters
- **api_key** (str) - Required - Your Schwab application's app key.
- **app_secret** (str) - Required - Application secret provided upon app approval.
- **callback_url** (str) - Required - Your Schwab application's callback URL.
- **token_path** (str) - Required - Path to which the token will be read or written.
```

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

### Run project tests

Source: https://schwab-py.readthedocs.io/en/latest/contributing.html

Execute the test suite to verify the environment and code changes.

```bash
make test
```

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

### Initialize Schwab Client with Webdriver

Source: https://schwab-py.readthedocs.io/en/latest/_sources/client.rst.txt

Initializes the Schwab client using easy_client, which requires authentication details and a webdriver function for certain operations. The webdriver is registered to quit on exit.

```python
import atexit
import httpx
from selenium import webdriver

from schwab.auth import easy_client
from schwab.orders.equities import equity_buy_market

def make_webdriver():
    driver = webdriver.Firefox()
    atexit.register(lambda: driver.quit())
    return driver

c = easy_client(
        token_path='/path/to/token.json',
        api_key='api-key',
        app_secret='app-secret',
        callback_url='https://callback.com',
        webdriver_func=make_webdriver)

resp = c.get_account_numbers()
assert resp.status_code == httpx.codes.OK

# The response has the following structure. If you have multiple linked
# accounts, you'll need to inspect this object to find the hash you want:
# [
#    {
#        "accountNumber": "123456789",
#        "hashValue":"123ABCXYZ"
#    }
#]
account_hash = resp.json()[0]['hashValue']

c.place_order(account_hash, equity_buy_market('AAPL', 1))
```

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

### Create and Use HTTP Client

Source: https://schwab-py.readthedocs.io/en/latest/_sources/client.rst.txt

Instantiates a client for synchronous API calls. Ensure only one Client object is used per token file to avoid OAuth2 session issues. Requires API key, app secret, callback URL, and token path.

```python
from schwab.auth import client_from_manual_flow

# Follow the instructions on the screen to authenticate your client.
c = easy_client(
        api_key='APIKEY',
        app_secret='APP_SECRET',
        callback_url='https://127.0.0.1',
        token_path='/tmp/token.json')

resp = c.get_price_history_every_day('AAPL')
assert resp.status_code == httpx.codes.OK
history = resp.json()
```

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

### schwab.auth.client_from_manual_flow

Source: https://schwab-py.readthedocs.io/en/latest/auth.html

Walks the user through performing an OAuth login flow by manually copy-pasting URLs and returns a client wrapped around the resulting token.

```APIDOC
## schwab.auth.client_from_manual_flow

### Description
Walks the user through performing an OAuth login flow by manually copy-pasting URLs, and returns a client wrapped around the resulting token. The client will be configured to refresh the token as necessary, writing each updated version to `token_path`.

### Parameters
- **api_key** (str) - Required - Your Schwab application’s app key.
- **app_secret** (str) - Required - Application secret provided upon app approval.
- **callback_url** (str) - Required - Your Schwab application’s callback URL.
- **token_path** (str) - Required - Path to which the new token will be written.
- **asyncio** (bool) - Optional - If set to True, enables async support. Defaults to False.
- **token_write_func** (callable) - Optional - Function to handle token writing.
- **enforce_enums** (bool) - Optional - Set to False to disable enum checks. Defaults to True.
```

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

### schwab.auth.client_from_access_functions

Source: https://schwab-py.readthedocs.io/en/latest/auth.html

Initializes a session using custom token read and write functions, suitable for environments without a standard writable filesystem.

```APIDOC
## schwab.auth.client_from_access_functions(api_key, app_secret, token_read_func, token_write_func, asyncio=False, enforce_enums=True)

### Description
Returns a session from an existing token file using custom accessor methods to read and write the token. This is an advanced method intended for serverless environments like AWS Lambda where tokens must be persisted in non-filesystem locations.

### Parameters
- **api_key** (string) - Required - Your Schwab application’s app key.
- **app_secret** (string) - Required - Application secret provided upon app approval.
- **token_read_func** (callable) - Required - Function that takes no arguments and returns a token object.
- **token_write_func** (callable) - Required - Function that writes the token on update. Called whenever the token is updated.
- **asyncio** (boolean) - Optional - If set to True, enables async support. Defaults to False.
- **enforce_enums** (boolean) - Optional - Set to False to disable enum checks on client methods. Defaults to True.
```

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

### Generate Schwab Token using Command Line Script

Source: https://schwab-py.readthedocs.io/en/latest/_sources/auth.rst.txt

This script is used to fetch a new token and write it to a specified file. It's useful for generating tokens on one machine and using them on another. Ensure pip's executable locations are in your $PATH.

```bash
usage: schwab-generate-token.py [-h] --token_file TOKEN_FILE --api_key API_KEY --app_secret APP_SECRET --callback_url CALLBACK_URL [--browser BROWSER]

Fetch a new token and write it to a file

options:
  -h, --help            show this help message and exit

required arguments:
  --token_file TOKEN_FILE
                        Path to token file. Any existing file will be overwritten
  --api_key API_KEY
  --app_secret APP_SECRET
  --callback_url CALLBACK_URL
  --browser BROWSER     Manually specify a browser in which to start the login flow. See here for available options:
                      https://docs.python.org/3/library/webbrowser.html#webbrowser.register
```

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

### Advanced Token Fetching with Client Functions

Source: https://schwab-py.readthedocs.io/en/latest/_sources/auth.rst.txt

Use this advanced method for highly specialized scenarios, such as serverless deployments, when the default token fetchers are insufficient. It offers the most flexible facility for fetching tokens.

```python
from schwab import auth

client = auth.client_from_access_functions(
    access_token_function=get_access_token,
    refresh_token_function=get_refresh_token,
    client_id_function=get_client_id,
    client_secret_function=get_client_secret,
    redirect_uri_function=get_redirect_uri,
)
```

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

### Create Complex Orders with Templates

Source: https://schwab-py.readthedocs.io/en/latest/order-builder.html

Uses helper functions to construct nested order strategies like one-triggers-other and one-cancels-other.

```python
from schwab.orders.common import OrderType
from schwab.orders.generic import OrderBuilder

one_triggers_other(
    equity_buy_limit('GOOG', 1, 1310),
    one_cancels_other(
        equity_sell_limit('GOOG', 1, 1400),
        equity_sell_limit('GOOG', 1, 1240)
            .set_order_type(OrderType.STOP_LIMIT)
            .clear_price()
            .set_stop_price(1250)
    ))
```

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

### schwab.auth.easy_client

Source: https://schwab-py.readthedocs.io/en/latest/auth.html

A convenient wrapper that loads a token from a file if it exists, or initiates a login flow to fetch a new one.

```APIDOC
## schwab.auth.easy_client

### Description
Convenient wrapper around `client_from_login_flow()` and `client_from_token_file()`. If `token_path` exists, loads the token from it; otherwise, opens a login flow to fetch a new token.

### Parameters
- **api_key** (str) - Required - Your Schwab application’s app key.
- **app_secret** (str) - Required - Application secret provided upon app approval.
- **callback_url** (str) - Required - Your Schwab application’s callback URL.
- **token_path** (str) - Required - Path to which the new token will be written.
- **asyncio** (bool) - Optional - If set to True, enables async support. Defaults to False.
- **enforce_enums** (bool) - Optional - Set to False to disable enum checks. Defaults to True.
- **max_token_age** (float) - Optional - If the token is older than this age (in seconds), delete and recreate it. Defaults to 561600.0.
- **callback_timeout** (float) - Optional - Timeout for the callback. Defaults to 300.0.
- **interactive** (bool) - Optional - Whether to run interactively. Defaults to True.
- **requested_browser** (str) - Optional - Browser to use for the login flow.
```

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

### OrderBuilder Stop Order Configuration Methods

Source: https://schwab-py.readthedocs.io/en/latest/order-builder.html

Methods for configuring stop prices, link bases, link types, and activation prices for stop orders.

```APIDOC
## OrderBuilder.set_stop_price(stop_price)
Sets the stop price. Accepts float or str.

## OrderBuilder.copy_stop_price(stop_price)
Directly sets the stop price, bypassing validation and truncation logic.

## OrderBuilder.clear_stop_price()
Clears the stop price.

## OrderBuilder.set_stop_price_link_basis(stop_price_link_basis)
Sets the stop price link basis.

## OrderBuilder.clear_stop_price_link_basis()
Clears the stop price link basis.

## OrderBuilder.set_stop_price_link_type(stop_price_link_type)
Sets the stop price link type.

## OrderBuilder.clear_stop_price_link_type()
Clears the stop price link type.

## OrderBuilder.set_stop_price_offset(stop_price_offset)
Sets the stop price offset.

## OrderBuilder.clear_stop_price_offset()
Clears the stop price offset.

## OrderBuilder.set_stop_type(stop_type)
Sets the stop type.

## OrderBuilder.clear_stop_type()
Clears the stop type.

## OrderBuilder.set_price_link_basis(price_link_basis)
Sets the price link basis.

## OrderBuilder.clear_price_link_basis()
Clears the price link basis.

## OrderBuilder.set_price_link_type(price_link_type)
Sets the price link type.

## OrderBuilder.clear_price_link_type()
Clears the price link basis.

## OrderBuilder.set_activation_price(activation_price)
Sets the activation price.

## OrderBuilder.clear_activation_price()
Clears the activation price.
```

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

### schwab.auth.client_from_login_flow

Source: https://schwab-py.readthedocs.io/en/latest/auth.html

Performs a full OAuth webapp login flow to create a client, with support for token refreshing and various configuration options.

```APIDOC
## schwab.auth.client_from_login_flow

### Description
Opens a web browser to perform an OAuth webapp login flow and creates a client wrapped around the resulting token. The client is configured to refresh the token as necessary.

### Parameters
- **api_key** (str) - Required - Your Schwab application's app key.
- **app_secret** (str) - Required - Application secret provided upon app approval.
- **callback_url** (str) - Required - Your Schwab application's callback URL.
- **token_path** (str) - Required - Path to which the new token will be written.
- **asyncio** (bool) - Optional - Enable async support. Defaults to False.
- **enforce_enums** (bool) - Optional - Disable enum checks on client methods. Defaults to False.
- **token_write_func** (callable) - Optional - Function called when the token is updated.
- **callback_timeout** (float) - Optional - Seconds to wait for callback. Defaults to 300.0.
- **interactive** (bool) - Optional - Require user input before starting browser. Defaults to True.
- **requested_browser** (str) - Optional - Name of the browser to attempt to open.
```

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

### Client.place_order

Source: https://schwab-py.readthedocs.io/en/latest/client.html

Places a new order for a specified account.

```APIDOC
## Client.place_order(account_hash, order)

### Description
Submits a new order to the Schwab API for the specified account.

### Parameters
- **account_hash** (string) - Required - The account hash to place the order in.
- **order** (Order) - Required - The order object constructed via the OrderBuilder.
```

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

### Client.get_account(account_hash, fields=None)

Source: https://schwab-py.readthedocs.io/en/latest/client.html

Retrieves account balances, positions, and orders for a specific account hash.

```APIDOC
## Client.get_account(account_hash, fields=None)

### Description
Retrieves account balances, positions, and orders for a given account hash.

### Parameters
- **account_hash** (str) - Required - The account hash to retrieve information for.
- **fields** (list) - Optional - Additional fields to include from `Account.Fields`.
```

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

### schwab.auth.client_from_token_file

Source: https://schwab-py.readthedocs.io/en/latest/auth.html

Returns a session from an existing token file, performing auth refresh as needed.

```APIDOC
## schwab.auth.client_from_token_file

### Description
Returns a session from an existing token file. The session will perform an auth refresh as needed and update the token on disk whenever appropriate.

### Parameters
- **token_path** (str) - Required - Path to an existing token.
- **api_key** (str) - Required - Your Schwab application’s app key.
- **app_secret** (str) - Required - Application secret provided upon app approval.
- **asyncio** (bool) - Optional - If set to True, enables async support. Defaults to False.
- **enforce_enums** (bool) - Optional - Set to False to disable enum checks. Defaults to True.
```

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

### StreamClient.add_nasdaq_book_handler

Source: https://schwab-py.readthedocs.io/en/latest/streaming.html

Register a function to handle level two NASDAQ book data.

```APIDOC
## StreamClient.add_nasdaq_book_handler(handler)

### Description
Register a function to handle level two NASDAQ book data as it is updated.
```

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

### OrderBuilder Session and Duration Methods

Source: https://schwab-py.readthedocs.io/en/latest/order-builder.html

Methods to configure the market session and the duration for which an order remains active.

```APIDOC
## OrderBuilder.set_duration(duration)

### Description
Sets the order duration. See the Duration class for valid options (e.g., DAY, GOOD_TILL_CANCEL, FILL_OR_KILL).

## OrderBuilder.clear_duration()

### Description
Clears the currently set order duration.

## OrderBuilder.set_session(session)

### Description
Sets the market session for the order. See the Session class for valid options (e.g., NORMAL, AM, PM, SEAMLESS).

## OrderBuilder.clear_session()

### Description
Clears the currently set order session.
```

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

### StreamClient.options_book_add

Source: https://schwab-py.readthedocs.io/en/latest/streaming.html

Add to the level two order book for options.

```APIDOC
## async StreamClient.options_book_add(symbols)

### Description
Add to the level two order book for options.

### Parameters
- **symbols** (list) - Required - Option symbols to add to the subscription.
```

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

### Build Option Symbol

Source: https://schwab-py.readthedocs.io/en/latest/_sources/order-templates.rst.txt

Constructs a syntactically correct option symbol using the OptionSymbol helper. This requires the underlying ticker, expiration date, option type (put/call), and strike price. The symbol is then built using the .build() method.

```python
from schwab.orders.options import OptionSymbol
import datetime

symbol = OptionSymbol(
    'TSLA', datetime.date(year=2020, month=11, day=20), 'P', '1360').build()

```

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

### Client.get_instruments

Source: https://schwab-py.readthedocs.io/en/latest/_sources/client.rst.txt

Searches for financial instruments based on various criteria.

```APIDOC
## Client.get_instruments

### Description
Searches for financial instruments based on criteria such as symbol, exchange, or asset type.

### Method
`get_instruments`

### Parameters
* **query** (dict) - Required - A dictionary containing search criteria. Refer to the official API documentation for available query parameters.
```

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

### Client.place_order

Source: https://schwab-py.readthedocs.io/en/latest/_sources/client.rst.txt

Places a new order for financial instruments. This method is used for all order types.

```APIDOC
## Client.place_order

### Description
Creates and places a new order. This method is versatile and used for various order types, including equities and options. The precise order type is defined by a complex order specification.

### Method
`place_order`

### Parameters
#### Path Parameters
- **account_hash** (string) - Required - The hash value of the account where the order will be placed.

#### Request Body
- **order_spec** (dict) - Required - A complex object defining the order details. Refer to the Schwab API documentation for specific order schemas and examples.
```

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

### Enable Root Logger

Source: https://schwab-py.readthedocs.io/en/latest/help.html

Configures the root logger to output diagnostic messages to the console.

```python
import logging
logging.getLogger('').addHandler(logging.StreamHandler())
```

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

### Place Order

Source: https://schwab-py.readthedocs.io/en/latest/_sources/client.rst.txt

Places an order for a financial instrument. This method is a helper that scratches the surface of what's possible with order creation.

```APIDOC
## place_order

### Description
Places an order for a financial instrument. This method provides a utility for creating various order types.

### Method
Not specified (likely a client library method call)

### Endpoint
Not applicable (client library method)

### Parameters
This method likely accepts parameters defining the order details, such as symbol, quantity, order type, and price. Specific parameters are not detailed in the source.

### Request Example
Not specified in the source.

### Response
This method returns an order ID, which may need to be extracted using a helper function. The exact response format is not detailed.

#### Success Response
Order ID (type not specified)

#### Response Example
Not specified in the source.
```

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

### Client.get_accounts

Source: https://schwab-py.readthedocs.io/en/latest/_sources/client.rst.txt

Retrieves a summary of all accounts linked to the client.

```APIDOC
## Client.get_accounts

### Description
Retrieves a summary of all accounts associated with the client.

### Method
`get_accounts`
```

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

### Client.get_user_preferences

Source: https://schwab-py.readthedocs.io/en/latest/client.html

Retrieves preferences for the logged-in account.

```APIDOC
## Client.get_user_preferences()

### Description
Retrieves preferences for the logged-in account, including all linked accounts.
```

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

### Option Sell to Open Limit

Source: https://schwab-py.readthedocs.io/en/latest/_sources/order-templates.rst.txt

Template for creating a limit order to sell an option to open a position.

```APIDOC
## schwab.orders.options.option_sell_to_open_limit

### Description
Creates a limit order to sell an option to open a position.

### Method
Not specified (assumed to be a function call within the SDK)

### Parameters
(Parameters not explicitly detailed in the source, but would typically include trade symbol, contract details, and limit price)

### Request Example
(Example not provided in source)

### Response
(Response details not provided in source)
```

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

### StreamClient.add_options_book_handler

Source: https://schwab-py.readthedocs.io/en/latest/streaming.html

Register a function to handle level two options book data.

```APIDOC
## StreamClient.add_options_book_handler(handler)

### Description
Register a function to handle level two options book data as it is updated.
```

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

### Sample Message Handler

Source: https://schwab-py.readthedocs.io/en/latest/_sources/streaming.rst.txt

A basic Python function to process incoming stream messages. It expects a single argument, which is the message dictionary, and prints it to the console after JSON formatting.

```python
import json

def sample_handler(msg):
    print(json.dumps(msg, indent=4))
```

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

### OrderBuilder Quantity Methods

Source: https://schwab-py.readthedocs.io/en/latest/order-builder.html

Methods for managing the order-level quantity configuration.

```APIDOC
## OrderBuilder.set_quantity(quantity)

### Description
Sets the order-level quantity. Note that this field's exact semantics are currently under investigation and may differ from order leg quantities.

### Parameters
- **quantity** (unknown) - Required - The quantity value to set.

## OrderBuilder.clear_quantity()

### Description
Clears the order-level quantity. This does not affect quantities defined in order legs.
```

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

### Option Buy to Close Limit

Source: https://schwab-py.readthedocs.io/en/latest/_sources/order-templates.rst.txt

Template for creating a limit order to buy an option to close a position.

```APIDOC
## schwab.orders.options.option_buy_to_close_limit

### Description
Creates a limit order to buy an option to close a position.

### Method
Not specified (assumed to be a function call within the SDK)

### Parameters
(Parameters not explicitly detailed in the source, but would typically include trade symbol, contract details, and limit price)

### Request Example
(Example not provided in source)

### Response
(Response details not provided in source)
```

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

### StreamClient.options_book_subs

Source: https://schwab-py.readthedocs.io/en/latest/streaming.html

Subscribe to the level two order book for options.

```APIDOC
## async StreamClient.options_book_subs(symbols)

### Description
Subscribe to the level two order book for options.

### Parameters
- **symbols** (list) - Required - Option symbols to subscribe to.
```

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

### Generate Order Code from UI

Source: https://schwab-py.readthedocs.io/en/latest/order-builder.html

Executes the codegen script to produce programmatic code for the most recently placed order.

```bash
# Notice we don't prefix this with "python" because this is a script that was
# installed by pip when you installed tda-api
schwab-order-codegen.py --token_file <your token file path> --api_key <your
API key>
```

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

### Complex One-Triggers-Other Order with OCO

Source: https://schwab-py.readthedocs.io/en/latest/_sources/order-builder.rst.txt

Demonstrates building a complex order strategy involving a limit order that triggers an 'one-cancels-other' (OCO) order upon execution. This is useful for advanced trading scenarios where multiple outcomes are considered.

```python
from schwab.orders.common import OrderType
from schwab.orders.generic import OrderBuilder

one_triggers_other(
    equity_buy_limit('GOOG', 1, 1310),
    one_cancels_other(
        equity_sell_limit('GOOG', 1, 1400),
        equity_sell_limit('GOOG', 1, 1240)
            .set_order_type(OrderType.STOP_LIMIT)
            .clear_price()
            .set_stop_price(1250)
    ))

```

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

### Client.get_account

Source: https://schwab-py.readthedocs.io/en/latest/_sources/client.rst.txt

Retrieves detailed information for a specific account.

```APIDOC
## Client.get_account

### Description
Fetches detailed information for a specified account, including balances and positions.

### Method
`get_account`

### Parameters
#### Query Parameters
- **account_hash** (string) - Required - The hash value of the account to retrieve information for.
```

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

### Client.get_accounts(fields=None)

Source: https://schwab-py.readthedocs.io/en/latest/client.html

Retrieves account balances, positions, and orders for all linked accounts.

```APIDOC
## Client.get_accounts(fields=None)

### Description
Retrieves account balances, positions, and orders for all linked accounts. Note that this method does not return account hashes.

### Parameters
- **fields** (list) - Optional - Additional fields to include from `Account.Fields`.
```

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

### Fetch account hash and place an order

Source: https://schwab-py.readthedocs.io/en/latest/client.html

Retrieves account numbers to obtain the required hash value for executing trades. Requires a valid token path and API credentials.

```python
import atexit
import httpx
from selenium import webdriver

from schwab.auth import easy_client
from schwab.orders.equities import equity_buy_market

def make_webdriver():
    driver = webdriver.Firefox()
    atexit.register(lambda: driver.quit())
    return driver

c = easy_client(
        token_path='/path/to/token.json',
        api_key='api-key',
        app_secret='app-secret',
        callback_url='https://callback.com',
        webdriver_func=make_webdriver)

resp = c.get_account_numbers()
assert resp.status_code == httpx.codes.OK

# The response has the following structure. If you have multiple linked
# accounts, you'll need to inspect this object to find the hash you want:
# [
#    {
#        "accountNumber": "123456789",
#        "hashValue":"123ABCXYZ"
#    }
#]
account_hash = resp.json()[0]['hashValue']

c.place_order(account_hash, equity_buy_market('AAPL', 1))
```

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

### Price

Source: https://schwab-py.readthedocs.io/en/latest/_sources/order-builder.rst.txt

Methods for setting, copying, and clearing the price for an order.

```APIDOC
## Price

### Description
Methods for setting, copying, and clearing the price for an order. The price is the amount you'd like to pay for each unit of the position you're taking. Note that the Schwab API expects price as a string, and `schwab-py` handles conversion with truncation logic.

### Methods
- `set_price(price: float | str)`
- `copy_price(order_builder: OrderBuilder)`
- `clear_price()`
```

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

### User Preferences

Source: https://schwab-py.readthedocs.io/en/latest/_sources/client.rst.txt

Retrieves user preferences.

```APIDOC
## User Preferences

### Description
Retrieves user preferences for the authenticated user.

### Method
**get_user_preferences**

### Endpoint
Not applicable (client library method)

### Parameters
None specified.

### Response
Returns user preference details. Specific fields are not detailed in the source.
```

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

### Client.get_price_history_every_five_minutes

Source: https://schwab-py.readthedocs.io/en/latest/_sources/client.rst.txt

Fetches historical price data for equities and ETFs at five-minute intervals.

```APIDOC
## Client.get_price_history_every_five_minutes

### Description
Retrieves historical price data for equities and ETFs with five-minute intervals. Can be called with or without date bounds.

### Method
`get_price_history_every_five_minutes`

### Parameters
#### Query Parameters
- **start_datetime** (datetime) - Optional - The start of the date range.
- **end_datetime** (datetime) - Optional - The end of the date range.
```

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

### Option Sell to Open Market

Source: https://schwab-py.readthedocs.io/en/latest/_sources/order-templates.rst.txt

Template for creating a market order to sell an option to open a position.

```APIDOC
## schwab.orders.options.option_sell_to_open_market

### Description
Creates a market order to sell an option to open a position.

### Method
Not specified (assumed to be a function call within the SDK)

### Parameters
(Parameters not explicitly detailed in the source, but would typically include trade symbol and contract details)

### Request Example
(Example not provided in source)

### Response
(Response details not provided in source)
```

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

### StreamClient.add_screener_equity_handler

Source: https://schwab-py.readthedocs.io/en/latest/streaming.html

Register a callback handler for equity screener data.

```APIDOC
## StreamClient.add_screener_equity_handler(handler)

### Description
Register a function to handle Screener Equity data as it is updated.

### Parameters
- **handler** (function) - Required - The function to handle incoming data.
```

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

### First Triggers Second

Source: https://schwab-py.readthedocs.io/en/latest/_sources/order-templates.rst.txt

Utility method to create a 'first triggers second' order strategy.

```APIDOC
## schwab.orders.common.first_triggers_second

### Description
Creates a composite order where the execution of the first order triggers the execution of the second order. Expects OrderBuilder objects as input.

### Method
Not specified (assumed to be a function call within the SDK)

### Parameters
- **order_one** (OrderBuilder) - Required - The first order that triggers the second.
- **order_two** (OrderBuilder) - Required - The second order that is triggered by the first.

### Request Example
(Example not provided in source, but the text provides a conceptual example of incorrect usage.)

### Response
(Response details not provided in source)
```

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

### Session and Duration

Source: https://schwab-py.readthedocs.io/en/latest/_sources/order-builder.rst.txt

Methods for setting and clearing the session and duration for an order.

```APIDOC
## Session and Duration

### Description
Methods for setting and clearing the session and duration for an order. These control when the order will be placed and how long it will remain active.

### Methods
- `set_duration(duration: Duration)`
- `clear_duration()`
- `set_session(session: Session)`
- `clear_session()`
```

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

### Client.get_price_history_every_day

Source: https://schwab-py.readthedocs.io/en/latest/_sources/client.rst.txt

Fetches historical price data for equities and ETFs on a daily basis.

```APIDOC
## Client.get_price_history_every_day

### Description
Retrieves historical price data for equities and ETFs on a daily basis. Can be called with or without date bounds.

### Method
`get_price_history_every_day`

### Parameters
#### Query Parameters
- **start_datetime** (datetime) - Optional - The start of the date range.
- **end_datetime** (datetime) - Optional - The end of the date range.
```

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

### Extracting an Order ID

Source: https://schwab-py.readthedocs.io/en/latest/util.html

Demonstrates how to retrieve an order ID from a successful place_order response using the Utils class.

```python
# Assume client and order already exist and are valid
account_id = ...  # Fetched from account_information
r = client.place_order(account_hash, order)
assert r.status_code == httpx.codes.OK, r.raise_for_status()
order_id = Utils(client, account_hash).extract_order_id(r)
assert order_id is not None
```

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

### Option Sell to Close Limit

Source: https://schwab-py.readthedocs.io/en/latest/_sources/order-templates.rst.txt

Template for creating a limit order to sell an option to close a position.

```APIDOC
## schwab.orders.options.option_sell_to_close_limit

### Description
Creates a limit order to sell an option to close a position.

### Method
Not specified (assumed to be a function call within the SDK)

### Parameters
(Parameters not explicitly detailed in the source, but would typically include trade symbol, contract details, and limit price)

### Request Example
(Example not provided in source)

### Response
(Response details not provided in source)
```

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

### OptionSymbol

Source: https://schwab-py.readthedocs.io/en/latest/order-templates.html

Constructs an option symbol from its constituent parts for use in order building.

```APIDOC
## class schwab.orders.options.OptionSymbol(underlying_symbol, expiration_date, contract_type, strike_price_as_string)

### Description
Constructs an option symbol from its constituent parts. Note that while parts are validated, the resulting symbol may not represent a traded option.

### Parameters
- **underlying_symbol** (string) - Required - Symbol of the underlying.
- **expiration_date** (datetime.date/datetime.datetime/string) - Required - Expiration date in [YYMMDD] format if string.
- **contract_type** (string) - Required - 'P'/'PUT' for put or 'C'/'CALL' for call.
- **strike_price_as_string** (string) - Required - Strike price as a decimal string.

### Methods
- **build()** - Returns the formatted option symbol string.
```

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

### Special Instructions

Source: https://schwab-py.readthedocs.io/en/latest/_sources/order-builder.rst.txt

Method for setting special instructions for an order.

```APIDOC
## Special Instructions

### Description
Method for setting special instructions for an order, which handle some edge cases.

### Methods
- `set_special_instruction(special_instruction: SpecialInstruction)`
```

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

### Client.get_price_history_every_fifteen_minutes

Source: https://schwab-py.readthedocs.io/en/latest/_sources/client.rst.txt

Fetches historical price data for equities and ETFs at fifteen-minute intervals.

```APIDOC
## Client.get_price_history_every_fifteen_minutes

### Description
Retrieves historical price data for equities and ETFs with fifteen-minute intervals. Can be called with or without date bounds.

### Method
`get_price_history_every_fifteen_minutes`

### Parameters
#### Query Parameters
- **start_datetime** (datetime) - Optional - The start of the date range.
- **end_datetime** (datetime) - Optional - The end of the date range.
```

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

### StreamClient.add_level_one_forex_handler

Source: https://schwab-py.readthedocs.io/en/latest/streaming.html

Register a callback function to handle incoming forex quote messages.

```APIDOC
## StreamClient.add_level_one_forex_handler(handler)

### Description
Register a function to handle level one forex quotes as they are received.

### Parameters
- **handler** (Callable) - Required - The function to process incoming quote data.
```

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

### Account Activity Subscription

Source: https://schwab-py.readthedocs.io/en/latest/_sources/streaming.rst.txt

Methods for subscribing to and unsubscribing from the account activity stream, and for adding handlers to process incoming data.

```APIDOC
## Account Activity Subscription Methods

### Description
These methods allow you to subscribe to, unsubscribe from, and manage handlers for the account activity data stream. This stream provides updates related to account activity.

### Methods
- `account_activity_sub()`: Subscribe to the account activity stream.
- `account_activity_unsubs()`: Unsubscribe from the account activity stream.
- `add_account_activity_handler(handler)`: Add a handler function to process account activity data.
```
Tokens:
Raw