tessl/pypi-td-ameritrade-python-api

A python client library for the TD Ameritrade API.

Overview

Eval results

Files

Order Management

Name: tessl/pypi-td-ameritrade-python-api
Author: tessl

The order management system provides comprehensive classes for building and managing trade orders, from simple buy/sell orders to complex multi-leg options strategies. The system uses builder pattern classes to construct orders with proper validation and structure.

Core Imports

from td.orders import Order, OrderLeg
from td.enums import ORDER_TYPE, ORDER_SESSION, DURATION, ORDER_INSTRUCTIONS

Capabilities

Order Class

Main order builder class for constructing complete trading orders with all necessary parameters and legs.

class Order:
    def __init__(self) -> None: ...
    def order_price(self, price: float) -> 'Order': ...
    def order_type(self, order_type: str) -> 'Order': ...
    def order_session(self, session: str) -> 'Order': ...
    def order_duration(self, duration: str, cancel_time: str = None) -> 'Order': ...
    def stop_price(self, stop_price: float) -> 'Order': ...
    def stop_price_offset(self, stop_price_offset: float) -> 'Order': ...
    def stop_type(self, stop_type: str) -> 'Order': ...
    def stop_price_link_type(self, stop_price_link_type: str) -> 'Order': ...
    def stop_price_link_basis(self, stop_price_link_basis: str) -> 'Order': ...
    def complex_order_type(self, complex_order_strategy_type: str) -> 'Order': ...
    def order_strategy_type(self, order_strategy_type: str) -> 'Order': ...
    def add_order_leg(self, order_leg: 'OrderLeg') -> None: ...
    def delete_order_leg(self, key: str, index: int) -> None: ...
    def create_child_order_strategy(self) -> 'Order': ...
    def add_child_order_strategy(self, child_order_strategy: 'Order') -> None: ...
    def delete_child_order_strategy(self, key: str, index: int) -> None: ...

Methods:

order_price(): Sets the limit price for the order
order_type(): Sets order type (MARKET, LIMIT, STOP, STOP_LIMIT, etc.)
order_session(): Sets trading session (NORMAL, AM, PM, SEAMLESS)
order_duration(): Sets order duration (DAY, GOOD_TILL_CANCEL, FILL_OR_KILL)
stop_price(): Sets stop price for stop orders
stop_price_offset(): Sets stop price offset amount
stop_type(): Sets stop order type
stop_price_link_type(): Sets stop price link type
stop_price_link_basis(): Sets stop price link basis
complex_order_type(): Sets complex order strategy type
order_strategy_type(): Sets order strategy type (SINGLE, OCO, TRIGGER)
add_order_leg(): Adds an order leg to the order
delete_order_leg(): Removes an order leg by key and index
create_child_order_strategy(): Creates a child order strategy
add_child_order_strategy(): Adds a child order strategy
delete_child_order_strategy(): Removes a child order strategy

OrderLeg Class

Individual order leg builder for multi-leg orders and complex strategies.

class OrderLeg:
    def __init__(self) -> None: ...
    def order_leg_instruction(self, instruction: str) -> 'OrderLeg': ...
    def order_leg_asset(self, asset_type: str, symbol: str) -> 'OrderLeg': ...
    def order_leg_quantity(self, quantity: int) -> 'OrderLeg': ...
    def order_leg_price(self, price: float) -> 'OrderLeg': ...
    def order_leg_quantity_type(self, quantity_type: str) -> 'OrderLeg': ...
    def copy(self) -> 'OrderLeg': ...

Methods:

order_leg_instruction(): Sets order instruction (BUY, SELL, BUY_TO_OPEN, SELL_TO_CLOSE, etc.)
order_leg_asset(): Sets asset type and symbol (EQUITY, OPTION, etc.)
order_leg_quantity(): Sets quantity for the order leg
order_leg_price(): Sets price for the order leg
order_leg_quantity_type(): Sets quantity type (SHARES, DOLLARS, ALL_SHARES)
copy(): Returns a copy of the order leg

Usage Examples

Simple Stock Orders

from td.orders import Order, OrderLeg
from td.enums import ORDER_TYPE, ORDER_SESSION, DURATION, ORDER_INSTRUCTIONS

# Market order to buy 100 shares of AAPL
buy_order = Order()
buy_order.order_type(ORDER_TYPE.MARKET)
buy_order.order_session(ORDER_SESSION.NORMAL)
buy_order.order_duration(DURATION.DAY)

# Create order leg
buy_leg = OrderLeg()
buy_leg.order_leg_instruction(ORDER_INSTRUCTIONS.BUY)
buy_leg.order_leg_asset('EQUITY', 'AAPL')
buy_leg.order_leg_quantity(100)

# Add leg to order
buy_order.add_order_leg(buy_leg)

# Limit order to sell 50 shares of MSFT at $300
sell_order = Order()
sell_order.order_type(ORDER_TYPE.LIMIT)
sell_order.order_price(300.00)
sell_order.order_session(ORDER_SESSION.NORMAL)
sell_order.order_duration(DURATION.GOOD_TILL_CANCEL)

sell_leg = OrderLeg()
sell_leg.order_leg_instruction(ORDER_INSTRUCTIONS.SELL)
sell_leg.order_leg_asset('EQUITY', 'MSFT')
sell_leg.order_leg_quantity(50)

sell_order.add_order_leg(sell_leg)

Stop Loss Orders

# Stop loss order for TSLA at $200
stop_loss = Order()
stop_loss.order_type(ORDER_TYPE.STOP)
stop_loss.stop_price(200.00)
stop_loss.order_session(ORDER_SESSION.NORMAL)
stop_loss.order_duration(DURATION.GOOD_TILL_CANCEL)

stop_leg = OrderLeg()
stop_leg.order_leg_instruction(ORDER_INSTRUCTIONS.SELL)
stop_leg.order_leg_asset('EQUITY', 'TSLA')
stop_leg.order_leg_quantity(100)

stop_loss.add_order_leg(stop_leg)

# Stop limit order
stop_limit = Order()
stop_limit.order_type(ORDER_TYPE.STOP_LIMIT)
stop_limit.stop_price(195.00)
stop_limit.order_price(194.00)
stop_limit.order_session(ORDER_SESSION.NORMAL)
stop_limit.order_duration(DURATION.DAY)

stop_limit_leg = OrderLeg()
stop_limit_leg.order_leg_instruction(ORDER_INSTRUCTIONS.SELL)
stop_limit_leg.order_leg_asset('EQUITY', 'TSLA')
stop_limit_leg.order_leg_quantity(100)

stop_limit.add_order_leg(stop_limit_leg)

Options Orders

# Buy to open call option
call_order = Order()
call_order.order_type(ORDER_TYPE.LIMIT)
call_order.order_price(2.50)
call_order.order_session(ORDER_SESSION.NORMAL)
call_order.order_duration(DURATION.DAY)

call_leg = OrderLeg()
call_leg.order_leg_instruction(ORDER_INSTRUCTIONS.BUY_TO_OPEN)
call_leg.order_leg_asset('OPTION', 'AAPL_021724C150')
call_leg.order_leg_quantity(1)

call_order.add_order_leg(call_leg)

# Sell to close put option
put_order = Order()
put_order.order_type(ORDER_TYPE.LIMIT)
put_order.order_price(1.25)
put_order.order_session(ORDER_SESSION.NORMAL)
put_order.order_duration(DURATION.DAY)

put_leg = OrderLeg()
put_leg.order_leg_instruction(ORDER_INSTRUCTIONS.SELL_TO_CLOSE)
put_leg.order_leg_asset('OPTION', 'AAPL_021724P140')
put_leg.order_leg_quantity(2)

put_order.add_order_leg(put_leg)

Multi-Leg Options Strategies

from td.enums import COMPLEX_ORDER_STRATEGY_TYPE

# Covered call strategy
covered_call = Order()
covered_call.order_type(ORDER_TYPE.NET_DEBIT)
covered_call.complex_order_type(COMPLEX_ORDER_STRATEGY_TYPE.COVERED)
covered_call.order_session(ORDER_SESSION.NORMAL)
covered_call.order_duration(DURATION.DAY)

# Long stock leg
stock_leg = OrderLeg()
stock_leg.order_leg_instruction(ORDER_INSTRUCTIONS.BUY)
stock_leg.order_leg_asset('EQUITY', 'AAPL')
stock_leg.order_leg_quantity(100)

# Short call leg
call_leg = OrderLeg()
call_leg.order_leg_instruction(ORDER_INSTRUCTIONS.SELL_TO_OPEN)
call_leg.order_leg_asset('OPTION', 'AAPL_030724C160')
call_leg.order_leg_quantity(1)

covered_call.add_order_leg(stock_leg)
covered_call.add_order_leg(call_leg)

# Vertical spread
vertical = Order()
vertical.order_type(ORDER_TYPE.NET_DEBIT)
vertical.complex_order_type(COMPLEX_ORDER_STRATEGY_TYPE.VERTICAL)
vertical.order_price(1.50)
vertical.order_session(ORDER_SESSION.NORMAL)
vertical.order_duration(DURATION.DAY)

# Buy lower strike
buy_leg = OrderLeg()
buy_leg.order_leg_instruction(ORDER_INSTRUCTIONS.BUY_TO_OPEN)
buy_leg.order_leg_asset('OPTION', 'AAPL_030724C150')
buy_leg.order_leg_quantity(1)

# Sell higher strike
sell_leg = OrderLeg()
sell_leg.order_leg_instruction(ORDER_INSTRUCTIONS.SELL_TO_OPEN)
sell_leg.order_leg_asset('OPTION', 'AAPL_030724C155')
sell_leg.order_leg_quantity(1)

vertical.add_order_leg(buy_leg)
vertical.add_order_leg(sell_leg)

Conditional Orders (OCO)

# One-Cancels-Other order
oco_order = Order()
oco_order.order_strategy_type('OCO')
oco_order.order_session(ORDER_SESSION.NORMAL)

# Profit target child order
profit_target = Order()
profit_target.order_type(ORDER_TYPE.LIMIT)
profit_target.order_price(110.00)
profit_target.order_duration(DURATION.GOOD_TILL_CANCEL)

profit_leg = OrderLeg()
profit_leg.order_leg_instruction(ORDER_INSTRUCTIONS.SELL)
profit_leg.order_leg_asset('EQUITY', 'AAPL')
profit_leg.order_leg_quantity(100)
profit_target.add_order_leg(profit_leg)

# Stop loss child order
stop_loss = Order()
stop_loss.order_type(ORDER_TYPE.STOP)
stop_loss.stop_price(95.00)
stop_loss.order_duration(DURATION.GOOD_TILL_CANCEL)

stop_leg = OrderLeg()
stop_leg.order_leg_instruction(ORDER_INSTRUCTIONS.SELL)
stop_leg.order_leg_asset('EQUITY', 'AAPL')
stop_leg.order_leg_quantity(100)
stop_loss.add_order_leg(stop_leg)

# Add child strategies
oco_order.add_child_order_strategy(profit_target)
oco_order.add_child_order_strategy(stop_loss)

Working with Orders

# Copy an order leg for similar orders
original_leg = OrderLeg()
original_leg.order_leg_instruction(ORDER_INSTRUCTIONS.BUY)
original_leg.order_leg_asset('EQUITY', 'AAPL')
original_leg.order_leg_quantity(100)

# Create a copy for a different order
copied_leg = original_leg.copy()

# Modify the copy
copied_leg.order_leg_asset('EQUITY', 'MSFT')

# Remove order legs
order = Order()
order.add_order_leg(original_leg)
order.add_order_leg(copied_leg)

# Delete specific leg (key and index depend on internal structure)
order.delete_order_leg('orderLegCollection', 1)

# Delete child order strategies
order.delete_child_order_strategy('childOrderStrategies', 0)

Order Validation

Orders built with these classes are automatically structured for the TD Ameritrade API format. The builder pattern ensures required fields are set and provides validation through the enum values. Use the enums module for valid parameter values to avoid API errors.

Install with Tessl CLI

npx tessl i tessl/pypi-td-ameritrade-python-api

docs

tessl/pypi-td-ameritrade-python-api