How to Generate Synthetic Future Charts in Python Using Weekly Options

Synthetic futures are a smart way to replicate index futures prices using only options data. This technique is particularly helpful when you’re dealing with weekly options and want to track market sentiment or momentum without directly using futures contracts.

In this guide, we’ll cover:

• What are synthetic futures?
• Why are they useful in weekly option trading?
• How to build and visualize synthetic future charts using Python and OpenAlgo.

What Is a Synthetic Future?

A synthetic future approximates the price of a futures contract using the following formula:

Synthetic Future Price = Call Price - Put Price + Strike Price

This is based on options pricing theory and reflects the fair value of a future using the at-the-money (ATM) options.

Why Use Synthetic Futures with Weekly Options?

1. Improved Liquidity in Options: Weekly options often have better liquidity than their corresponding futures, especially for retail traders.
2. Early Market Readings: Synthetic futures reflect real-time changes in sentiment as options prices adjust quickly to underlying movements.
3. Volatility Insight: Since options price includes implied volatility, the synthetic future also indirectly reflects changing volatility conditions.
4. Better Precision for Option Strategies: Traders executing strategies like intraday straddles or strangles can monitor the synthetic future for trend confirmation.

Requirements

Before running the code, ensure the following:

• OpenAlgo application is installed, running, and connected to your broker.
• Generate your OpenAlgo API Key from the OpenAlgo dashboard.
• Configure the API key in the Python script.

To install necessary packages:

pip install openalgo pandas plotly

If you’re using a Jupyter notebook:

pip install nbformat ipykernel

Python Code: Generate a Synthetic Future Chart

import pandas as pd
from openalgo import api
from datetime import datetime, timedelta
import plotly.graph_objects as go

client = api(api_key='your_openalgo_api_key', host='http://127.0.0.1:5000')

# Date Range
end_date = datetime.now()
start_date = end_date - timedelta(days=5)

# ATM Strike Calculation
spot = client.quotes(symbol="NIFTY", exchange="NSE_INDEX")['data']['ltp']
atm_strike = round(spot / 50) * 50
expiry = '05JUN25'
ce_symbol = f"NIFTY{expiry}{atm_strike}CE"
pe_symbol = f"NIFTY{expiry}{atm_strike}PE"

# Historical Data
df_ce = client.history(symbol=ce_symbol, exchange="NFO", interval="5m",
                       start_date=start_date.strftime("%Y-%m-%d"),
                       end_date=end_date.strftime("%Y-%m-%d"))
df_pe = client.history(symbol=pe_symbol, exchange="NFO", interval="5m",
                       start_date=start_date.strftime("%Y-%m-%d"),
                       end_date=end_date.strftime("%Y-%m-%d"))

# Combine and Calculate Synthetic Future
df = df_ce[['open', 'high', 'low', 'close']].copy()
df['open'] = df_ce['open'] - df_pe['open'] + atm_strike
df['high'] = df_ce['high'] - df_pe['low'] + atm_strike
df['low'] = df_ce['low'] - df_pe['high'] + atm_strike
df['close'] = df_ce['close'] - df_pe['close'] + atm_strike
df.index = pd.to_datetime(df.index)
formatted_index = df.index.strftime('%d-%b\n%H:%M')

# Plot
fig = go.Figure(data=[
    go.Candlestick(x=formatted_index,
                   open=df['open'], high=df['high'],
                   low=df['low'], close=df['close'],
                   name="Synthetic Future")
])
fig.update_layout(
    title=f'NIFTY Synthetic Future ({atm_strike})',
    xaxis=dict(type="category", tickmode="array",
               tickvals=formatted_index[::len(formatted_index)//10]),
    xaxis_title='Time', yaxis_title='Price',
    template="plotly_dark", xaxis_rangeslider_visible=False,
    height=500, width=800
)

fig.write_html("synthetic_future_chart.html", auto_open=True)
# fig.show()  # Use this only inside a Jupyter Notebook

Can Synthetic Futures Be Calculated Only from ATM Options?

No, synthetic futures can technically be calculated using any option strike pair (Call and Put with the same strike and expiry). However, ATM (At-The-Money) options are the most commonly used and practically preferred for this purpose.

1. Put-Call Parity is Most Accurate at ATM.
   This parity relationship holds best for ATM options where extrinsic (time) value dominates, and intrinsic value is minimal.
2. Better Liquidity and Tighter Spreads
   ATM options typically have the highest trading volumes, leading to more accurate pricing and minimal slippage.
3. Balanced Implied Volatility
   ATM options are less influenced by volatility skew, making the synthetic value more stable and reflective of actual market sentiment.

Using Non-ATM Strikes: What to Expect

• In-the-Money (ITM) or Out-of-the-Money (OTM) options can also be used to compute synthetic prices.
• However, the calculated price may deviate more from the actual future price due to:
  • Lower liquidity
  • Higher bid-ask spreads
  • Uneven implied volatility across strikes

This could introduce noise or pricing bias into your synthetic chart.

Conclusion

Synthetic future charts provide a unique, real-time view of market direction and option sentiment. They are especially useful in strategies involving intraday options like straddles, giving a more precise edge over traditional spot or futures tracking.

This method not only saves cost (by avoiding direct futures trades) but also provides deeper insights for short-term decision-making using just the options market.