Tradier API Python Tutorial

Attention all programmers and algo traders! Are you ready to take your software building to the next level with Python and the Tradier API? Do you feel overwhelmed with the search for a comprehensive and straightforward guide on how to use the Tradier API in Python? Look no further, this article is designed specifically for you.

With a step-by-step approach, this article will guide you through the entire process of calling Tradier API endpoints in Python. From creating a Tradier account to obtaining your API tokens, we will provide you with an easy-to-follow tutorial to connect with the Tradier API and execute your first endpoint call.

Whether you are a beginner or an experienced programmer, this article provides you with all the necessary information to build sophisticated financial software using the Tradier API in Python. So, don’t wait any longer, start exploring the potential of the Tradier API today!

What Is Tradier?

Tradier is a cloud-based securities brokerage platform offering tools and services for individual investors and traders to trade in stocks, options, and other financial instruments. With real-time market data and cutting-edge trading technologies, it offers its clients a comprehensive online trading solution.

Dan Raju founded Tradier in 2012, and its headquarters are located in Charlotte, North Carolina, United States.

What Is the Tradier API?

The Tradier API is a RESTful API that gives developers access to Tradier Brokerage’s trading platform and market data. It empowers developers to create custom trading solutions, financial apps, and websites and automate trading strategies. The API provides real-time market data, quotes, orders, and other trading information, allowing developers to create unique trading experiences for their users.

Tradier Pros and Cons

Pros:

• Tradier offers commission-free trading for stocks and EFTs.
• It has an easy-to-use mobile app.
• Tradier features are highly customizable with the REST API.
• It provides both real-time and historical market data.

Cons:

• Tradier doesn’t offer cryptocurrencies.
• Limit asset coverage compared to other brokerages.
• As per some users, customer support is not responsive.

Tradier API Pricing Plans

Tradier Brokerage offers commission-free trading for stocks and ETFs and has two pricing plans for options trading – standard and pro.

The standard plan charges $0.35 per options contract while the pro plan has a flat fee of $10/month for unlimited options trading. If you mainly trade stocks and ETFs, the standard account may be enough. If you trade options frequently, the pro account with its monthly fee is a better option.

How to Get Started with Tradier API in Python?

Accessing the Tradier API requires Tradier access tokens which you can get by creating an account with Tradier.

To do so, go to the Tradier Sign-up page and create your Tradier account.

The next step is to retrieve your Tradier API token, which allows you access to the Tradier API from within your Python code.

Once you log in to your Tradier account, you will see your account dashboard. Click on your profile avatar from the top-right corner of your dashboard, and click “API Access.”

You should see both your real (brokerage account) and sandbox account access tokens. The Tradier sandbox account is a paper trading account that allows you to simulate various API functions on dummy data. A sandbox account is a good option if you want to test your application or trading strategy before launching it into production.

Save your real and sandbox account access tokens in a safe place. Do not share these tokens with anyone. Consider looking into environment variables or using a dotenv file.

Now that you have everything you need to access Tradier API endpoints, let’s dive into a step-by-step demonstration with a simple example using Python.

Simple Example Fetching Data Using Tradier API in Python

This section will show you how to access Tradier API endpoints via your real and sandbox accounts.

According to Tradier documentation, two third-party Python libraries are available. However, these libraries can be challenging for beginners to use due to limited documentation and encountered issues.

I personally recommend using the Python requests library for accessing Tradier API as it is easier, has extensive documentation, and is faster. Additionally, mastering the use of the requests library can enable you to access any REST API.

Real Account Example with Requests Module

Let’s first save a few things we’re going to use a lot:

• The Tradier API real account access token.
• The base URL for the Tradier API real account, which is: https://api.tradier.com

The following script defines variables that store your Tradier API access tokens and the base URL. These two values will always remain the same; the only change will be in the URL of the endpoint you want to access.

import os
# access the tradier token for real account
tradier_key = os.getenv('TRADIER_TOKEN')
# base API URL for real account
base_url = 'https://api.tradier.com'

Making a Request

To make a request to a Tradier API endpoint via the Python requests module, you need craft a request to an endpoint. Here you’ll also need three items:

1. The concatenation of base and endpoint URLs.
2. A parameters dictionary specifying the information that you want to retrieve from the endpoint. Some of the endpoints do not require the parameter dictionary.
3. A headers dictionary that contains the authentication information e.g, your access token.

You need to pass the above three values to one of the requests module’s methods, e.g., get(), post(), delete(), etc.

For example, the following script makes an API call using the get() method to retrieve Apple and Microsoft quotes information.  

We pass the following information to the get() method:

1. The endpoint URL is /v1/markets/quotes.
2. The parameters dictionary is where we pass AAPL and MSFT values for the symbols attribute.
3. The headers dictionary contains your real account access token.

import requests

# declare variables to store endpoint url, parameters, and headers

endpoint_url = '/v1/markets/quotes'
parameters = {'symbols': 'AAPL,MSFT'}
headers = {'Authorization': 'Bearer '+ tradier_key }

# make the call to tradier API
response = requests.get(base_url + endpoint_url,
                        params = parameters,
                        headers = headers
                       )

Processing Response

Tradier API returns responses in two formats: XML and JSON.

XML Response

By default, the Tradier API returns a response in XML format. You can print all the data in the response using the text attribute of the response object.

print(response.text)

You can parse the XML response in a Pandas DataFrame using the read_xml() method of the Pandas module.

import pandas as pd
quotes_df = pd.read_xml(response.text)
quotes_df.head()

JSON Response

If you want to get a response in the JSON format, you must pass application/json as the value for the Accept attribute of the headers dictionary. In the response, you will see JSON data.

headers = {'Authorization': 'Bearer '+ tradier_key, 'Accept':'application/json' }

response = requests.get(base_url + endpoint_url,
                        params = parameters,
                        headers = headers
                       )

json_response = response.json()

print(json_response)

Converting a JSON response to a Pandas DataFrame requires one additional step. You first have to convert the JSON response to a Pandas dictionary. The above output shows that the quote dictionary nested inside the quotes dictionary contains the information we need. To convert it into a Python dictionary, you can use the  json_response[‘quotes’][‘quote’]  code. Next, you can pass the dictionary to the DataFrame constructor. Here is an example.

quotes_df = pd.DataFrame(json_response['quotes']['quote'])
quotes_df.head()

You cannot convert all Tradier API responses to Pandas DataFrames, because the response might not be symmetrical, i.e., contain an unequal number of attributes for all the records in the response. I recommend that you first print the response using the text attribute and then see if you can convert it to your desired format.

In the next section, you will see how to access Tradier API endpoints via a sandbox account.

Sandbox Account Example with Requests Module

To access the Tradier API via a sandbox account, you need to make a couple of changes to the code that you have already seen:

1. Replace the real account access token with the sandbox account access token.
2. Replace the real account base URL with the sandbox account base URL, which is: https://sandbox.tradier.com

# access the tradier sandbox account token
sb_tradier_key = os.getenv('TRADIER_SB_TOKEN')

# base url now points to sandbox base url
sb_base_url = 'https://sandbox.tradier.com'

The remaining process remains the same as accessing Tradier API endpoints via a real account. The following script shows how to get stock quote information via a Tradier API sandbox account.

endpoint_url = '/v1/markets/quotes'
parameters = {'symbols': 'AAPL,MSFT'}
headers = {'Authorization': 'Bearer '+ sb_tradier_key }

# make the call to tradier API
response = requests.get(sb_base_url + endpoint_url,
                        params = parameters,
                        headers = headers
                       )

# parsing response
quotes_df = pd.read_xml(response.text)
quotes_df.head()

In the rest of this article, I will use the sandbox account for accessing the Tradier API. I will switch to the real account for endpoints not available in the sandbox account.

What are the Tradier API Endpoints?

We can group Tradier API endpoints into the following categories:

• Account
• Market Data
• Streaming
• Trading
• Watchlist

Let’s see in action some standard requests from the above endpoints.

Account Endpoint

As the name suggests, the account endpoint functions allow you to retrieve your account-related information, e.g., your profile name, account balance, account orders, etc.

Get User Profile and Account Info

The endpoint URL /v1/user/profile allows you to retrieve your account information, such as your Tradier profile name and ID, your Tradier account number, account type, etc.

endpoint_url = '/v1/user/profile'
headers = {'Authorization': 'Bearer '+ sb_tradier_key, 'Accept':'application/json'}

response = requests.get(sb_base_url + endpoint_url,
                        headers = headers
                       )

response = response.json()
print(response)

It doesn’t make much sense to convert the above output to a Pandas dataframe since we do not have multiple data records.  

You can retrieve individual pieces of information from the response. For example, you can retrieve your Tradier profile name and user ID via the following script. You can use this information to display your custom application logged-in user name and ID.

print("User Name - {}".format(response['profile']['name']))
print("User Id - {}".format(response['profile']['id']))

You can get your detailed account information via the following script.

Get Account Balance

The /v1/accounts/account_id/balances/ endpoint URL returns your account balance information. You need to replace your account id with the /account_id in the endpoint URL. In the output, you will see your detailed account balance information.

account_id = "VA74599218"
endpoint_url = '/v1/accounts/{}/balances'.format(account_id)

headers = {'Authorization': 'Bearer '+ sb_tradier_key, 'Accept':'application/json'}

response = requests.get(sb_base_url + endpoint_url,
                        headers= headers
                       )

response.json()

Get Orders

If you want to see all your account orders, e.g., buying, selling, canceled, modified, etc., you use the /v1/accounts/{account_id}/orders endpoint. The response contains your order id, order type, stock symbol, order side (buy, sell, etc.), order status, create date, etc.

account_id = "VA74599218"
endpoint_url = '/v1/accounts/{}/orders'.format(account_id)
headers = {'Authorization': 'Bearer '+ sb_tradier_key, 'Accept':'application/json'}
response = requests.get(sb_base_url + endpoint_url,
                        headers= headers
                       )
response = response.json()

# execute the following code only if you have placed orders
# otherwise you will receive an exception

orders_df = pd.DataFrame(response['orders']['order'])
orders_df.head()

In the next section, you will see how to retrieve stock market data via the market data endpoint.

Market Data Endpoint

The market data endpoint functions allow to access market information such as current and historical quotes, time-series data, company information, financial reports, etc.

Get Tradier Securities List

The /v1/markets/etb endpoint returns all Tradier securities along with their symbols, types, descriptions, and exchanges.

endpoint_url = '/v1/markets/etb'
params = {'q': 'alphabet', 'indexes': 'false'}
headers = {'Authorization': 'Bearer '+ sb_tradier_key, 'Accept':'application/json' }

response = requests.get(sb_base_url + endpoint_url,
    headers = headers
)
response = response.json()
securities_df = pd.DataFrame(response['securities']['security'])
securities_df.head()

Once you parse the information about all Tradier securities in a Pandas DataFrame, you can filter the information about any security. For instance, the following script filters securities that contain the word “apple” in their descriptions.

df = securities_df[securities_df['description'].str.contains("apple",  
                                                             na = False, 
                                                             case = False )]
df.head()

Get Tradier Quotes

You have already seen the quotes endpoint in action in the first example of this article. The quotes endpoint returns the current quotes information, such as the latest price, current trading volume, etc.

endpoint_url = '/v1/markets/quotes'
parameters = {'symbols': 'AAPL,MSFT', 'greeks': 'false'}
headers = {'Authorization': 'Bearer '+ sb_tradier_key, 'Accept':'application/json' }

response = requests.get(sb_base_url + endpoint_url,
                        params = parameters,
                        headers = headers
                       )


json_response = response.json()

quotes_df = pd.DataFrame(json_response['quotes']['quote'])
quotes_df.head()

Get Tradier Historical Quotes

Historical information about quotes allows you to see a quote’s recent buying/selling/volume trends. This information is helpful for backtesting and future trading decisions.

The /v1/markets/history endpoint returns historical data for a quote. You must pass the start and end dates to the parameter dictionary’s start and end attributes. The interval attribute specifies the granularity of the response. The intervals can be daily, weekly, and monthly.

In the output, you will see historical OHLCV information.

endpoint_url = '/v1/markets/history'
params = {'symbol': 'AAPL', 'interval': 'daily', 'start': '2023-01-01', 'end': '2023-01-25'}
headers = {'Authorization': 'Bearer '+ sb_tradier_key, 'Accept':'application/json' }

response = requests.get(sb_base_url + endpoint_url,
                        params = params,
                        headers = headers
                       )

response = response.json()
hist_quotes_df = pd.DataFrame(response['history']['day'])
hist_quotes_df.head(10)

Get Stock Time Seris Data

If you want more fine-grained historical information, you can use the /v1/markets/timesales endpoint to retrieve time-series information with finer intervals of up to a single tick. A tick corresponds to a single trade occurring for a quote. Other interval levels include 1min. 5min, and 15min.

The following script returns 15min time series data for Apple within a specific period.

endpoint_url = '/v1/markets/timesales'
params = {'symbol': 'AAPL', 'interval': '15min', 'start': '2023-01-19 09:30:00', 'end': '2023-01-19 16:00:00'}
headers = {'Authorization': 'Bearer '+ sb_tradier_key, 'Accept':'application/json' }

response = requests.get(sb_base_url + endpoint_url,
    params = params,
    headers = headers
)

response = response.json()
quotes_ts = pd.DataFrame(response['series']['data'])
quotes_ts.head()

You can plot the time series in a Pandas DataFrame, using a line plot in Python. You will first need to convert the time column to DateTime column type and then set the column as the index column of a DataFrame.

quotes_ts['time'] = pd.to_datetime(quotes_ts['time'])
quotes_ts.set_index('time', inplace=True)
quotes_ts.head()

The following script uses the matplotlib.pyplot() module to plot a line plot using time series data from the Tradier API.

import matplotlib.pyplot as plt
import seaborn as sns
sns.set_style("darkgrid")
sns.set_context("poster")

quotes_ts['close'].plot(figsize=(12,8))

Get Company Information

The /beta/markets/fundamentals/company endpoint returns miscellaneous information about a company. This endpoint is currently in Beta and unavailable with the sandbox account. The following script searches company information for Apple.

# currently in beta and not available to sandbox accounts

endpoint_url = '/beta/markets/fundamentals/company'
headers = {'Authorization': 'Bearer '+ tradier_key, 'Accept':'application/json' }
params={'symbols': 'AAPL'}
response = requests.get(base_url + endpoint_url,
                        params = params,
                        headers = headers
)

response = response.json()
response

Get Company Financial Reports

You can use the /beta/markets/fundamentals/financials endpoint to retrieve a company’s financial reports, which can help you make future trading decisions.

# currently in beta and not available to sandbox accounts

endpoint_url = '/beta/markets/fundamentals/financials'
headers = {'Authorization': 'Bearer '+ tradier_key, 'Accept':'application/json' }
params={'symbols': 'AAPL'}
response = requests.get(base_url + endpoint_url,
                        params = params,
                        headers = headers
)

response = response.json()
response

Streaming Endpoint

The streaming API allows you to retrieve real-time data from the Tradier API. The streaming API endpoint provides HTTP and WebSocket streaming functionalities to access real-time data.

The endpoint functions are not available with the sandbox account.

Create Tradier Streaming Session

You must create a streaming session before using HTTP or WebSocket streaming to retrieve real-time data. A streaming session is only valid for 5 minutes. You must initiate an HTTP or a WebSocket stream within 5 minutes of creating a streaming session or you’ll need to create a new one.

The /v1/markets/events/session endpoint allows you to create a streaming session.

endpoint_url = '/v1/markets/events/session'
headers = {'Authorization': 'Bearer '+ tradier_key, 'Accept':'application/json' }

response = requests.post(base_url + endpoint_url,
                         headers= headers)
response = response.json()
print(response)

The following script shows how you can retrieve your session id from the response of creating a streaming session. You need the session id to initiate an HTTP or a WebSocket stream, as you will see in the next section.

session_id = response['stream']['sessionid']
print(session_id)

Before proceeding, it is pertinent to mention that HTTP and WebSockets are different client-server communication protocols. As a general rule, I suggest using WebSockets over HTTP in almost every scenario since WebSockets are faster and more state-of-the-art. If you are interested in learning more about the difference, check out this blog from Windows.

Streaming Quotes Events via HTTP Streaming

The base URL for HTTP streaming events is https://stream.tradier.com.

The /v1/markets/events endpoint allows you to retrieve real-time events for a particular stock.

The response is an iterable Python object that you can iterate using iter_lines() method to retrieve real-time streaming responses.

import json 

stm_base_url = 'https://stream.tradier.com'
endpoint_url = '/v1/markets/events'
headers = {'Accept': 'application/json'}

payload = { 'sessionid': session_id,
           'symbols': 'AAPL',
           'linebreak': True
}

response = requests.get(stm_base_url + endpoint_url, 
                        stream=True, 
                        params=payload, 
                        headers=headers)

for line in response.iter_lines():
    if line:
        print(json.loads(line))

Streaming Quotes via WebSocket Streaming

The base URL for WebSocket streaming is wss://ws.tradier.com.

You can retrieve WebSocket streaming from the Tradier API using the Python websockets module.

To initiate a WebSocket connection, you need to define an asynchronous function and pass the base and endpoint URLs to the connect() method of the WebSockets module.

Next, you send the payload containing quotes symbols and session id via the send() method of websocket module.

Finally, you can parse the WebSocket response line by line, print it on the console, or use it in your application logic.

import asyncio
import websockets

# will need this for jupyter notebook
import nest_asyncio
nest_asyncio.apply()

ws_url = "wss://ws.tradier.com"
endpoint_url = "/v1/markets/events"

async def ws_connect():
    uri = ws_url + endpoint_url
    async with websockets.connect(uri, ssl=True, compression=None) as websocket:
        payload = '{"symbols": ["AAPL"], "sessionid":"' + session_id + '", "linebreak": true}'
        print(payload)
        await websocket.send(payload)

        print(f">>> {payload}")

        async for message in websocket:
            print(f"<<< {message}")

asyncio.run(ws_connect())

Trading Endpoint

The trading endpoint functions allow you to execute various trading activities, e.g., buying and selling equities and options.

Place a Stock Buying Order

The /v1/accounts/{account_id}/orders endpoint allows you to place an order.

You need to pass values for the five required parameters while selling or buying a stock:

1. class – specifies the order type, e.g., equity, option, combo, etc.
2. symbol – the stock symbol you want to buy, sell, or short.
3. duration: the duration for which the order will be effective (Day or GTC)
4. side – the order side, e.g., buy or sell
5. quantity – the number of shares to buy or sell
6. type – the type of order, e.g., market, limit, etc.

You must pass the above parameter values into a data dictionary to execute an order. The requests module’s post() method allows you to execute an order.

For example, the following script places a buying market order for five shares of Microsoft.

account_id = 'VA74599218'
endpoint_url = '/v1/accounts/{}/orders'.format(account_id)

headers = {'Authorization': 'Bearer '+ sb_tradier_key, 'Accept':'application/json'}
data = {'class': 'equity', 
      'symbol': 'MSFT', 
      'side': 'buy', 
      'quantity': '5', 
      'type': 'market', 
      'duration': 'day',  
      'tag': 'my-aapl-order'}

response = requests.post(sb_base_url + endpoint_url,
                         data = data,
                         headers = headers
                        )

response = response.json()
response

Place a Stock Selling Order

For selling a stock order, everything remains the same except that you need to pass sell as the value for the side attribute of the data dictionary.

For example, the following script places a selling order for two shares of Microsoft.

account_id = 'VA74599218'
endpoint_url = '/v1/accounts/{}/orders'.format(account_id)

headers = {'Authorization': 'Bearer '+ sb_tradier_key, 'Accept':'application/json'}
data = {'class': 'equity', 
      'symbol': 'MSFT', 
      'side': 'sell', 
      'quantity': '2', 
      'type': 'market', 
      'duration': 'day',  
      'tag': 'my-msft-order'}

response = requests.post(sb_base_url + endpoint_url,
                         data = data,
                         headers = headers
                        )

response = response.json()
response

Cancel an Order

To cancel an order, you must call the delete() method from the requests module and pass it the

/v1/accounts/{account_id}/orders/{order_id} endpoint URL. You need to replace the account_id with your account id and the order_id with the ID of the order you want to cancel.

An order can be in the following states: open, partially filled, filled, expired, canceled, pending, rejected, or error. You cannot cancel an order in a filled or partially filled state.

The following script demonstrates how to cancel an order.

account_id = 'VA74599218'
order_id = '4845262'

endpoint_url = '/v1/accounts/{}/orders/{}'.format(account_id, order_id)

headers = {'Authorization': 'Bearer '+ sb_tradier_key, 'Accept':'application/json'}

response = requests.delete(sb_base_url + endpoint_url,
                         headers = headers
                        )


response.text

# status can be one of: open, partially_filled,
# filled, expired, canceled, pending, rejected, error

Modify an Order

The requests modules put() method modifies an order. The endpoint for order modification is /v1/accounts/{account_id}/orders/{order_id}. You need to pass the data dictionary with the modified order information to the put() method.

You cannot modify an already filled order, just like canceling an order.

account_id = 'VA74599218'
order_id = '4918981'
endpoint_url = '/v1/accounts/{}/orders/{}'.format(account_id, order_id)
headers = {'Authorization': 'Bearer '+ sb_tradier_key, 'Accept':'application/json'}
data = {'quantity': '7'}
response = requests.put(sb_base_url + endpoint_url,
                        data = data,
                         headers = headers
                        )
response.text

If you try to modify an already filled order, you will receive the following response.

Watchlist Endpoint

Tradier API allows you to create, retrieve, and delete watchlists. A watchlist in trading is a list of securities that a user is interested in monitoring or tracking.  

Create a Tradier Watchlist

You must pass the /v1/watchlists endpoint URL to the put() method of the requests module to create a new watchlist.

You need to pass the data dictionary containing the watchlist name, and symbols of the equities you want to track to the put() method. Here is an example:

endpoint_url = '/v1/watchlists'
data = {'name': 'My Watchlist6', 'symbols': 'AAPL,MSFT,NFLX'}
headers = {'Authorization': 'Bearer '+ sb_tradier_key, 'Accept':'application/json'}

response = requests.post(sb_base_url + endpoint_url,
                         data = data,
                         headers = headers
)
response = response.json()
response

Get Tradier Watchlists

You can retrieve all your Tradier watchlists using the /v1/watchlists endpoint. You need to pass the endpoint URL to the get() method.

Here is an example:

endpoint_url = '/v1/watchlists'
response = requests.get(sb_base_url + endpoint_url,
                         headers = headers
)
response = response.json()
response

To retrieve information about a specific watchlist, you can use the /v1/watchlists/{watchlist_id} endpoint, as the following example demonstrates.

watch_list_id = "public-13ci9xve4t"
endpoint_url = '/v1/watchlists/{}'.format(watch_list_id)
response = requests.get(sb_base_url + endpoint_url,
                         headers = headers
)
response = response.json()
response

Once you retrieve a watchlist, you can use the equities symbols from your watchlist to get information about the symbols.

Delete Watchlists

The /v1/watchlists/{watchlist_id} endpoint, in combination with the requests module’s delete() method, allows you to delete an existing watch. Here is an example:

watch_list_id = "public-13ci9xve4t"
endpoint_url = '/v1/watchlists/{}'.format(watch_list_id)
response = requests.delete(sb_base_url + endpoint_url,
                         headers = headers
)
response = response.json()
response

Tradier API endpoints allow you to perform various tasks, as seen in the previous section. However, several Tradier alternatives are of interest to you.

Tradier Alternatives

Following are some alternatives to the Tradier platform:

1. Tasty Works
2. Robinhood
3. Vanguard
4. Etrade
5. Webull

Frequently Asked Questions

The Bottom Line

Tradier Brokerage offers a user-friendly trading platform through a web interface or REST API. This tutorial shows how to access Tradier API endpoints in Python for custom financial software and automated trading. Using the Python requests module is a reliable alternative to third-party API clients. After following the steps in this tutorial, you will be able to access market data, execute trades, and manage accounts using the Tradier API.