examples/options-trading-mleg.ipynb

{
 "cells": [
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# Alpaca-py trading multi-leg (mleg) options",
   "id": "6edd49e212343722"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/alpacahq/alpaca-py/blob/master/examples/options-trading-mleg.ipynb)",
   "id": "93b07ca970df3c8"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "- This notebook shows how to use alpaca-py with options trading API endpoints to place multi-leg options orders.\n",
    "- Please use ``paper account``. Please ``DO NOT`` use this notebook with live account. In this notebook, we place orders for options as an example."
   ],
   "id": "73e9000570f15da4"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Please change the following to your own PAPER api key and secret\n",
    "# or set them as environment variables (ALPACA_API_KEY, ALPACA_SECRET_KEY).\n",
    "# You can get them from https://alpaca.markets/\n",
    "\n",
    "api_key = None\n",
    "secret_key = None\n",
    "\n",
    "#### We use paper environment for this example ####\n",
    "paper = True  # Please do not modify this. This example is for paper trading only.\n",
    "####\n",
    "\n",
    "# Below are the variables for development this documents\n",
    "# Please do not change these variables\n",
    "\n",
    "trade_api_url = None"
   ],
   "id": "4ec3fa9be63ec8be",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "import os\n",
    "\n",
    "if api_key is None:\n",
    "    api_key = os.environ.get('ALPACA_API_KEY')\n",
    "\n",
    "if secret_key is None:\n",
    "    secret_key = os.environ.get('ALPACA_SECRET_KEY')"
   ],
   "id": "a95d813baede59e4",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# install alpaca-py if it is not available\n",
    "try:\n",
    "    import alpaca\n",
    "except ImportError:\n",
    "    !python3 -m pip install alpaca-py\n",
    "    import alpaca"
   ],
   "id": "3edec8c032b75388",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "\n",
    "from datetime import datetime, timedelta\n",
    "from zoneinfo import ZoneInfo\n",
    "import calendar\n",
    "\n",
    "from alpaca.trading.client import TradingClient\n",
    "\n",
    "from alpaca.trading.requests import (\n",
    "    GetOptionContractsRequest,\n",
    "    MarketOrderRequest,\n",
    "    OptionLegRequest,\n",
    "    ReplaceOrderRequest,\n",
    "    LimitOrderRequest,\n",
    ")\n",
    "from alpaca.trading.enums import (\n",
    "    AssetStatus,\n",
    "    ExerciseStyle,\n",
    "    OrderSide,\n",
    "    OrderStatus,\n",
    "    TimeInForce,\n",
    "    OrderClass,\n",
    "    ContractType\n",
    ")\n",
    "from alpaca.common.exceptions import APIError"
   ],
   "id": "8537217fbfb2d777",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## Trading Client",
   "id": "8d19088b41288688"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# setup client\n",
    "trade_client = TradingClient(api_key=api_key, secret_key=secret_key, paper=paper, url_override=trade_api_url)"
   ],
   "id": "cf259f6b53acffe2",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# First, let us see if the account is enabled for multi-leg options trading\n",
    "acct = trade_client.get_account()\n",
    "if acct.options_trading_level >= 3:\n",
    "    print(\"Account is enabled for multi-leg options trading!\")\n",
    "else:\n",
    "    print(\"Account is not enabled for multi-leg options trading!\")"
   ],
   "id": "321926acf817f87e",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "### The Straddle\n",
    "\n",
    "A straddle is an options strategy that involves buying both a call and a put option with the same strike price and expiration date. This is typically done when the trader expects a large price movement but is unsure of the direction. That is to say, the trader will profit if the price moves significantly in either direction from the strike price. By using a multi-leg order, rather than place two separate orders, the trader can ensure that both legs\n",
    "of the order are executed simultaneously."
   ],
   "id": "23e5cccd91409d73"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Let us find the earnings date for TSLA closest to today\n",
    "# Typically these occur OCT, JAN, APR, or JUL around the middle of the 3rd week of the month\n",
    "\n",
    "\n",
    "today = datetime.now(tz=ZoneInfo(\"America/New_York\"))\n",
    "\n",
    "earnings_month = None\n",
    "earnings_day = None\n",
    "earnings_year = today.year\n",
    "\n",
    "# find next earnings date month\n",
    "if today.month < 4:\n",
    "    earnings_month = 4\n",
    "elif today.month < 7:\n",
    "    earnings_month = 7\n",
    "elif today.month < 10:\n",
    "    earnings_month = 10\n",
    "else:\n",
    "    earnings_year += 1\n",
    "    earnings_month = 1\n",
    "\n",
    "# find wednesday of the 3rd week of the month\n",
    "earnings_day = calendar.monthcalendar(earnings_year, earnings_month)[-2][calendar.WEDNESDAY]\n",
    "\n",
    "earnings_date = datetime(earnings_year, earnings_month, earnings_day)\n",
    "\n",
    "earnings_date"
   ],
   "id": "1b7cfa90b85495f9",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# This is a function that will return a contract which minimizes the difference from a target price\n",
    "def find_nearest_strike_contract(contracts, target_price):\n",
    "    min_diff = 0\n",
    "    min_contract = None\n",
    "    for contract in contracts:\n",
    "        diff = abs(float(contract.strike_price) - target_price)\n",
    "        if min_contract is None or diff < min_diff:\n",
    "            min_diff = diff\n",
    "            min_contract = contract\n",
    "    return min_contract"
   ],
   "id": "15c5b3f0e3600865",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Let us find a call and put option for TSLA with the closest expiration date to the earnings date\n",
    "# and a strike price closest to some price\n",
    "order_legs = []\n",
    "optimal_price = 413.82  # this could be our entry price, for example, that we wish to hedge against (if we expect volatility)\n",
    "\n",
    "for c_type in [ContractType.CALL, ContractType.PUT]:\n",
    "    req = GetOptionContractsRequest(\n",
    "        underlying_symbols=[\"TSLA\"],\n",
    "        status=AssetStatus.ACTIVE,\n",
    "        expiration_date_gte=earnings_date,\n",
    "        expiration_date_lte=earnings_date + timedelta(weeks=4),\n",
    "        style=ExerciseStyle.AMERICAN,\n",
    "        strike_price_gte=str(optimal_price - 20),\n",
    "        strike_price_lte=str(optimal_price + 20),\n",
    "        limit=10,\n",
    "        type=c_type,  # We could do this in one request, without setting type, if we set up the\n",
    "        # gte, lte, and limit strategically (but the current approach is a bit more generalizable).\n",
    "        # See the next example for how to do this.\n",
    "        page_token=None,\n",
    "    )\n",
    "    cts = trade_client.get_option_contracts(req)\n",
    "\n",
    "    c = find_nearest_strike_contract(cts.option_contracts, optimal_price)\n",
    "    order_legs.append(OptionLegRequest(\n",
    "        symbol=c.symbol,\n",
    "        side=OrderSide.BUY,\n",
    "        ratio_qty=1\n",
    "    ))\n",
    "\n",
    "# We should see that the symbols are similar, like \"TSLA______C________\" and \"TSLA______P________\",\n",
    "# with all values marked as \"_\" being the same in both symbols.\n",
    "# Such is because we expect only the contract type (call or put, C or P) to be different.\n",
    "order_legs"
   ],
   "id": "c5d3eef0fcabc15e",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Now we place the order for both legs at the same time\n",
    "req = MarketOrderRequest(\n",
    "    qty=1,\n",
    "    order_class=OrderClass.MLEG,\n",
    "    time_in_force=TimeInForce.DAY,\n",
    "    legs=order_legs\n",
    ")\n",
    "res = trade_client.submit_order(req)\n",
    "res"
   ],
   "id": "c0597fc0c1f6098f",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Note that we can query via order ids or client order ids for the whole order or individual legs\n",
    "\n",
    "# Query by the order's client id\n",
    "q1 = trade_client.get_order_by_client_id(res.client_order_id)\n",
    "\n",
    "# Query by the whole order's id\n",
    "q2 = trade_client.get_order_by_id(res.id)\n",
    "\n",
    "# Query just the first leg's client id\n",
    "q3 = trade_client.get_order_by_client_id(res.legs[0].client_order_id)\n",
    "\n",
    "# Query by first leg's id\n",
    "q4 = trade_client.get_order_by_id(res.legs[0].id)\n",
    "\n",
    "print(f\"Q1: {q1}\\n===\\nQ2: {q2}\\n===\\nQ3: {q3}\\n===\\nQ4: {q4}\")"
   ],
   "id": "626f69b5d3a81150",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "### The Iron Condor\n",
    "\n",
    "This is traditionally harder to implement because it requires 4 legs. However, with multi-leg orders, Alpaca makes doing this a breeze! Moreover, we can use a limit order on the multi-leg order to better time our entry (which is much more important with an iron condor than with a straddle).\n",
    "\n",
    "This time we are considering 4 separate strike prices: A, B, C, and D. We buy a put at A, sell a put at B, sell a call at C, and buy a call at D. A trader expects the price to stay within the range of B and C and will typically enter only once the price is between B and C. Using a limit order, we execute the order when the *net* price is 0 or better.\n",
    "\n"
   ],
   "id": "42bb8487b4414977"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# At the time of writing, TSLA has a standard deviation (a common measure of variation for the price) of 5.02 and a price of 413.82\n",
    "# Let's create a interval around the current price such that B and C are a standard deviation away from each other\n",
    "\n",
    "stddev = 5.02\n",
    "B = optimal_price - (stddev / 2)\n",
    "C = optimal_price + (stddev / 2)\n",
    "A = B - stddev\n",
    "D = C + stddev\n",
    "\n",
    "print(f\"A: {A}, B: {B}, C: {C}, D: {D}\")"
   ],
   "id": "88d3d516e5e20270",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Now, instead of doing two separate requests, we can do one request to get all the contracts we need\n",
    "# We set this up by setting the gte, lte, and limit strategically\n",
    "# That being said, it is still safest to do separate requests as we did in the prior example as the number of contracts\n",
    "# returned can vary based on the strike prices and expiration dates (which are not fixed in this notebook).\n",
    "\n",
    "# Let's find the delta between strike prices from our prior example\n",
    "max_delta = 0\n",
    "for i in range(len(cts.option_contracts) - 1):\n",
    "    delta = abs(float(cts.option_contracts[i].strike_price) - float(cts.option_contracts[i + 1].strike_price))\n",
    "    if delta > max_delta:\n",
    "        max_delta = delta\n",
    "\n",
    "\n",
    "def next_divisible(n: float, div: float, round_up: bool):\n",
    "    if n % div == 0:\n",
    "        return n\n",
    "    if round_up:\n",
    "        return n + div - n % div\n",
    "    return n - n % div\n",
    "\n",
    "\n",
    "min_contract_price = next_divisible(A, max_delta, False)\n",
    "max_contract_price = next_divisible(D, max_delta, True)\n",
    "print(f\"Min: {min_contract_price}, Max: {max_contract_price}\")"
   ],
   "id": "700d60b9b3968156",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Now the actual request\n",
    "req = GetOptionContractsRequest(\n",
    "    underlying_symbols=[\"TSLA\"],\n",
    "    status=AssetStatus.ACTIVE,\n",
    "    expiration_date_gte=cts.option_contracts[0].expiration_date - timedelta(weeks=5),\n",
    "    expiration_date_lte=cts.option_contracts[0].expiration_date - timedelta(weeks=3),\n",
    "    style=ExerciseStyle.AMERICAN,\n",
    "    strike_price_gte=str(min_contract_price),\n",
    "    strike_price_lte=str(max_contract_price),\n",
    "    page_token=None,\n",
    ")\n",
    "cts_m = trade_client.get_option_contracts(req)\n",
    "cts_m"
   ],
   "id": "4e477db0a6bc1748",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# This finds contracts which minimizes the difference from a set of target prices\n",
    "class ContractBuffer:\n",
    "    def __init__(self, optimal, is_call, is_buy):\n",
    "        self.optimal = optimal\n",
    "        self.is_call = is_call\n",
    "        self.is_buy = is_buy\n",
    "        self.contract = None\n",
    "        self.diff = 0\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Contract: {self.contract}, Optimal: {self.optimal}, Diff: {self.diff}, Is Call: {self.is_call}\"\n",
    "\n",
    "\n",
    "buffers = [ContractBuffer(A, False, True), ContractBuffer(B, False, False), ContractBuffer(C, True, False),\n",
    "           ContractBuffer(D, True, True)]\n",
    "\n",
    "for contract in cts_m.option_contracts:\n",
    "    for buff in buffers:\n",
    "        is_call = contract.type == ContractType.CALL\n",
    "        if buff.is_call != is_call:\n",
    "            continue\n",
    "        diff = abs(float(contract.strike_price) - buff.optimal)\n",
    "        if diff < buff.diff or buff.contract is None:\n",
    "            buff.diff = diff\n",
    "            buff.contract = contract\n",
    "\n",
    "order_legs_m = []\n",
    "for buff in buffers:\n",
    "    order_legs_m.append(OptionLegRequest(\n",
    "        symbol=buff.contract.symbol,\n",
    "        side=OrderSide.BUY if buff.is_buy else OrderSide.SELL,\n",
    "        ratio_qty=1\n",
    "    ))\n",
    "\n",
    "del buffers\n",
    "order_legs_m"
   ],
   "id": "c4d6a9949d7fed",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Order for the iron condor\n",
    "req = LimitOrderRequest(\n",
    "    qty=50,\n",
    "    order_class=OrderClass.MLEG,\n",
    "    time_in_force=TimeInForce.DAY,\n",
    "    legs=order_legs_m,\n",
    "    limit_price=0  # i.e., for a net price of 0\n",
    ")\n",
    "res = trade_client.submit_order(req)\n",
    "res"
   ],
   "id": "d54598897e5d0453",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## Querying, Replacing, and Cancelling Multi-leg Orders",
   "id": "54ca6690fdc6f747"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# We have two resolutions at which we can query the order status: by the mleg's id or by the individual legs' ids.\n",
    "\n",
    "# Query by the order's id\n",
    "q1 = trade_client.get_order_by_client_id(res.client_order_id)\n",
    "\n",
    "# Query just the first leg's id\n",
    "q2 = trade_client.get_order_by_client_id(res.legs[0].client_order_id)\n",
    "\n",
    "print(f\"Query by whole order id: {q1}\\n===\\nQuery by leg id: {q2}\")"
   ],
   "id": "f889a157aaf2ad2e",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Note that we cannot cancel nor replace an individual leg\n",
    "try:\n",
    "    if q1.legs[0].status != OrderStatus.FILLED:\n",
    "        res = trade_client.cancel_order_by_id(res.legs[0].id)\n",
    "        print(f\"Cancelled leg: {res}\")\n",
    "    else:\n",
    "        print(\"Order is already filled.\")\n",
    "except APIError as e:\n",
    "    print(f\"Error: {e}\")\n",
    "\n",
    "try:\n",
    "    if q1.status != OrderStatus.FILLED:\n",
    "        req = ReplaceOrderRequest(\n",
    "            qty=1\n",
    "        )\n",
    "        res = trade_client.replace_order_by_id(res.legs[0].id, req)\n",
    "        print(f\"Replaced order: {res}\")\n",
    "    else:\n",
    "        print(\"Order is already filled.\")\n",
    "except APIError as e:\n",
    "    print(f\"Error: {e}\")\n",
    "\n",
    "# Should get an output of form\n",
    "# Error: {\"code\":42210000,\"message\":\"cannot cancel individual legs of a mleg order\"}\n",
    "# Error: {\"code\":42210000,\"message\":\"cannot replace individual legs of a mleg order\"}"
   ],
   "id": "e3ca89c326f2b541",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Replace overall order\n",
    "if q1.status != OrderStatus.FILLED:\n",
    "    # We can replace the order\n",
    "    req = ReplaceOrderRequest(\n",
    "        qty=55,\n",
    "    )\n",
    "    res = trade_client.replace_order_by_id(res.id, req)\n",
    "    print(f\"Replaced order: {res}\")\n",
    "else:\n",
    "    print(\"Order is already filled.\")"
   ],
   "id": "34df30f717d2683a",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# Cancel the whole order\n",
    "trade_client.cancel_order_by_id(res.id)"
   ],
   "id": "8cc9815f84b7b49",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {},
   "cell_type": "code",
   "source": [
    "# To validate, we can query the order again\n",
    "res = trade_client.get_order_by_client_id(res.client_order_id)\n",
    "res"
   ],
   "id": "cefb7d7785ba13ad",
   "outputs": [],
   "execution_count": null
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}