Options

The Options module calculates important options metrics including First, Second and Third Order Greeks, the Black-Scholes Model, Option Chains, Implied Volatilities, Breeden–Litzenberger and more.

To install the FinanceToolkit it simply requires the following:

pip install financetoolkit -U

get_option_chains

Get the Option Chains which gives information about the currently available options as reported by Yahoo Finance. This returns the Contract Symbol, Strike Currency, Last Price, Absolute Change, Percent Change, Volume, Open Interest, Bid Pirce, Ask Price, Expiration, Last Trade Date, Implied Volatility and whether the option is In The Money.

The data comes from Yahoo Finance and is not always available. If the data is not available, it is advised to use the theoretical calculations as provided by the Black Scholes Model as well as the Greeks to get a better understanding of the option prices over time.

Also known as: calls, puts, strike prices, expiry dates, option data.

Args:

• expiration_date (str \| None, optional): The expiration date to use. Defaults to None which means it will use the first available expiration date.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.

Returns:

pd.DataFrame: the option chains containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "TSLA"], api_key="FINANCIAL_MODELING_PREP_KEY")

option_chains = toolkit.options.get_option_chains()

option_chains.loc[('AAPL', option_chains['In The Money'] == True), :]

Which returns:

get_black_scholes_model

Calculate the Black Scholes Model, a mathematical model used to estimate the price of European-style options.

The Black Scholes Model is a mathematical model used to estimate the price of European-style options. It is widely used by traders and investors to determine the theoretical value of an option, and to assess the potential risks and rewards of a position.

Within Risk Management, defining the theoretical value of an option is important to assess the potential risk and rewards of an option position. A position that could be used to hedge a portfolio, for example, is a long put option. The theoretical value of this option can be used to determine the potential risk and rewards of this position.

The Black Scholes Model is based on several assumptions, including the following:

• The option is European and can only be exercised at expiration.
• The underlying stock follows a lognormal distribution.
• The risk-free rate and volatility of the underlying stock are known and constant.
• The returns on the underlying stock are normally distributed.

By default the most recent risk free rate, dividend yield and stock price is used, you can alter this by changing the start date. The volatility is calculated based on the daily returns of the stock price and the selected period (this can be altered by defining this accordingly when defining the Toolkit class, start_date and end_date).

The formulas are as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration, N(d1) is the cumulative normal distribution of d1 and N(d2) is the the cumulative normal distribution of d2.

Also known as: BSM, Black-Scholes-Merton, option pricing model.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• put_option (bool, optional): Whether to calculate the put option price. Defaults to False which means it will calculate the call option price.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the dividend yield as obtained through annual historical data.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: Black Scholes values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AMZN", "AAPL"], api_key="FINANCIAL_MODELING_PREP_KEY")

black_scholes = toolkit.options.get_black_scholes_model()

black_scholes.loc['AMZN']

Which returns:

get_implied_volatility

Calculate the Implied Volatility (IV) based on the Black Scholes Model and the actual option prices for any of the available expiration dates.

Implied Volatility (IV) is a measure of how much the market expects the price of the underlying asset to fluctuate in the future. It is a key component of options pricing and can also be used to calculate the theoretical value of an option.

By default the most recent risk free rate, dividend yield and stock price is used, you can alter this by changing the start date. The volatility is calculated based on the daily returns of the stock price and the selected period (this can be altered by defining this accordingly when defining the Toolkit class, start_date and end_date).

The formulas are as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration, N(d1) is the cumulative normal distribution of d1 and N(d2) is the the cumulative normal distribution of d2.

In which the Implied Volatility is then calculated as follows:

To determine the Implied Volatility, the Black Scholes Model is used to calculate the theoretical option price in which sigma (σ) is the only unknown variable. The actual option price is then used to determine the implied volatility by minimizing the difference between the theoretical and actual option price.

Also known as: IV, option-implied volatility.

Args:

• expiration_date (str \| None, optional): The expiration date to use for the calculation. Defaults to None which means it will use the most recent expiration date.
• put_option (bool, optional): Whether to calculate the put option price. Defaults to False which means it will calculate the call option price.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the dividend yield as obtained through annual historical data.
• show_expiration_dates (bool, optional): Whether to show the expiration dates. Defaults to False.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.Series | list[str]: Implied Volatility values containing the tickers as the index and the expiration dates as the columns. If show_expiration_dates is True, it will return a list of expiration dates.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["MSFT", "AAPL"], api_key="FINANCIAL_MODELING_PREP_KEY")

implied_volatility = toolkit.options.get_implied_volatility()

implied_volatility.loc['AAPL']

Which returns:

get_volatility_surface

Calibrate an arbitrage-checked implied volatility surface across multiple expiries, by fitting a raw SVI (Stochastic Volatility Inspired, Gatheral 2004) curve to the market-implied smile (see get_implied_volatility) at each expiry, and checking the fitted surface for calendar-spread arbitrage.

A single per-expiry smile only tells you the shape of the market’s volatility skew at that one maturity. Stitching several calibrated SVI slices together instead gives a full surface, which is what is needed to price/interpolate options at maturities or strikes that don’t trade directly, and to check for term-structure inconsistencies (see Notes).

Before fitting, strikes whose market-implied volatility is a statistical outlier relative to its neighbors (a common symptom of a stale or wide-bid/ask illiquid quote) are dropped via a median-absolute-deviation filter, since a single bad quote can otherwise dominate the least-squares SVI fit for that whole expiry.

See: Gatheral, J. (2004), “A parsimonious arbitrage-free implied volatility parameterization with application to the valuation of volatility derivatives”, and Gatheral, J., & Jacquier, A. (2014), “Arbitrage-free SVI volatility surfaces”, Quantitative Finance, 14(1), 59-71.

Also known as: SVI surface, implied volatility surface.

Notes: A warning is logged (not raised) if the fitted surface has any calendar-spread arbitrage violations, i.e. total implied variance decreasing with time to expiration at some log-moneyness – this reflects genuine inconsistency in the underlying market quotes across expiries, not a fitting error, and is only checked, not corrected.

Args:

• expiration_dates (list[str] \| None, optional): The expiration dates to fit the surface over. Defaults to None, meaning the first number_of_expirations available expiration dates.
• put_option (bool, optional): Whether to use put options instead of call options. Defaults to False.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the dividend yield as obtained through annual historical data.
• number_of_expirations (int, optional): The number of near-term expiration dates to fit when expiration_dates is not given. Defaults to 6.
• outlier_threshold (float, optional): The number of median absolute deviations from the median implied volatility beyond which a quote is treated as an outlier and dropped before fitting. Defaults to 5.0.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Returns:

pd.DataFrame: The SVI-fitted implied volatility, indexed by (ticker, strike price), with one column per expiration date. NaN where a given strike wasn’t part of that expiry’s calibration.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL"], api_key="FINANCIAL_MODELING_PREP_KEY")

volatility_surface = toolkit.options.get_volatility_surface(number_of_expirations=3)

volatility_surface.loc["AAPL"]

Which returns:

get_risk_neutral_density

Extract the market-implied risk-neutral probability density of the underlying’s price at expiration, via the Breeden-Litzenberger (1978) theorem, applied to a volatility smile calibrated to real market option prices (see get_implied_volatility) rather than a single flat assumed volatility.

get_partial_derivative computes the same second-derivative relationship but with one flat volatility value applied at every strike – with a flat volatility input, the second derivative can only ever recover a lognormal density regardless of what the real market smile looks like, which defeats the entire purpose of the theorem. This method instead first calibrates a raw SVI (Gatheral 2004) curve to the actual market smile (see get_volatility_surface) and evaluates the density from that.

The formula is as follows:

Where C(K) is the Black-Scholes call price at strike K, using the SVI-smoothed implied volatility at that strike, r is the risk-free rate and t is the time to expiration. The second derivative is approximated numerically via a central finite difference on a fine, evenly-spaced strike grid, since the smile only gives implied volatility at a sparse set of traded strikes.

See the paper: Breeden, D.T., & Litzenberger, R.H. (1978), “Prices of State-Contingent Claims Implicit in Option Prices”, Journal of Business, 51(4), 621-651. https://www.jstor.org/stable/2352653

Also known as: Breeden-Litzenberger, implied risk-neutral distribution.

Notes: A warning is logged (not raised) for any ticker whose density goes negative at some strike – this indicates a butterfly-arbitrage violation (the call price is not convex in the strike) in the underlying market quotes or the SVI fit, which a well-calibrated, liquid smile should not produce.

Args:

• expiration_date (str \| None, optional): The expiration date to use. Defaults to None which means it will use the first available expiration date.
• put_option (bool, optional): Whether to use put options instead of call options. Defaults to False.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the dividend yield as obtained through annual historical data.
• strike_price_range (float, optional): The range of strikes to evaluate the density over, as a fraction of the forward price in each direction. Defaults to 0.5, i.e. from 50% to 150% of the forward price.
• number_of_strikes (int, optional): The number of strikes in the evaluation grid. Defaults to 200.
• outlier_threshold (float, optional): The number of median absolute deviations from the median implied volatility beyond which a quote is treated as an outlier and dropped before fitting. Defaults to 5.0.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to None.

Raises:

ValueError: If no implied volatility could be determined for the given expiration date.

Returns:

pd.DataFrame: The risk-neutral probability density, indexed by strike price, with one column per ticker.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL"], api_key="FINANCIAL_MODELING_PREP_KEY")

risk_neutral_density = toolkit.options.get_risk_neutral_density()

Which returns:

get_binomial_model

Calculate the Binomial Option Pricing Model, a mathematical model used to estimate the price of European and American style options. It does so by creating a binomial tree of price paths for the underlying asset, and then working backwards through the tree to determine the price of the option at each node.

By default the most recent risk free rate, dividend yield and stock price is used, you can alter this by changing the start date. The volatility is calculated based on the daily returns of the stock price and the selected period (this can be altered by defining this accordingly when defining the Toolkit class, start_date and end_date).

The formulas are as follows:

For European Style options:

For American Style options:

Where S is the stock price, K is the strike price, r is the risk free rate, σ is the volatility, t is the time to expiration, j is the number of up movements, n is the number of time steps, C_u is the call option price at the up movement, C_d is the call option price at the down movement, P_u is the put option price at the up movement and P_d is the put option price at the down movement.

The resulting output is a DataFrame containing the tickers, strike prices and movements as the index and the time to expiration as the columns. The movements index contains the number of up movements and the number of down movements. The output is the binomial tree displayed in a table. E.g. when using 10 time steps, the table for each strike price from each company will contain the actual binomial tree as also depicted in the image found here: https://en.wikipedia.org/wiki/Binomial_options_pricing_model#Method

Also known as: binomial tree, lattice model, option pricing.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• put_option (bool, optional): Whether to calculate the put option price. Defaults to False which means it will calculate the call option price.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• time_to_expiration (int): The number of year to use for the time to expiration. Defaults to 1 which equals one year.
• timesteps (int): The number of time steps to use for the binomial tree. Defaults to 10 which equals 10 time steps. This will be evenly distributed over the time to expiration.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the dividend yield as obtained through annual historical data.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: Binomial Trees values containing the tickers, strike prices and movements as the index and the timesteps as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "MSFT"], api_key="FINANCIAL_MODELING_PREP_KEY")

binomial_trees_model = toolkit.options.get_binomial_trees_model(
    start_date='2024-02-02'
)

binomial_trees_model.loc['AAPL', 140]

Which returns:

get_stock_price_simulation

Simulate the Stock Price based on the Binomial Model, a mathematical model used to estimate the price of European and American style options. It does so by creating a binomial tree of price paths for the underlying asset based on the stock price, volatility, risk free rate, dividend yield and time to expiration. The stock price is then simulated based on the up and down movements.

By default the most recent risk free rate and stock price is used, you can alter this by changing the start date. The volatility is calculated based on the daily returns of the stock price and the selected period (this can be altered by defining this accordingly when defining the Toolkit class, start_date and end_date).

The formulas are as follows:

Where S is the stock price, r is the risk free rate, σ is the volatility, t is the time to expiration, j is the number of up movements, n is the number of time steps.

The resulting output is a DataFrame containing the tickers and movements as the index and the time to expiration as the columns. The movements index contains the number of up movements and the number of down movements. The output is the binomial tree displayed in a table. E.g. when using 10 time steps, the table from each company will contain the actual binomial tree’s stock prices as also depicted in the image found here: https://en.wikipedia.org/wiki/Binomial_options_pricing_model#Method

Hint: consider plotting the resulting DataFrame for each company to visualize the binomial tree. For example for below’s example use stock_price_simulation.loc['AMZN'].T.plot(legend=False)

Also known as: Monte Carlo simulation, GBM, stock price path.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• time_to_expiration (int): The number of year to use for the time to expiration. Defaults to 1 which equals one year.
• timesteps (int): The number of time steps to use for the binomial tree. Defaults to 10 which equals 10 time steps. This will be evenly distributed over the time to expiration.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• show_unique_combinations (bool, optional): Whether to show the unique combinations of the stock prices. Defaults to False.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: Simulated Stock Price values containing the tickers and movements as the index and the timesteps as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AMZN", "ASML"], api_key=API_KEY)

stock_price_simulation = toolkit.options.get_stock_price_simulation(
    start_date='2020-06-22', timesteps=4
)

stock_price_simulation.loc['AMZN']

Which returns:

get_put_call_parity

Calculate the Put-Call Parity gap, the amount by which Black-Scholes call and put prices deviate from the no-arbitrage relationship between them.

Put-Call Parity states that, for European options sharing the same strike price and time to expiration, the following relationship must hold in order to prevent arbitrage:

Where C is the call option price, P is the put option price, S is the stock price, K is the strike price, r is the risk-free rate, q is the dividend yield and t is the time to expiration.

This method computes the Black-Scholes call and put price for each ticker, strike price and time to expiration and then calculates the parity gap, i.e. the amount by which (C - P) deviates from S * e^(-qt) - K * e^(-rt). Because both prices come from the same Black-Scholes model and inputs, the gap is (up to floating point precision) always zero - this is a useful diagnostic to confirm that a set of option prices is internally consistent, or, when plugging in externally observed call and put prices, to detect potential arbitrage.

Also known as: Put-Call Parity, PCP, the no-arbitrage relationship between calls and puts.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the dividend yield as obtained through annual historical data.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: The Put-Call Parity gap containing the tickers and strike prices as the index and the time to expiration as the columns. Values should be (approximately) zero.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AMZN", "AAPL"], api_key="FINANCIAL_MODELING_PREP_KEY")

parity_gap = toolkit.options.get_put_call_parity()

parity_gap.loc['AMZN']

get_garman_kohlhagen

Calculate the Garman-Kohlhagen Model, a variant of the Black-Scholes model used to price European-style options on foreign exchange (FX) rates.

Because holding foreign currency earns the foreign risk-free rate (analogous to a continuous dividend yield on a stock), the Garman-Kohlhagen model uses the foreign risk-free rate in place of the dividend yield used in the standard Black-Scholes model.

The formulas are as follows:

Where S is the spot exchange rate, K is the strike price, r is the domestic risk-free rate, r_f is the foreign risk-free rate, σ is the volatility, t is the time to expiration, N(d1) is the cumulative normal distribution of d1 and N(d2) is the cumulative normal distribution of d2.

Also known as: the Black-Scholes model for currency options, FX option pricing model.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• put_option (bool, optional): Whether to calculate the put option price. Defaults to False which means it will calculate the call option price.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The domestic risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• foreign_risk_free_rate (float, optional): The foreign risk free rate to use for the calculation, which plays the role of the dividend yield in the standard Black-Scholes model. Defaults to 0.0.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: Garman-Kohlhagen values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AMZN", "AAPL"], api_key="FINANCIAL_MODELING_PREP_KEY")

garman_kohlhagen = toolkit.options.get_garman_kohlhagen(foreign_risk_free_rate=0.02)

garman_kohlhagen.loc['AMZN']

get_binary_option

Calculate the price of a Binary (Digital) Option using the Black-Scholes framework.

A binary option pays out a fixed amount if the option expires in-the-money and nothing otherwise. Two variants are supported through the option_type parameter:

• “cash-or-nothing”: pays a fixed cash amount if the option expires in-the-money.
• Call = cash_payout * e^(-r * t) * N(d2)
• Put = cash_payout * e^(-r * t) * N(-d2)
• “asset-or-nothing”: pays the value of the underlying asset if the option expires in-the-money.
• Call = S * e^(-q * t) * N(d1)
• Put = S * e^(-q * t) * N(-d1)

Where S is the stock price, r is the risk-free rate, q is the dividend yield, t is the time to expiration, N(d1) is the cumulative normal distribution of d1 and N(d2) is the cumulative normal distribution of d2.

Also known as: digital option, all-or-nothing option, cash-or-nothing option, asset-or-nothing option.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• put_option (bool, optional): Whether to calculate the put option price. Defaults to False which means it will calculate the call option price.
• option_type (str, optional): Either “cash-or-nothing” or “asset-or-nothing”. Defaults to “cash-or-nothing”.
• cash_payout (float, optional): The fixed cash amount paid out by a cash-or-nothing option when it expires in-the-money. Ignored for asset-or-nothing options. Defaults to 1.0.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the dividend yield as obtained through annual historical data.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: Binary Option values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AMZN", "AAPL"], api_key="FINANCIAL_MODELING_PREP_KEY")

binary_option = toolkit.options.get_binary_option()

binary_option.loc['AMZN']

get_bjerksund_stensland

Calculate American option prices using the Bjerksund-Stensland (1993) closed-form analytical approximation.

Unlike European options, American options can be exercised at any time up to and including expiration, which normally requires a numerical approach such as the Binomial Tree model (see get_binomial_model). The Bjerksund-Stensland model instead derives a closed-form approximation by assuming the early-exercise boundary is a flat trigger price: once the stock price crosses this level, immediate exercise is assumed optimal.

The approximation (call, cost of carry b = r - q smaller than r) is:

• β = (0.5 - b / σ²) + sqrt((b / σ² - 0.5)² + 2r / σ²)
• B∞ = β / (β - 1) * K
• B0 = max(K, r / (r - b) * K)
• h(T) = -(b * T + 2σ√T) * (B0 / (B∞ - B0))
• I = B0 + (B∞ - B0) * (1 - e^h(T))

If S ≥ I, immediate exercise is optimal and the value is S - K. American puts are priced through the put-call transformation AmericanPut(S, K, T, r, b, σ) = AmericanCall(K, S, T, r - b, -b, σ).

Also known as: BS93, Bjerksund-Stensland approximation, American option approximation.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• put_option (bool, optional): Whether to calculate the put option price. Defaults to False which means it will calculate the call option price.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the dividend yield as obtained through annual historical data.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: Bjerksund-Stensland American option values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AMZN", "AAPL"], api_key="FINANCIAL_MODELING_PREP_KEY")

bjerksund_stensland = toolkit.options.get_bjerksund_stensland()

bjerksund_stensland.loc['AMZN']

get_monte_carlo_option_price

Calculate European option prices through Monte Carlo simulation of Geometric Brownian Motion (GBM) stock price paths.

The Monte Carlo method prices an option by simulating a large number of possible future paths for the underlying stock price under the risk-neutral measure, computing the option’s payoff at expiration for each simulated path, and then discounting the average payoff back to the present:

• S(t + Δt) = S(t) * e^((r - q - σ²/2) * Δt + σ * √Δt * Z)
• Call Price = e^(-r * T) * mean(max(S(T) - K, 0))
• Put Price = e^(-r * T) * mean(max(K - S(T), 0))

Where S(t) is the stock price at time t, r is the risk-free rate, q is the dividend yield, σ is the volatility, Δt is the length of a single time step and Z is a standard normal random variable.

As it is a simulation, the result comes with sampling error. Set show_standard_error=True to additionally return the standard error of each estimate - as a rule of thumb, the true price lies within plus or minus 2 times the standard error roughly 95% of the time. A fixed seed is used by default for reproducibility of documentation examples; set it explicitly (or leave it as None) to control this behavior.

Also known as: Monte Carlo option pricing, simulation-based option pricing.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• put_option (bool, optional): Whether to calculate the put option price. Defaults to False which means it will calculate the call option price.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the dividend yield as obtained through annual historical data.
• simulations (int, optional): The number of simulated stock price paths. Defaults to 10,000.
• time_steps (int, optional): The number of time steps used to build each simulated path. Defaults to 100.
• seed (int \| None, optional): The seed used to initialize the random number generator, ensuring reproducible results. Defaults to None, which means the results will not be reproducible.
• show_standard_error (bool, optional): Whether to also return the standard error of each Monte Carlo estimate as a second DataFrame. Defaults to False.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: Monte Carlo option values containing the tickers and strike prices as the index and the time to expiration as the columns. If show_standard_error is True, a tuple of (prices, standard_errors) is returned instead.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AMZN", "AAPL"], api_key="FINANCIAL_MODELING_PREP_KEY")

monte_carlo = toolkit.options.get_monte_carlo_option_price(seed=42)

monte_carlo.loc['AMZN']

get_barrier_option

Calculate the closed-form price of a single-barrier (knock-in or knock-out, up or down) European option using the Reiner & Rubinstein (1991) formulas.

A barrier option is a path-dependent option whose payoff (and existence) depends on whether the underlying stock price touches a pre-specified barrier level at any point before expiration:

• Knock-out: the option becomes worthless if the barrier is touched.
• Knock-in: the option only comes into existence if the barrier is touched.
• Down barrier: the barrier is below the current stock price.
• Up barrier: the barrier is above the current stock price.

The barrier level is defined relative to the current stock price through barrier_percentage, e.g. a value of 0.9 sets the barrier at 90% of the current stock price (a sensible default for a down barrier).

A useful identity is in-out parity: for identical parameters, a knock-in option plus its corresponding knock-out option (same direction) always equals the price of the equivalent vanilla Black-Scholes option, since the underlying either does or does not touch the barrier.

Also known as: knock-in option, knock-out option, down-and-out, down-and-in, up-and-out, up-and-in option.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• put_option (bool, optional): Whether to calculate the put option price. Defaults to False which means it will calculate the call option price.
• barrier_percentage (float, optional): The barrier level as a percentage of the current stock price. Defaults to 0.9 which equals 90% of the current stock price.
• barrier_direction (str, optional): Either “down” or “up”. Defaults to “down”.
• knock_type (str, optional): Either “in” or “out”. Defaults to “out”.
• rebate (float, optional): The fixed cash amount paid out if the option knocks out (or fails to knock in). Defaults to 0.0.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the dividend yield as obtained through annual historical data.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: Barrier option values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AMZN", "AAPL"], api_key="FINANCIAL_MODELING_PREP_KEY")

barrier_option = toolkit.options.get_barrier_option()

barrier_option.loc['AMZN']

get_asian_option

Calculate the closed-form price of a geometric-average Asian option using the Kemna & Vorst (1990) formula.

An Asian option’s payoff depends on the average price of the underlying stock over the option’s life, rather than the price at a single point in time, which typically makes it cheaper than the equivalent vanilla option (the averaging reduces variance). The geometric-average version has a closed-form solution based on an adjusted volatility and cost of carry:

• σ_A = σ / √3
• b_A = 0.5 * (b - σ²/6), where b = r - q is the cost of carry
• d1 = (ln(S / K) + (b_A + σ_A²/2) * t) / (σ_A * √t)
• d2 = d1 - σ_A * √t
• Call Price = S * e^((b_A - r) * t) * N(d1) - K * e^(-r * t) * N(d2)
• Put Price = K * e^(-r * t) * N(-d2) - S * e^((b_A - r) * t) * N(-d1)

Where S is the stock price, K is the strike price, r is the risk-free rate, q is the dividend yield, σ is the volatility, t is the time to expiration, N(d1) is the cumulative normal distribution of d1 and N(d2) is the cumulative normal distribution of d2.

Also known as: geometric Asian option, average rate option, average price option.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• put_option (bool, optional): Whether to calculate the put option price. Defaults to False which means it will calculate the call option price.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the dividend yield as obtained through annual historical data.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: Geometric-average Asian option values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AMZN", "AAPL"], api_key="FINANCIAL_MODELING_PREP_KEY")

asian_option = toolkit.options.get_asian_option()

asian_option.loc['AMZN']

get_strategy_payoff

Calculate the net expiration profit and loss (P&L) profile of a multi-leg option (and, optionally, stock) strategy across a range of stock prices.

A strategy is expressed as a list of “legs”. Each leg is a dictionary describing either an option position or a stock position:

• For an option leg: “instrument”: “option” (default), “strike_price” (float, required), “put_option” (bool, defaults to False), “position” (“long” or “short”, defaults to “long”), “premium” (float, defaults to 0).
• For a stock leg: “instrument”: “stock”, “position” (“long” or “short”, defaults to “long”), “premium” (float, the entry price, defaults to 0).

This single, generic building block can express many common strategies by combining legs, for example:

• Straddle: long call + long put, same strike.
• Strangle: long call + long put, different (OTM) strikes.
• Bull call spread: long call (lower strike) + short call (higher strike).
• Bear put spread: long put (higher strike) + short put (lower strike).
• Covered call: long stock + short call.
• Protective put: long stock + long put.
• Iron condor: short put + long put (lower strikes) + short call + long call (higher strikes).

Also known as: option strategy payoff diagram, P&L profile.

Args:

• legs (list[dict]): A list of leg dictionaries as described above. Must contain at least one leg. The same legs are applied to every ticker, so strike prices should be chosen with the relevant tickers’ price levels in mind.
• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• stock_price_range (float): The percentage range to use for the stock prices at expiration. Defaults to 0.5 which equals 50% and thus results in stock prices from 50 to 150 if the current stock price is 100.
• stock_price_step_size (float): The step size to use for the stock prices at expiration. Defaults to 1.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.

Returns:

pd.DataFrame: The strategy’s net P&L with the range of stock prices at expiration as the index and the tickers as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AMZN", "AAPL"], api_key="FINANCIAL_MODELING_PREP_KEY")

straddle_legs = [
    {"strike_price": 150, "put_option": False, "position": "long", "premium": 8},
    {"strike_price": 150, "put_option": True, "position": "long", "premium": 6},
]

strategy_payoff = toolkit.options.get_strategy_payoff(legs=straddle_legs)

strategy_payoff["AMZN"]

collect_all_greeks

Calculate all Greeks of an option based on the Black Scholes Model. This will return the following Greeks per Strike Price and Expiration Date:

First Order Greeks:

• Delta: measures the rate of change of the theoretical option value with respect to changes in the underlying asset’s price.
• Dual Delta: the first derivative of the option price with respect to the strike price. Up to the discount factor and a sign it is the risk-neutral probability of the option finishing in the money, negative for a call and positive for a put.
• Vega: measures sensitivity to volatility. Vega is the derivative of the option value with respect to the volatility of the underlying asset.
• Theta: measures the sensitivity of the value of the derivative to the passage of time, the “time decay.”
• Rho: measures sensitivity to the interest rate: it is the derivative of the option value with respect to the risk-free interest rate (for the relevant outstanding term).
• Epsilon: measures the percentage change in option value per percentage change in the underlying dividend yield, a measure of the dividend risk.
• Lambda: measures the percentage change in option value per percentage change in the underlying price, a measure of leverage, sometimes called gearing. This greek is also sometimes called Omega or Elasticity.

Second Order Greeks:

• Gamma: measures the rate of change in the delta with respect to changes in the underlying price. Gamma is the second derivative of the value function with respect to the underlying price.
• Dual Gamma: the second derivative of the option value with respect to the strike price rather than the underlying price. It is the discounted risk-neutral probability density of the underlying at expiration.
• Vanna: also referred to as DvegaDspot and DdeltaDvol, is a second-order derivative of the option value, once to the underlying spot price and once to volatility.
• Charm: Charm or delta decay measures the instantaneous rate of change of delta over the passage of time.
• Vomma: also referred to as volga, vega convexity, or DvegaDvol measures second-order sensitivity to volatility. Vomma is the second derivative of the option value with respect to the volatility, or, stated another way, vomma measures the rate of change to vega as volatility changes.
• Veta: also referred to as DvegaDtime, measures the rate of change in the vega with respect to the passage of time. Veta is the second derivative of the value function; once to volatility and once to time.
• Vera: also referred to as rhova, measures the rate of change in rho with respect to volatility. Vera is the second derivative of the value function; once to volatility and once to interest rate.
• Partial Derivative: measures the rate of change in the option price with respect to the strike price.

Third Order Greeks:

• Speed: measures the rate of change in Gamma with respect to changes in the underlying price.
• Zomma: measures the rate of change of Gamma with respect to changes in volatility.
• Color: also referred to as gamma decay or DgammaDtime measures the rate of change of gamma over the passage of time.
• Ultima: measures the sensitivity of the option vomma with respect to change in volatility.

For a deeper explanation, please have a look at: https://en.wikipedia.org/wiki/Greeks_(finance) and the references to the literature as found on this page.

By default the most recent risk free rate, dividend yield and stock price is used, you can alter this by changing the start date. The volatility is calculated based on the daily returns of the stock price and the selected period (this can be altered by defining this accordingly when defining the Toolkit class, start_date and end_date).

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the dividend yield as obtained through annual historical data.
• put_option (bool, optional): Whether to calculate the put option delta. Defaults to False which means it will calculate the call option delta.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the greeks values containing the tickers and strike prices as the index and the time to expiration and greeks as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["TSLA", "MU"], api_key="FINANCIAL_MODELING_PREP_KEY")

all_greeks = toolkit.options.collect_all_greeks(start_date='2024-01-03')

all_greeks.loc['TSLA', '2024-01-04']

Which returns:

collect_first_order_greeks

Calculate the first order Greeks of an option based on the Black Scholes Model. This will return the following Greeks per Strike Price and Expiration Date:

• Delta: measures the rate of change of the theoretical option value with respect to changes in the underlying asset’s price.
• Dual Delta: the first derivative of the option price with respect to the strike price. Up to the discount factor and a sign it is the risk-neutral probability of the option finishing in the money, negative for a call and positive for a put.
• Vega: measures sensitivity to volatility. Vega is the derivative of the option value with respect to the volatility of the underlying asset.
• Theta: measures the sensitivity of the value of the derivative to the passage of time, the “time decay.”
• Rho: measures sensitivity to the interest rate: it is the derivative of the option value with respect to the risk-free interest rate (for the relevant outstanding term).
• Epsilon: measures the percentage change in option value per percentage change in the underlying dividend yield, a measure of the dividend risk.
• Lambda: measures the percentage change in option value per percentage change in the underlying price, a measure of leverage, sometimes called gearing. This greek is also sometimes called Omega or Elasticity.

For a deeper explanation, please have a look at: https://en.wikipedia.org/wiki/Greeks_(finance) and the references to the literature as found on this page.

By default the most recent risk free rate, dividend yield and stock price is used, you can alter this by changing the start date. The volatility is calculated based on the daily returns of the stock price and the selected period (this can be altered by defining this accordingly when defining the Toolkit class, start_date and end_date).

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the dividend yield as obtained through annual historical data.
• put_option (bool, optional): Whether to calculate the put option delta. Defaults to False which means it will calculate the call option delta.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the first order greek values containing the tickers and strike prices as the index and the time to expiration and greeks as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.collect_first_order_greeks().loc["AAPL"]

Which returns:

get_delta

Calculate the delta of an option based on the Black Scholes Model. The Black Scholes Model is a mathematical model used to estimate the price of European-style options. The delta is the rate of change of the option price with respect to the price of the underlying asset.

The delta calculation is the theoretical value of the delta. The actual delta can differ from this value due to several factors such as the volatility of the underlying asset, the time to expiration, the risk free rate and more.

The formula is as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration, N(d1) is the cumulative normal distribution of d1 and N(d2) is the the cumulative normal distribution of d2.

The Delta can be interpreted as follows:

• For call options, Delta is positive, indicating that the option price tends to move in the same direction as the underlying asset’s price.
• For put options, Delta is negative, indicating that the option price tends to move in the opposite direction to the underlying asset’s price.

Note that the delta of a call option is always between 0 and e^(-q * t), while the delta of a put option is always between -e^(-q * t) and 0. Without a dividend yield those bounds collapse to the familiar 0 to 1 and -1 to 0.

Also known as: option price sensitivity to underlying, hedge ratio.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• put_option (bool, optional): Whether to calculate the put option delta. Defaults to False which means it will calculate the call option delta.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the delta values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.get_delta().loc["AAPL"]

Which returns:

get_dual_delta

Calculate the dual delta of an option based on the Black Scholes Model. The Black Scholes Model is a mathematical model used to estimate the price of European-style options. The dual delta is the actual probability of an option finishing in the money which is the first derivative of option price with respect to strike.

The dual delta calculation is the theoretical value of the dual delta. The actual dual delta can differ from this value due to several factors such as the volatility of the underlying asset, the time to expiration, the risk free rate and more.

The formula is as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration, N(d1) is the cumulative normal distribution of d1 and N(d2) is the the cumulative normal distribution of d2.

The Dual Delta is the sensitivity of the option value to the strike price rather than to the underlying price. Up to the discount factor and a sign it is the risk-neutral probability that the option finishes in the money: a call Dual Delta of -0.5 corresponds to a roughly 50% chance of finishing in the money. It is negative for a call, since raising the strike lowers the call’s value, and positive for a put.

Also known as: cash delta, binary option delta.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the dividend yield as obtained through annual historical data.
• put_option (bool, optional): Whether to calculate the put option dual delta. Defaults to False which means it will calculate the call option dual delta.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the dual delta values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.get_dual_delta().loc["AAPL"]

Which returns:

get_vega

Calculate the vega of an option based on the Black Scholes Model. The Black Scholes Model is a mathematical model used to estimate the price of European-style options. The vega is the rate of change of the option price with respect to the volatility of the underlying asset.

The vega calculation is the theoretical value of the vega. The actual vega can differ from this value due to several factors such as the volatility of the underlying asset, the time to expiration, the risk free rate and more.

The formula is as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration, N’(d1) is the standard normal probability density at d1 and N(d2) is the cumulative normal distribution of d2.

The division by 100 expresses Vega per 1 percentage point change in volatility, the usual market quote. The higher order volatility Greeks (Vanna, Vomma, Zomma, Vera, Ultima) are reported unscaled, per 1.00 of volatility; only Vega and Veta carry this factor.

The Vega can be interpreted as follows:

• If Vega is positive, it indicates that the option value will increase as the volatility increases, and vice versa.
• If Vega is negative, it implies that the option value will decrease as the volatility increases, and vice versa.

Note that the vega of a call option and put option are equal to each other.

Also known as: option sensitivity to volatility changes.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the dividend yield as obtained through annual historical data.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the vega values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.get_vega().loc["AAPL"]

Which returns:

get_theta

Calculate the theta of an option based on the Black Scholes Model. The Black Scholes Model is a mathematical model used to estimate the price of European-style options. The theta is the rate of change of the option price with respect to the passage of time.

The theta calculation is the theoretical value of the theta. The actual theta can differ from this value due to several factors such as the volatility of the underlying asset, the time to expiration, the risk free rate and more.

The formula is as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration, N’(d1) is the standard normal probability density at d1 and N(d2) is the cumulative normal distribution of d2.

Theta is the derivative with respect to calendar time elapsed, not with respect to the remaining time to maturity, and the division by 365 expresses it per calendar day rather than per year. Charm, Veta and Color measure the same passage of time in the same direction.

The Theta can be interpreted as follows:

• If Theta is negative, the option loses value with each day that passes, all else equal. This is the normal case for a long option, whose time value erodes towards expiration.
• If Theta is positive, the option gains value with each day that passes. This happens for instance on a deep in-the-money European put, where the discounting of the strike dominates.

Also known as: time decay, option time value erosion.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the dividend yield as obtained through annual historical data.
• put_option (bool, optional): Whether to calculate the put option theta. Defaults to False which means it will calculate the call option theta.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the theta values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.get_theta().loc["AAPL"]

Which returns:

get_rho

Calculate the rho of an option based on the Black Scholes Model. The Black Scholes Model is a mathematical model used to estimate the price of European-style options. The rho is the rate of change of the option price with respect to the risk free interest rate.

The rho calculation is the theoretical value of the rho. The actual rho can differ from this value due to several factors such as the volatility of the underlying asset, the time to expiration, the risk free rate and more.

The formula is as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration, N(d1) is the cumulative normal distribution of d1 and N(d2) is the the cumulative normal distribution of d2.

The Rho can be interpreted as follows:

• If Rho is positive, it indicates that the option value will increase as the risk free rate increases, and vice versa.
• If Rho is negative, it implies that the option value will decrease as the risk free rate increases, and vice versa.

Rho is reported unscaled, as the amount of money per share of the underlying that the value of the option gains or loses per 1.00 change in the risk-free rate. Divide by 100 for the more commonly quoted move per 1.0% per annum (100 basis points). Epsilon and Vera follow the same unscaled convention, while Vega and Veta are already divided by 100.

Also known as: option sensitivity to interest rate.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the dividend yield as obtained through annual historical data.
• put_option (bool, optional): Whether to calculate the put option rho. Defaults to False which means it will calculate the call option rho.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the rho values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.get_rho().loc["AAPL"]

Which returns:

get_epsilon

Calculate the epsilon of an option based on the Black Scholes Model. The Black Scholes Model is a mathematical model used to estimate the price of European-style options. The epsilon is the rate of change of the option price with respect to the dividend yield.

The epsilon calculation is the theoretical value of the epsilon. The actual epsilon can differ from this value due to several factors such as the volatility of the underlying asset, the time to expiration, the risk free rate and more.

The formula is as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration, N(d1) is the cumulative normal distribution of d1 and N(d2) is the the cumulative normal distribution of d2.

Epsilon is reported unscaled, per 1.00 change in the dividend yield, matching Rho and Vera.

The Epsilon can be interpreted as follows:

• If Epsilon is positive, it indicates that the option value will increase as the dividend yield increases, and vice versa.
• If Epsilon is negative, it implies that the option value will decrease as the dividend yield increases, and vice versa.

Also known as: option sensitivity to dividend yield.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the dividend yield as obtained through annual historical data.
• put_option (bool, optional): Whether to calculate the put option epsilon. Defaults to False which means it will calculate the call option epsilon.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the epsilon values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.get_epsilon().loc["AAPL"]

Which returns:

get_lambda

Calculate the lambda of an option based on the Black Scholes Model. The Black Scholes Model is a mathematical model used to estimate the price of European-style options. The lambda is the rate of change of the option price with respect to the underlying price.

The lambda calculation is the theoretical value of the lambda. The actual lambda can differ from this value due to several factors such as the volatility of the underlying asset, the time to expiration, the risk free rate and more.

The formula is as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration, N(d1) is the cumulative normal distribution of d1 and N(d2) is the the cumulative normal distribution of d2.

The Lambda can be interpreted as follows:

• If Lambda is positive, it indicates that the option value will increase as the underlying price increases, and vice versa.
• If Lambda is negative, it implies that the option value will decrease as the underlying price increases, and vice versa.

Also known as: option elasticity, leverage factor.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the dividend yield as obtained through annual historical data.
• put_option (bool, optional): Whether to calculate the put option lambda. Defaults to False which means it will calculate the call option lambda.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the lambda values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.get_lambda().loc["AAPL"]

Which returns:

collect_second_order_greeks

Calculate the second order Greeks of an option based on the Black Scholes Model. This will return the following Greeks per Strike Price and Expiration Date:

• Gamma: measures the rate of change in the delta with respect to changes in the underlying price. Gamma is the second derivative of the value function with respect to the underlying price.
• Dual Gamma: the second derivative of the option value with respect to the strike price rather than the underlying price. It is the discounted risk-neutral probability density of the underlying at expiration.
• Vanna: also referred to as DvegaDspot and DdeltaDvol, is a second-order derivative of the option value, once to the underlying spot price and once to volatility.
• Charm: Charm or delta decay measures the instantaneous rate of change of delta over the passage of time.
• Vomma: also referred to as volga, vega convexity, or DvegaDvol measures second-order sensitivity to volatility. Vomma is the second derivative of the option value with respect to the volatility, or, stated another way, vomma measures the rate of change to vega as volatility changes.
• Veta: also referred to as DvegaDtime, measures the rate of change in the vega with respect to the passage of time. Veta is the second derivative of the value function; once to volatility and once to time.
• Vera: also referred to as rhova, measures the rate of change in rho with respect to volatility. Vera is the second derivative of the value function; once to volatility and once to interest rate.
• Partial Derivative: measures the rate of change in the option price with respect to the strike price.

For a deeper explanation, please have a look at: https://en.wikipedia.org/wiki/Greeks_(finance) and the references to the literature as found on this page.

By default the most recent risk free rate, dividend yield and stock price is used, you can alter this by changing the start date. The volatility is calculated based on the daily returns of the stock price and the selected period (this can be altered by defining this accordingly when defining the Toolkit class, start_date and end_date).

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the current dividend yield.
• put_option (bool, optional): Whether to calculate the put option delta. Defaults to False which means it will calculate the call option delta.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the second order greeks values containing the tickers and strike prices as the index and the time to expiration and greeks as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "MSFT"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.collect_second_order_greeks().loc["AAPL"]

Which returns:

get_gamma

Calculate the gamma of an option based on the Black Scholes Model. The Black Scholes Model is a mathematical model used to estimate the price of European-style options. The gamma is the rate of change of the delta with respect to the price of the underlying asset.

The gamma calculation is the theoretical value of the gamma. The actual gamma can differ from this value due to several factors such as the volatility of the underlying asset, the time to expiration, the risk free rate and more.

The formula is as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration, N’(d1) is the standard normal probability density at d1 and N(d2) is the cumulative normal distribution of d2.

The Gamma can be interpreted as follows:

• If Gamma is high, it indicates that the option’s Delta is highly sensitive to changes in the underlying asset’s price. The option’s Delta will change more significantly with small movements in the stock price.
• If Gamma is low, it suggests that the option’s Delta is relatively insensitive to changes in the underlying asset’s price. The option’s Delta changes more gradually with movements in the stock price.

Note that the gamma of a call option and put option are equal to each other.

Also known as: rate of change of delta, option convexity.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the gamma values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.get_gamma().loc["AAPL"]

Which returns:

get_dual_gamma

Calculate the gamma of an option based on the Black Scholes Model. The Black Scholes Model is a mathematical model used to estimate the price of European-style options. The gamma is the rate of change of the delta with respect to the price of the underlying asset.

The gamma calculation is the theoretical value of the gamma. The actual gamma can differ from this value due to several factors such as the volatility of the underlying asset, the time to expiration, the risk free rate and more.

The formula is as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration, N’(d2) is the standard normal probability density at d2 and N(d1) is the cumulative normal distribution of d1. Note that Dual Gamma is a second derivative with respect to the strike price, so it is the strike and not the stock price that appears in the denominator.

Note that the dual gamma of a call option and put option are equal to each other.

Also known as: cash gamma, binary option gamma.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the current dividend yield.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the dual gamma values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.get_dual_gamma().loc["AAPL"]

Which returns:

get_vanna

Calculate the vanna of an option based on the Black Scholes Model. The Black Scholes Model is a mathematical model used to estimate the price of European-style options. The vanna is the rate of change of the vega with respect to the price of the underlying asset.

The vanna calculation is the theoretical value of the vanna. The actual vanna can differ from this value due to several factors such as the volatility of the underlying asset, the time to expiration, the risk free rate and more.

The formula is as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration, N(d1) is the cumulative normal distribution of d1 and N(d2) is the the cumulative normal distribution of d2.

The Vanna can be interpreted as follows:

• If Vanna is positive, it indicates that the Delta of the option becomes more positive as both the underlying asset’s price and implied volatility increase, and more negative as they both decrease.
• If Vanna is negative, it suggests that the Delta of the option becomes more negative as both the underlying asset’s price and implied volatility increase, and more positive as they both decrease.

Note that the vanna of a call option and put option are equal to each other.

Also known as: delta-vega cross-derivative.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the current dividend yield.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the vanna values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.get_vanna().loc["AAPL"]

Which returns:

get_charm

Calculate the charm of an option based on the Black Scholes Model. The Black Scholes Model is a mathematical model used to estimate the price of European-style options. The charm is the rate of change of the delta with respect to the time to expiration.

The charm calculation is the theoretical value of the charm. The actual charm can differ from this value due to several factors such as the volatility of the underlying asset, the time to expiration, the risk free rate and more.

The formula is as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration, N’(d1) is the standard normal probability density at d1 and N(d1) is the cumulative normal distribution of d1.

Charm is the derivative with respect to calendar time elapsed, in the same direction as Theta, but it is reported per year rather than per day. Divide by 365 for delta decay per calendar day. Color follows the same per-year convention.

The Charm can be interpreted as follows:

• If Charm is positive, it suggests that the option’s Delta is becoming more positive over time. In other words, the option is gaining sensitivity to changes in the underlying asset’s price as time passes.
• If Charm is negative, it indicates that the option’s Delta is becoming more negative over time. The option is losing sensitivity to changes in the underlying asset’s price as time passes.

Also known as: delta time decay, delta bleed.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the current dividend yield.
• put_option (bool, optional): Whether to calculate the put option charm. Defaults to False which means it will calculate the call option charm.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the charm values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.get_charm().loc["AAPL"]

Which returns:

get_vomma

Calculate the vomma of an option based on the Black Scholes Model. The Black Scholes Model is a mathematical model used to estimate the price of European-style options. The vomma is the rate of change of the vega with respect to the volatility of the underlying asset.

The vomma calculation is the theoretical value of the vomma. The actual vomma can differ from this value due to several factors such as the volatility of the underlying asset, the time to expiration, the risk free rate and more.

The formula is as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration, N(d1) is the cumulative normal distribution of d1 and N(d2) is the the cumulative normal distribution of d2.

The vomma can be interpreted as follows:

• If Vomma is high, it indicates that the option’s Vega is highly sensitive to changes in implied volatility. The option’s value will experience more significant fluctuations with variations in implied volatility.
• If Vomma is low, it suggests that the option’s Vega is relatively less sensitive to changes in implied volatility.

Also known as: volga, vega convexity.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the current dividend yield.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the vomma values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.get_vomma().loc["AAPL"]

Which returns:

get_vera

Calculate the vera of an option based on the Black Scholes Model. The Black Scholes Model is a mathematical model used to estimate the price of European-style options. The vera is the rate of change of the rho with respect to volatility.

The vera calculation is the theoretical value of the vera. The actual vera can differ from this value due to several factors such as the volatility of the underlying asset, the time to expiration, the risk free rate and more.

The formula is as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration, N’(d2) is the standard normal probability density at d2 and N(d1) is the cumulative normal distribution of d1.

Vera is reported unscaled, per 1.00 of volatility and per 1.00 of the risk free rate, matching Rho.

The Vera can be interpreted as follows:

• If Vera is positive, it indicates that the option’s Rho becomes more positive as implied volatility rises. In other words, the option gains sensitivity to the risk free rate when volatility increases.
• If Vera is negative, it suggests that the option’s Rho becomes more negative as implied volatility rises. The option loses sensitivity to the risk free rate when volatility increases.

Note that the vera of a call option and put option are equal to each other.

Also known as: rho-vega cross-derivative.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the current dividend yield.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the vera values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.get_vera().loc["AAPL"]

Which returns:

get_veta

Calculate the veta of an option based on the Black Scholes Model. The Black Scholes Model is a mathematical model used to estimate the price of European-style options. The veta is the rate of change of the vega with respect to the time to expiration.

The veta calculation is the theoretical value of the veta. The actual veta can differ from this value due to several factors such as the volatility of the underlying asset, the time to expiration, the risk free rate and more.

The formula is as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration, N’(d1) is the standard normal probability density at d1 and N(d2) is the cumulative normal distribution of d2.

The formula as usually published carries a leading minus sign because it differentiates with respect to the time to maturity, which runs opposite to elapsed calendar time. That sign is absorbed here so that Veta, like Theta, Charm and Color, measures the change per unit of time that passes: a long option loses Vega as expiry approaches, so its Veta is negative.

It is common practice to divide the mathematical result of veta by 100 times the number of days per year to reduce the value to the percentage change in vega per one day. This is also done here.

The Veta can be interpreted as follows:

• If Veta is positive, it indicates that the option’s Vega is becoming more positive over time. In other words, the option is gaining sensitivity to changes in implied volatility as time passes.
• If Veta is negative, it suggests that the option’s Vega is becoming more negative over time. The option is losing sensitivity to changes in implied volatility as time passes.

Also known as: vega time decay.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the current dividend yield.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the veta values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.get_veta().loc["AAPL"]

Which returns:

get_partial_derivative

Calculate the partial derivative of an option based on the Black Scholes Model. The Black Scholes Model is a mathematical model used to estimate the price of European-style options. The partial derivative is the rate of change of the option price with respect to the strike price.

Note that this uses a single, flat assumed volatility (the same value at every strike price) rather than the market’s actual implied volatility smile. This means it is NOT the Breeden-Litzenberger risk-neutral density – with a flat volatility input the second derivative can only ever recover a lognormal density, regardless of what the real market smile looks like, which defeats the entire purpose of that theorem. For the actual market-implied (smile-consistent) risk-neutral density, see get_risk_neutral_density, which uses this same second-derivative relationship but applied to a volatility surface calibrated to real market option prices instead of a flat assumption.

The formula is as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility and t is the time to expiration. This expression is algebraically identical to e^(-r * t) * N’(d2) / (K * σ * sqrt(t)), i.e. to the Dual Gamma, since both are the second derivative of the option price with respect to the strike price.

Also known as: numerical derivative, option sensitivity.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the current dividend yield.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the partial derivative values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.get_partial_derivative().loc["AAPL"]

Which returns:

collect_third_order_greeks

Calculate the third order Greeks of an option based on the Black Scholes Model. This will return the following Greeks per Strike Price and Expiration Date:

• Speed: measures the rate of change in Gamma with respect to changes in the underlying price.
• Zomma: measures the rate of change of gamma with respect to changes in volatility.
• Color: also referred to as gamma decay or DgammaDtime measures the rate of change of gamma over the passage of time.
• Ultima: measures the sensitivity of the option vomma with respect to change in volatility.

For a deeper explanation, please have a look at: https://en.wikipedia.org/wiki/Greeks_(finance) and the references to the literature as found on this page.

By default the most recent risk free rate, dividend yield and stock price is used, you can alter this by changing the start date. The volatility is calculated based on the daily returns of the stock price and the selected period (this can be altered by defining this accordingly when defining the Toolkit class, start_date and end_date).

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the current dividend yield.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the third order greeks values containing the tickers and strike prices as the index and the time to expiration and greeks as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["MU", "AMZN"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.collect_third_order_greeks().loc["MU"]

Which returns:

get_speed

Calculate the speed of an option based on the Black Scholes Model. The Black Scholes Model is a mathematical model used to estimate the price of European-style options. The speed is the rate of change of the gamma with respect to the price of the underlying asset.

The speed calculation is the theoretical value of the speed. The actual speed can differ from this value due to several factors such as the volatility of the underlying asset, the time to expiration, the risk free rate and more.

The formula is as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration and N’(d1) is the standard normal probability density at d1.

The Speed can be interpreted as follows:

• If Speed is positive, the option’s Gamma rises as the underlying price rises, so the position’s convexity builds up on the way up.
• If Speed is negative, the option’s Gamma falls as the underlying price rises, which is the usual case just below the strike where Gamma is already close to its peak.

Note that the speed of a call option and put option are equal to each other.

Also known as: gamma rate of change.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the current dividend yield.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the speed values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.get_speed().loc["AAPL"]

Which returns:

get_zomma

Calculate the zomma of an option based on the Black Scholes Model. The Black Scholes Model is a mathematical model used to estimate the price of European-style options. The zomma is the rate of change of the gamma with respect to volatility.

The zomma calculation is the theoretical value of the zomma. The actual zomma can differ from this value due to several factors such as the volatility of the underlying asset, the time to expiration, the risk free rate and more.

The formula is as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration and N’(d1) is the standard normal probability density at d1. This is equivalently Gamma * (d1 * d2 - 1) / σ, and it is reported unscaled, per 1.00 of volatility.

The Zomma can be interpreted as follows:

• If Zomma is positive, the option’s Gamma rises as implied volatility rises, which is typical for strikes well away from the money.
• If Zomma is negative, the option’s Gamma falls as implied volatility rises, which is typical for strikes near the money where Gamma is already at its peak.

Note that the zomma of a call option and put option are equal to each other.

Also known as: gamma sensitivity to volatility.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the current dividend yield.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the zomma values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.get_zomma().loc["AAPL"]

Which returns:

get_color

Calculate the color of an option based on the Black Scholes Model. The Black Scholes Model is a mathematical model used to estimate the price of European-style options. The color is the rate of change of the gamma with respect to time to expiration.

The color calculation is the theoretical value of the color. The actual color can differ from this value due to several factors such as the volatility of the underlying asset, the time to expiration, the risk free rate and more.

The formula is as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration and N’(d1) is the standard normal probability density at d1.

The formula as usually published carries a leading minus sign because it differentiates with respect to the time to maturity, which runs opposite to elapsed calendar time. That sign is absorbed here so that Color, like Theta, Charm and Veta, measures the change per unit of time that passes. The result is per year, matching Charm; divide by 365 for gamma decay per calendar day.

The Color can be interpreted as follows:

• If Color is positive, the option’s Gamma builds up with each day that passes, which is what happens to a near-the-money option as expiration approaches.
• If Color is negative, the option’s Gamma bleeds away with each day that passes, which is what happens to a strike far from the money that is running out of time to reach it.

Note that the color of a call option and put option are equal to each other.

Also known as: gamma time decay.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the current dividend yield.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the color values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.get_color().loc["AAPL"]

Which returns:

get_ultima

Calculate the ultima of an option based on the Black Scholes Model. The Black Scholes Model is a mathematical model used to estimate the price of European-style options. The ultima is the rate of change of the vomma with respect to volatility.

The ultima calculation is the theoretical value of the ultima. The actual gamma can differ from this value due to several factors such as the volatility of the underlying asset, the time to expiration, the risk free rate and more.

The formula is as follows:

Where S is the stock price, K is the strike price, r is the risk free rate, q is the dividend yield, σ is the volatility, t is the time to expiration and vega is the unscaled S * e^(-q * t) * N’(d1) * sqrt(t), i.e. the Vega before the division by 100 that get_vega applies. Ultima itself is likewise reported unscaled, per 1.00 of volatility.

The Ultima can be interpreted as follows:

• If Ultima is positive, the option’s Vomma rises as implied volatility rises, so the volatility convexity of the position builds up in a rising volatility regime.
• If Ultima is negative, the option’s Vomma falls as implied volatility rises, which is the usual case for strikes near the money.

Note that the ultima of a call option and put option are equal to each other.

Also known as: third-order vega.

Args:

• start_date (str \| None, optional): The start date which determines the stock price. Defaults to None which means it will use the most recent date.
• strike_price_range (float): The percentage range to use for the strike prices. Defaults to 0.25 which equals 25% and thus results in strike prices from 75 to 125 if the current stock price is 100.
• strike_step_size (int): The step size to use for the strike prices. Defaults to 5 which means that the strike prices will be 75, 80, 85, 90, 95, 100, 105, 110, 115 and 120 if the current stock price is 100.
• expiration_time_range (int): The number of days to use for the time to expiration. Defaults to 30 which equals 30 days.
• risk_free_rate (float, optional): The risk free rate to use for the calculation. Defaults to None which means it will use the current risk free rate.
• dividend_yield (float, optional): The dividend yield to use for the calculation. Defaults to None which means it will use the current dividend yield.
• show_input_info (bool, optional): Whether to show the input information. Defaults to False.
• rounding (int \| None, optional): The number of decimals to round the results to. Defaults to 4.
• standardize (bool, optional): Whether to standardize (Z-Score) the result across the time to expiration columns for each ticker and strike price. Defaults to False.

Returns:

pd.DataFrame: the ultima values containing the tickers and strike prices as the index and the time to expiration as the columns.

As an example:

from financetoolkit import Toolkit

toolkit = Toolkit(["AAPL", "ASML"], api_key="FINANCIAL_MODELING_PREP_KEY")

toolkit.options.get_ultima().loc["AAPL"]

Which returns: