How To Trade Options with Alpaca's Dashboard and Trading API

This blog was last updated on February 25th, 2025.

Alpaca enables developers to algorithmically trade options, stocks, ETFs, and crypto with the ability for manual execution if desired. Easy to use and designed for complex trading strategies, this in-depth tutorial guides traders on how to both paper trade and live trade options. This guide has been updated to include multi-leg option trading strategies. 

With the launch of Level 3 options, Trading API users can now implement multi-leg strategies like straddles, strangles, iron butterflies, iron condors, and spreads (like credit, calendar, and debit) to capitalize on market volatility, range-bound price movements, and directional trends. These advanced strategies allow traders to increase efficiency by combining multiple contracts in one trade rather than combining multiple single-leg orders, and enhance risk management by ensuring all orders and trades are executed simultaneously.

In this tutorial, we’ll review how to apply for options trading in your Alpaca account and demonstrate how to use the dashboard to paper trade options, including calls and puts, as well as multi-leg orders. We’ll then provide a tutorial on how to place an options trade in Alpaca’s Trading API with both Alpaca-py and Postman. This includes fetching the necessary account and contract data to place an order before closing its associated position.

Apply For Your Desired Options Level

1. Sign up for an account

Note: If you already have an account, please skip to the next step. If you are only paper trading options, you can skip ahead to the next section. All paper trading accounts will automatically have access to Level 3 strategies. You only need to apply for your desired level if you are looking to live trade options.

To trade options, you will need to create a Trading API account with Alpaca and connect it to our paper trading environment. If you’d like to open a live trading account, Alpaca will ask for additional details regarding your trading background and your objectives for investing.

2. Apply for options trading

Navigate to the “Home” page and in the top right, to the left of “Add Funds”, there will be a button to apply for options trading. You can also check your current options approvals by going to the “Configure” tab under the “Account” menu of your Dashboard. Please note: It’s important to check the configurations under the appropriate “Live” or “Paper” account.

3. Get approved

Once you’ve provided all the necessary information, you will be approved for options trading and can start live trading in your Dashboard or Alpaca’s Trading API!

Trading Options Using Alpaca’s Dashboard

1. Log in to your account

Sign in to your account and navigate to the “Home” page.

2. Find your desired trade

On your dashboard in the top left, you can select between using your paper trading or live accounts. It’s important that you select the appropriate trading account before implementing an options strategy. If you want to practice without the risk of real capital, you can use your paper trading accounts. If you are looking to implement strategies, you can use your live account.

Once you’ve selected the desired account within your dashboard, you can monitor your portfolio, access market data, execute trades, and review your trading history. In order to create your first options trade, use the search bar to find and select the applicable option ticker symbol.

Please note we are using SPY as an example and it should not be considered investment advice.

3. Opening an options position

On the asset’s page, toggle from “Stocks” to “Options” and determine your desired contract type between calls and puts. You can also adjust the expiration date from the dropdown, ranging anywhere from 0DTE options to contracts hundreds of days in the future.

Once determined, review your order type (such as market, limit, stop, stop limit, or trailing stop) and the number of contracts you’d like to trade. 

Press "Confirm Order" and your paper trading account will then mimic the execution of the order as though it were a real transaction.

4. Exercising your position

Exercising a position in options trading involves electing the right provided by an options contract to buy or sell the underlying asset at the agreed-upon price.

If you’d like to exercise, this can be accomplished in the same manner as when it was opened. Find the desired options contract through the “Home” or “Positions” page and select “Exercise”.

You’ll then be prompted to confirm.

Please note: You will need to have sufficient funds in your account to exercise the option. Also, in American-style options, only long positions can be exercised. This can occur at any time before or at expiration.

5. Closing your position

Closing an options position involves selling the options contract that you previously bought (in a long position) or buying back the options contract that you previously sold (in a short position). Either action terminates, or “closes”, your associated position.

If you’d like to close your position, find the desired options contract on your “Home” page or under “Positions”. Click on the appropriate contract symbol and select “Close Position”.

You’ll then be prompted to confirm.

6. Entering a Multi-Leg Options Strategy

While the above steps highlight executing a single-leg order, creating a multi-leg option strategy in Alpaca's dashboard requires a few extra steps. Below, we’ll demonstrate how to execute a long straddle using Alpaca’s dashboard. 

Please note we are using SPY as an example and it should not be considered investment advice.

6.1 Opening an options position

Assume we have already analyzed the market and determined the strike price for both a call and a put option to be $600. Once determined, select and review your order type (market or limit) and decide on the number of contracts you’d like to trade. You can select up to four legs. 

A long straddle requires buying one call option and one put option at the same strike price. Therefore, you can establish your position in the dashboard by selecting one call option and one put option with the same strike price with both selected as "buy to open". Click “Confirm Order” to purchase the options contracts.

Please note: The order in which you select the options does not matter. Also, on Alpaca’s dashboard and Alpaca’s Trading API, credits are displayed as negative values, while debits are shown as positive values. For example, in the image below, the debit spread (where your initial entry requires payment) is displayed with a positive limit price ($2.58 in this case) under “Limit Price (Debit).”

6.2 Cancel your order

Keep in mind that with multi-leg options order, you cannot cancel or replace a child leg individually. You can only cancel or replace your multi-leg options order as a whole.

You’ll then be prompted to confirm.

6.3 Exercising / Closing your position

Closing, or liquidating, a multi-leg options position follows the same steps as closing a single-leg options position. If you’d like to close your position, find the desired options contract on your “Home” page or under “Positions”. Click on the appropriate contract symbol and select “Liquidate Selected”.

You will, then, click the “Confirm” button to liquidate the position.

Options Trading Using Alpaca-py

Now that we’ve covered the dashboard, we can switch to how to paper or live trade options using Alpaca’s Trading API. We’ve chosen to showcase this using Alpaca-py, Alpaca’s Python library, which is designed for algorithmic trading. 

Trading options algorithmically opens up a realm of possibilities for automation, especially in the US options market. If you’re looking for more options-related content, we produce in-depth tutorials and guides on trading options algorithmically like: the options wheel strategy, 0dte options, gamma scalping, and delta hedging. Read all of our options-related content.

Developing with Alpaca-py:

1. Setup

1.1 Install / Update Alpaca-py

pip install alpaca-py --upgrade

1.2 Import Necessary Packages

If you have any other packages you want to add, you can do so in this section.

import json
from datetime import datetime, timedelta
from zoneinfo import ZoneInfo

from alpaca.trading.client import TradingClient
from alpaca.data.timeframe import TimeFrame, TimeFrameUnit
from alpaca.data.historical.stock import StockHistoricalDataClient, StockLatestTradeRequest
from alpaca.data.historical.option import OptionHistoricalDataClient
from alpaca.trading.stream import TradingStream
from alpaca.data.live.option import OptionDataStream

from alpaca.data.requests import (
    OptionBarsRequest,
    OptionTradesRequest,
    OptionLatestQuoteRequest,
    OptionLatestTradeRequest,
    OptionSnapshotRequest,
    OptionChainRequest
)
from alpaca.trading.requests import (
    GetOptionContractsRequest,
    GetAssetsRequest,
    MarketOrderRequest,
    GetOrdersRequest,
    ClosePositionRequest
)
from alpaca.trading.enums import (
    AssetStatus,
    ExerciseStyle,
    OrderSide,
    OrderType,
    TimeInForce,
    QueryOrderStatus,
    ContractType
)
from alpaca.common.exceptions import APIError

2. Setup clients

In this demonstration, we use a paper trading environment.

# Initializing connection to Alpaca’s Trading API
TRADE_API_KEY = "Your API Key"
TRADE_API_SECRET = "Your API Secret"
TRADE_API_URL = "https://api.alpaca.markets"

#### We use paper environment for this example ####

## To enable live trading, a few settings need to be changed in the API client configuration as outlined below:
# 1. Replace `PAPER = True` with `PAPER = False` to disable the paper trading configuration.  
# 2. Replace `url_override=None` with `url_override=TRADE_API_URL` to connect to your Alpaca live account.  

PAPER = True
trade_client = TradingClient(api_key=TRADE_API_KEY, secret_key=secret_key, paper=PAPER, url_override=None)
stock_data_client = StockHistoricalDataClient(api_key=TRADE_API_KEY, secret_key=TRADE_API_SECRET)

# Below are the variables for development this documents so please do not change these variables
TRADE_API_WSS = None
DATA_API_URL = None
OPTION_STREAM_DATA_WSS = None

3. Check trading account

# Check account related information
acc = trade_client.get_account()

4. Check account configuration

# Check account configurations
acct_config = trade_client.get_account_configurations()

5. Retrieve list of assets which are options enabled

# We can filter assets by `options_enabled` attribute
# Asset object has `options_enabled` attribute if it is options enabled
req = GetAssetsRequest(
  attributes = "options_enabled"  
)
assets = trade_client.get_all_assets(req)

6. Get list of options contracts for the given symbol (e.g. SPY)

# In this instance, we retrieve the necessary contracts based on the parameters we've configured.
# specify underlying symbol

underlying_symbol = "SPY"
req = GetOptionContractsRequest(
    underlying_symbol=[underlying_symbol],  
    
# specify asset status: active (default)
    status=AssetStatus.ACTIVE,   
    
# specify expiration date (specified date + 1 day range)
    expiration_date = None,
    
# we can pass a date object or string (YYYY-MM-DD) to specify an expiration date range
    expiration_date_gte = None,                            
    expiration_date_lte = None, 
    
# specify root symbol
    root_symbol = None,
    
# specify option type (ContractType.CALL or ContractType.PUT)
    type = None,                    
)

res = trade_client.get_option_contracts(req)

7. Get options contract by symbol

symbol = res.option_contracts[0].symbol
contract = trade_client.get_option_contract(symbol)

8. Get options contract by id

id = res.option_contracts[0].id
contract = trade_client.get_option_contract(symbol_or_id=id)

9. Get put options contracts

Please note that the stock SPY is used as an example and should not be considered investment advice.

# We can filter the contracts that are relevant to us by specifying various option properties like expiration date range (the contracts which are expiring within a particular time window), strike range (the contracts with strike prices within a given range), style of expiration for the option contract (like American or European), etc.

underlying_symbol = "SPY"

# specify expiration date range
now = datetime.now(tz=ZoneInfo("America/New_York"))
day1 = now + timedelta(days=1)
day60 = now + timedelta(days=60)

req = GetOptionContractsRequest(
# specify underlying symbol
    underlying_symbol = [underlying_symbol],
    
# specify asset status: active (default)
    status = AssetStatus.ACTIVE,
    
# specify expiration date (specified date + 1 day range)
    expiration_date = None,
    
# we can pass date object or string
    expiration_date_gte = day1.date(),
    expiration_date_lte = day60.strftime(format="%Y-%m-%d"),
    
# specify root symbol
    root_symbol = None,
    
# specify option type: put
    type = ContractType.PUT,
    
# specify option style: american
    style = ExerciseStyle.AMERICAN
    
# specify strike price range
    strike_price_gte = None,
    strike_price_lte = None,
    
# specify limit
    limit = 100,
    
# specify page
    page = None
)

res = trade_client.get_option_contracts(req)

10. Get the highest open interest contract

# Filter contract with the highest open interest

max_open_interest = 0
high_open_interest_contract = None
for contract in res.option_contracts:
    if int(contract.open_interest) > max_open_interest:
        max_open_interest = int(contract.open_interest)
        high_open_interest_contract = contract

11. Explore information about the selected contract

# Check contract information like expiry, expiration style and contract status

#Check option expiry
print(high_open_interest_contract.expiration_date)

#Check option status
print(high_open_interest_contract.status)

#Check option exercise style
print(high_open_interest_contract.style)

12. Place a long put option order

# Execute either a Buy Call or Put option order in accordance with your trading strategy

req = MarketOrderRequest(
    symbol=high_open_interest_contract.symbol,
    qty=1,
    side=OrderSide.BUY,
    type=OrderType.MARKET,
    time_in_force=TimeInForce.DAY,
)
res = trade_client.submit_order(req)

13. Get list of requested orders by specifying option contract symbol

req = GetOrdersRequest(
    status=QueryOrderStatus.ALL,
    symbols=[high_open_interest_contract.symbol],
    limit=2,
)
orders = trade_client.get_orders(req)

14. Filter contract with the desired client_order_id and print the status

orders_df = pd.DataFrame([vars(order) for order in orders])

#select order with the corresponding client_order_id
order = orders_df[orders_df['client_order_id'] == client_order_id]

#print order status
print(order.status.iloc[0])

15. Get positions filtered by option contract symbol

Review all positions or open positions (By symbol or contract ID) in the following ways.

15.1 Get all positions

positions = trade_client.get_all_positions()

15.2 Get open positions by symbol

positions = trade_client.get_open_position(
symbol_or_asset_id=high_open_interest_contract.id
)

15.3 Get open positions by contract id

positions = trade_client.get_open_position(
symbol_or_asset_id=high_open_interest_contract.id
)

15.4 check cost basis and unrealized profit/loss

# Show cost basis
print(positions.cost_basis)

# Show unrealized profit/loss
print(positions.unrealized_pl)

16. Close the option position

trade_client.close_position(
    symbol_or_asset_id=high_open_interest_contract.symbol,
    close_options=ClosePositionRequest(qty="1")
)

17. Trade Update (Stream)

# Retrieve real-time live trade update data from the moment the order is placed until execution.
# Subscribe trade updates

trade_stream_client = TradingStream(api_key, secret_key, paper=paper, url_override=TRADE_API_WSS)

async def trade_updates_handler(data):
    print(data)

trade_stream_client.subscribe_trade_updates(trade_updates_handler)
trade_stream_client.run()

18. Market Data (Historical)

# setup option historical data client
option_historical_data_client = OptionHistoricalDataClient(api_key, secret_key, url_override=DATA_API_URL)

# get option latest quote by symbol
req = OptionLatestQuoteRequest(
    symbol_or_symbols=[high_open_interest_contract.symbol],
)
option_historical_data_client.get_option_latest_quote(req)

# get option latest trade by symbol
req = OptionLatestTradeRequest(
    symbol_or_symbols=[high_open_interest_contract.symbol],
)
option_historical_data_client.get_option_latest_trade(req)


# get option chain by underlying_symbol
req = OptionChainRequest(
    underlying_symbol=high_open_interest_contract.underlying_symbol,
)
option_historical_data_client.get_option_chain(req)

19. Market Data (Stream)

# Live streaming of market data based on a collection of symbols or an individual symbol
option_data_stream_client = OptionDataStream(api_key, secret_key, url_override=OPTION_STREAM_DATA_WSS)

async def option_data_stream_handler(data):
    print(data)

symbols=[
    high_open_interest_contract.symbol,
]

option_data_stream_client.subscribe_quotes(option_data_stream_handler, *symbols) 
option_data_stream_client.subscribe_trades(option_data_stream_handler, *symbols)

option_data_stream_client.run()

20. Place Multi-Leg Option Position

The example below utilizes one of the multi-leg option strategies called a long straddle.

Please note that the stock SPY is used as an example and should not be considered investment advice.

20.1 Get the underlying stock price and define the strike range to narrow down the option chain.

# Define a underlying symbol we want to trade
underlying_symbol = 'SPY'

# Get the latest price of the underlying stock
def get_underlying_price(symbol):
    underlying_trade_request = StockLatestTradeRequest(symbol_or_symbols=symbol)
    underlying_trade_response = stock_data_client.get_stock_latest_trade(underlying_trade_request)
    return underlying_trade_response[symbol].price

# Get the latest price of the underlying stock
underlying_price = get_underlying_price(underlying_symbol)

# Define a 1% range around the underlying price 
STRIKE_RANGE = 0.01

# Set the minimum and maximum strike prices based on the underlying price
min_strike = str(underlying_price * (1 - STRIKE_RANGE))
max_strike = str(underlying_price * (1 + STRIKE_RANGE))

print(f"{underlying_symbol} price: {underlying_price}")

20.2 Define a function to find near at-the-money (ATM) options.

# This is a function that will return a contract which minimizes the difference from a target price
def find_nearest_strike_contract(contracts, target_price):
    min_diff = 0
    min_contract = None
    for contract in contracts:
        diff = abs(float(contract.strike_price) - target_price)
        if min_contract is None or diff < min_diff:
            min_diff = diff
            min_contract = contract
    return min_contract

20.3 Narrow down the options to near-ATM options.

# Obtain both call options and put options of the specified underlying asset
underlying_symbol = ['SPY']
order_legs = []

for c_type in [ContractType.CALL, ContractType.PUT]:
    print(c_type)
    req = GetOptionContractsRequest(
        underlying_symbols=underlying_symbol,
        status=AssetStatus.ACTIVE,
        expiration_date_gte = now.date() + timedelta(days=7),
        expiration_date_lte = now.date() + timedelta(days=8),
        style=ExerciseStyle.AMERICAN,
        strike_price_gte=min_strike,
        strike_price_lte=max_strike,
        type=c_type,
        page_token=None
    )
    # Get option chain of the underlying symbol for both contract types
    cts = trade_client.get_option_contracts(req)

    c = find_nearest_strike_contract(cts.option_contracts, underlying_price)
    order_legs.append(OptionLegRequest(
        symbol=c.symbol,
        side=OrderSide.BUY,
        ratio_qty=1
    ))

# We should see that the symbols are similar, like "SPY______C________" and "SPY______P________",
# with all values marked as "_" being the same in both symbols.
# Such is because we expect only the contract type (call or put, C or P) to be different.

order_legs

20.4 Place the order for both legs simultaneously to execute the long straddle.

# Set up an order request
req = MarketOrderRequest(
    qty=1,
    order_class=OrderClass.MLEG,
    time_in_force=TimeInForce.DAY,
    legs=order_legs
)
# place the order of the long straddle
res = trade_client.submit_order(req)
res

Options Trading Using Postman

Using Postman, a popular API client, allows for the straightforward automation and testing of options trading strategies in both simulated and live trading environments. This will navigate you through the initial setup of Postman, establishing a connection with Alpaca’s Trading API, and conducting your first options paper trade.

Installation

• Download Postman from the official website.
• Follow the installation instructions for your operating system.

Configure Postman Environment

1. Open Postman

2. Create “Environment”

Click the "Environment" quick look (eye icon) on the top right and select "Add" to create a new environment, or you can also click on the Environment icon on the left side of the dashboard. You should see this page:

3. Set up your environment (e.g., "Alpaca Trading") and add the following variables:

This step is recommended for accessibility and security purposes.

• api_key: Your Alpaca API Key
• secret_key: Your Alpaca Secret Key
• option_snapshots_url: Set this as shown below. This is used for retrieving option chains.
• base_url: Set this to either the live account endpoint or the paper account endpoint, depending on your setup. This link serves as the API endpoint.

# option_snapshots_url for option chain retrieval
https://data.alpaca.markets/v1beta1/options

# base_url for paper trading
https://paper-api.alpaca.markets/v2

# base_url for live trading
https://api.alpaca.markets

After you create the environment, make sure to save it. You can find this environment anytime in your “Environment” tab on the left side of the dashboard.

4. Initiate your first API request

To initiate your first API request, click the “Send an API request” or click the “+” tab under the “Search Postman” UI. You should see this page:

Select a created environment (e.g. “Alpaca Trading”) to link this API Request to the environment.

Alpaca uses API keys for authentication. Since we have already set up the environment called  “Alpaca Trading” and linked it to this Get Request, we can avoid hard-coding and instead use the predefined parameters. In each request, include the following headers:

• URL: Set this to {{base_url}}/account
• APCA-API-KEY-ID: Set this to {{api_key}}.
• APCA-API-SECRET-KEY: Set this to {{secret_key}}.

5. Verifying your Account Authentication

Finally, hit the send button, and you should see the following response. This means you should be able to see various account information from this API call. Now you’re ready to trade!

API Endpoints and Examples

1. Check Trading Account

Endpoint: GET {{base_url}}/account

Description: Retrieves your trading account information.

Example

• Set the method to GET.
• Enter the URL: {{base_url}}/account.
• Add headers for authentication.
• Send the request and review the response for option_approved_level and option_trading_level.

2. Get List of Assets Which Are Options Enabled

Endpoint: GET {{base_url}}/assets

Params: status=active and asset_class=us_equity.

Description: Fetches a list of assets that are eligible for options trading.

Example

• Method: GET.
• URL: {{base_url}}/assets?status=active&asset_class=us_equity.
• Filter the JSON response for assets with "options_enabled": true.

3. Get List of Options Contracts

Endpoint: GET {{option_snapshots_url}}/snapshots

Params: type=call (or put)  and feed=indicative.

Description: Fetches a list of options contracts eligible for options trading.

Example

• Method: GET.
• URL: {{option_snapshots_url}}/snapshots/SPY?feed=indicative&type=call&strike_price_gte=595

This will extract option chains where the underlying symbol is SPY and only retrieve call options with strike prices greater than or equal to $595.

4. Place an Order

Endpoint: POST {{base_url}}/orders

Description: Place an order for an options contract.

Example

• Method: POST.
• URL: {{base_url}}/orders.
• Body (JSON):

Please note we are using SPY as an example and it should not be considered investment advice.

{
  "symbol": "SPY250127C00608000",
  "qty": "1",
  "side": "buy",
  "type": "market",
  "time_in_force": "day"
}

Make sure to modify the symbol to the specific options contract symbol.

If you're unfamiliar with JSON, be sure to check out our API reference to learn how to create an order!

5. Place an Order (Multi-Leg Option Order)

Endpoint: POST {{base_url}}/orders

Description: Place an order for an options contract.

Example

• Method: POST.
• URL: {{base_url}}/orders.
• Body (JSON):

{
  "type": "market",
  "time_in_force": "day",
  "order_class": "mleg",
  "legs": [
    {
      "side": "buy",
      "position_intent": "buy_to_open",
      "symbol": "SPY250127C00608000",
      "ratio_qty": "1"
    },
    {
      "side": "buy",
      "position_intent": "buy_to_open",
      "symbol": "SPY250127P00608000",
      "ratio_qty": "1"
    }
  ],
  "qty": "2"
}

If you're unfamiliar with JSON for multi-leg option trading, be sure to check out our API reference for creating an order!

In the dashboard, you'll see a tab labeled "Body." Click on this tab, select the "raw" format, and choose "JSON (application/json)" as the data type from the dropdown menu. Enter the JSON data you want to send in the text box.

Once you hit the “Send” button, you should receive a response similar to the following:

You can also find the submitted order in the "Recent Orders" section on the Alpaca dashboard, as shown in the picture below.

6. Monitor Orders and Positions

Orders Endpoint: GET {{base_url}}/orders

Positions Endpoint: GET {{base_url}}/positions

Description: Use these endpoints to monitor your active orders and current positions.

Example

For orders: Use the GET method with the orders endpoint to retrieve a list of filled orders

1. Click on the REST API under Collections and the GET Request under it.
2. In the Endpoint section on top, type in “{{base_url}}/orders”.
3. In the “Params” section, create a “status” variable and set its value as “filled” to review all filled orders.
4. In “Headers”, create variables named APCA-API-KEY-ID, APCA-API-SECRET-KEY, and set their values to your api key and api secret respectively.
5. Send the request to retrieve information regarding all filled orders.

For positions: Use the GET method with the positions endpoint to view your current holdings.

1. Click on the REST API under Collections and the GET Request under it.
2. In the Endpoint section on top, type in {{base_url}}/positions
3. In “Headers”, create variables named APCA-API-KEY-ID, APCA-API-SECRET-KEY, and set their values to your api key and api secret respectively.
4. Send the request to retrieve information regarding all current positions

If you're unfamiliar with the GET method, be sure to check out our API reference on getting an open position!

You can also check a specific position by adding the symbol, like this: {{base_url}}/positions/{options_symbol}.

Bringing It Together

We empower both algorithmic and manual trading, ensuring flexibility for traders with varying automation preferences. 

For those interested in manually trading options, the dashboard serves as a centralized hub for trade management, market data access, and more. For developers focused on using Trading API for options trading, Alpaca has a wide variety of SDKs to utilize, such as Alpaca-py or clients like Postman.

Curious to learn more about options? We have multiple tutorials on option trading strategies like the options wheel strategy, trading 0dte options, gamma scalping, and delta hedging. Read all of our options-related content.

If you’re looking for additional technical resources, reference our options documentation for Trading API! It’s the perfect place to start developing and testing your trading algorithms today!

*Commission-free trading means that there are no commission charges for Alpaca self-directed individual cash brokerage accounts that trade U.S.-listed securities and options through an API. Relevant regulatory fees may apply. Commission-free trading is available to Alpaca's retail customers. Alpaca reserves the right to charge additional fees if it is determined that order flow is non-retail in nature. This does not apply to cryptocurrencies.

Alpaca Securities LLC and Postman are not affiliated, and neither are responsible for the liabilities of the other. 

Options trading is not suitable for all investors due to its inherent high risk, which can potentially result in significant losses. Please read Characteristics and Risks of Standardized Options before investing in options.

The Paper Trading API is offered by AlpacaDB, Inc. and does not require real money or permit a user to transact in real securities in the market. Providing use of the Paper Trading API is not an offer or solicitation to buy or sell securities, securities derivative or futures products of any kind, or any type of trading or investment advice, recommendation or strategy, given or in any manner endorsed by AlpacaDB, Inc. or any AlpacaDB, Inc. affiliate and the information made available through the Paper Trading API is not an offer or solicitation of any kind in any jurisdiction where AlpacaDB, Inc. or any AlpacaDB, Inc. affiliate (collectively, “Alpaca”) is not authorized to do business.

Please note that this article is for general informational purposes only and is believed to be accurate as of the posting date but may be subject to change. The examples above are for illustrative purposes only. Alpaca does not provide investment, tax, or legal advice. Please consult your own independent advisor as to any investment, tax, or legal statements made herein.

All investments involve risk, and the past performance of a security, or financial product does not guarantee future results or returns. There is no guarantee that any investment strategy will achieve its objectives. Please note that diversification does not ensure a profit, or protect against loss. There is always the potential of losing money when you invest in securities, or other financial products. Investors should consider their investment objectives and risks carefully before investing.

Securities brokerage services are provided by Alpaca Securities LLC ("Alpaca Securities"), member FINRA/SIPC, a wholly-owned subsidiary of AlpacaDB, Inc. Technology and services are offered by AlpacaDB, Inc.

Cryptocurrency services are made available by Alpaca Crypto LLC ("Alpaca Crypto"), a FinCEN registered money services business (NMLS # 2160858), and a wholly-owned subsidiary of AlpacaDB, Inc. Alpaca Crypto is not a member of SIPC or FINRA. Cryptocurrencies are not stocks and your cryptocurrency investments are not protected by either FDIC or SIPC. Please see the Disclosure Library for more information.

This is not an offer, solicitation of an offer, or advice to buy or sell securities or cryptocurrencies or open a brokerage account or cryptocurrency account in any jurisdiction where Alpaca Securities or Alpaca Crypto, respectively, are not registered or licensed, as applicable.