How to Calculate Expected Move Before Earnings Using Implied Volatility

Before an earnings report, the options market puts a price on how far the stock might move. That price is the expected move. You can read it off the options chain in a few steps, and it gives you a range to compare against your own view, your position size and your strikes. This guide shows two ways to calculate it, how to find the report date on Mboum, and how to pull the same numbers as JSON.

Step 1: find the report date and timing

Open the Upcoming Earnings page. It lists scheduled reports in date order with the report date, the time (Before Open or After Close), the EPS estimate, the last reported EPS and the last surprise. The Report Date filter has presets such as Today, Tomorrow and Next week, and a Listed Options filter keeps the list to stocks that have options, which you need for this method. Dates can change until a company confirms them, so check again close to the report.

The timing decides which expiration to use. A stock that reports before the open reacts that same day. A stock that reports after the close reacts the next session.

Step 2: pick the expiration

Choose the first expiration on or after the day the stock reacts. A Wednesday after-close report reacts on Thursday, so a Friday weekly expiration works. Use the nearest one. A longer-dated option also prices in weeks of ordinary movement, which blurs the earnings number.

Step 3: add up the at-the-money straddle

The at-the-money straddle is the call and the put at the strike closest to the stock price. Add their midpoints (halfway between bid and ask). The sum is what the market charges for a move in either direction, so it is a common read on the expected move.

Worked example, with made-up numbers for a stock called XYZ:

  • XYZ trades at $100.40. The nearest strike is $100.
  • The $100 call midpoint is $3.10 and the $100 put midpoint is $2.90.
  • Straddle = $3.10 + $2.90 = $6.00, or 6.0% of the stock price.
  • Expected range: about $94.40 to $106.40.

Check the bid-ask spread first. On a thinly traded option the midpoint can be far from a price anyone would trade at.

Step 4: cross-check with implied volatility

The second method uses implied volatility (IV), the annualized volatility the option prices imply. One standard deviation of movement over the life of the option is:

stock price × IV × √(days to expiration ÷ 365)

With the same stock, an average IV of 60% and 5 days to expiration: 100.40 × 0.60 × √(5 ÷ 365) is about $7.05, or 7.0%.

The two numbers differ by definition. For an at-the-money option, the straddle is roughly 0.8 times the one-standard-deviation move. That is why $6.00 sits below $7.05. Use the straddle as the typical move and the IV figure as a wider band, and stay consistent so you can compare stocks.

Step 5: compare IV with 30-day historical volatility

Implied volatility tells you what the market expects. Thirty-day historical volatility tells you how much the stock has actually moved recently. If IV is 60% and 30-day historical volatility is 35%, options cost about 1.7 times what recent movement would justify. Much of that gap can be the earnings event itself. Also check the Implied Volatility Rank page to see whether the current IV is high or low against the past year.

The Upcoming Earnings page shows EPS surprises, not price reactions, so it can't tell you how big past moves were. Keep your own log of each report's expected move against what happened, and you will learn how a given stock tends to behave.

Get this as JSON

Three Mboum endpoints cover the inputs. GET https://api.mboum.com/v2/markets/calendar/earnings with a ticker returns the next report date, the report timing and the last price (docs). GET https://api.mboum.com/v3/markets/options takes a ticker and an optional expiration in YYYY-MM-DD, and returns the chain with meta.expirations (docs). Each of those calls has weight 2. This script calls the chain twice, once for the expiration list and once for the chosen date, so one run costs 6.

import math
from datetime import datetime, timedelta

import requests

BASE = "https://api.mboum.com"
HEADERS = {"Authorization": "Bearer YOUR_MBOUM_API_KEY"}


def num(value):
    return float(str(value).replace(",", "").replace("$", "").replace("%", "").replace("+", ""))


def get(path, **params):
    resp = requests.get(BASE + path, headers=HEADERS, params=params, timeout=30)
    data = resp.json()
    if resp.status_code != 200 or not data.get("body"):
        raise SystemExit(f"{path} failed: {str(data)[:150]}")
    return data


def reaction_day(report, time_code):
    day = report
    if "after" in time_code.lower():  # after the close, the stock reacts next session
        day += timedelta(days=1)
    while day.weekday() >= 5:  # skip weekends
        day += timedelta(days=1)
    return day


def expected_move(ticker):
    # 1. Next report date, timing and last price
    row = get("/v2/markets/calendar/earnings", ticker=ticker)["body"][0]
    report = datetime.strptime(row["nextEarningsDate"], "%m/%d/%y").date()
    spot = num(row["lastPrice"])
    react = reaction_day(report, row["timeCode"])

    # 2. First listed expiration on or after the reaction day
    groups = get("/v3/markets/options", ticker=ticker)["meta"]["expirations"]
    dates = sorted(d for group in groups.values() for d in group)
    expiry = next((d for d in dates if d >= react.isoformat()), None)
    if not expiry:
        raise SystemExit("No expiration after the report date")

    # 3. At-the-money straddle for that expiration
    chain = get("/v3/markets/options", ticker=ticker, expiration=expiry)["body"]
    call = min(chain["Call"], key=lambda c: abs(num(c["strikePrice"]) - spot))
    put = next(p for p in chain["Put"] if p["strikePrice"] == call["strikePrice"])
    straddle = num(call["midpoint"]) + num(put["midpoint"])

    # 4. Move implied by volatility, and 30-day historical volatility
    iv = num(call["averageVolatility"]) / 100
    dte = num(call["daysToExpiration"])
    iv_move = spot * iv * math.sqrt(dte / 365)
    hv = num(call["historicVolatility30d"])

    print(f"{ticker} reports {report} ({row['timeCode']}); expiration {expiry}, {dte:.0f} days")
    print(f"Last {spot:.2f}, at-the-money strike {call['strikePrice']}")
    print(f"Straddle move: ${straddle:.2f} ({straddle / spot:.1%}), "
          f"range {spot - straddle:.2f} to {spot + straddle:.2f}")
    print(f"IV move (1 sigma): ${iv_move:.2f} ({iv_move / spot:.1%})")
    print(f"Average IV {iv:.1%} vs 30-day HV {hv:.1f}%: {iv * 100 / hv:.1f}x")


if __name__ == "__main__":
    expected_move("AAPL")

The script uses averageVolatility, the average implied volatility of the calls and puts just above and below the stock price, and historicVolatility30d. Both come back on every chain row, as does baseNextEarningsDate. Here is a trimmed row from the docs example, with the fields used above:

{
  "strikePrice": "590.00",
  "expirationDate": "05/30/25",
  "bidPrice": "4.96",
  "midpoint": "4.97",
  "askPrice": "4.98",
  "volatility": "20.08%",
  "daysToExpiration": "3",
  "averageVolatility": "18.63%",
  "historicVolatility30d": "19.69%",
  "baseNextEarningsDate": "N/A",
  "impliedVolatilityRank1y": "17.80%"
}

Best practices

  • Check the body. Some failures return HTTP 200 with a message and no body. The script exits when body is empty. ETFs and stocks without a scheduled report have no earnings date to find.
  • Parse the strings. Prices and percentages arrive as text such as "3,042.74" and "18.63%". The num() helper strips the formatting.
  • Mind the rate limit. The limit is 10 requests per second, and going over returns HTTP 429. Only HTTP 200 responses count toward weight. For a watchlist, add a short pause between tickers.
  • Treat the result as a range, not a forecast. The expected move is where the market prices the typical outcome. A stock can move past it in either direction, so size positions with that in mind.

Next steps

Run the script for each name on your earnings watchlist the day before the report, and log the result next to the actual move. This is for education, not investment advice.

Claim your free API key and see the Mboum docs for Python, PHP, JavaScript and Bash samples.