GARCH Model Explained

What Is the GARCH Model?

The GARCH model (Generalised Autoregressive Conditional Heteroscedasticity) is a statistical model that captures a fundamental property of financial returns: volatility clustering. Periods of high volatility tend to be followed by more high volatility, and calm periods tend to persist. GARCH models this behaviour directly, producing time-varying estimates of variance that update as new data arrives.

If you've ever looked at a chart of daily stock returns, the pattern is obvious. Returns are roughly centred around zero, but the amplitude of the swings isn't constant. There are stretches where moves are tiny, then suddenly the swings get violent for weeks or months before settling down again. This is heteroscedasticity - non-constant variance - and it's present in virtually every financial time series.

A standard regression model treats variance as a single fixed number. That's fine for some data, but it badly misrepresents how financial markets work. The GARCH model says: variance itself evolves over time, and today's variance depends on yesterday's squared return and yesterday's variance. This simple idea, formalised by Tim Bollerslev in 1986, became one of the most important tools in financial econometrics and remains central to quantitative finance in 2026.

GARCH volatility estimates feed into risk management systems, position sizing algorithms, option pricing models, and regulatory capital calculations. If you work with financial data and care about the uncertainty around your forecasts, GARCH is a model you need to understand.

---

From ARCH to GARCH

The GARCH model grew out of Robert Engle's ARCH (Autoregressive Conditional Heteroscedasticity) model, published in 1982. Engle's insight was that you could model variance as a function of past squared residuals - treating volatility as something predictable rather than a fixed constant. He won the Nobel Prize in Economics in 2003 partly for this work.

Engle's ARCH Model

The ARCH(q) model specifies today's conditional variance as a linear function of the past q squared error terms:

sigma_t^2 = omega + alpha_1 * epsilon_{t-1}^2 + alpha_2 * epsilon_{t-2}^2 + ... + alpha_q * epsilon_{t-q}^2

If yesterday's return was large (positive or negative), the squared residual is large, and the model raises its estimate of today's variance. The model captures volatility clustering because a large shock at time t-1 feeds into a higher variance estimate at time t, which makes another large shock more likely.

The problem with ARCH is practical. To capture the long memory of volatility - the fact that a shock can influence variance for weeks or months - you need a high order q, meaning many parameters. Fitting an ARCH(20) model to capture a month of persistence is cumbersome and prone to overfitting.

Bollerslev's Generalisation

Tim Bollerslev solved this in 1986 by adding lagged conditional variance terms. Instead of using twenty lags of squared residuals, you could use a single lag of squared residuals and a single lag of the conditional variance itself. The GARCH(1,1) model - one ARCH lag and one GARCH lag - captures the same long persistence with just three parameters. In practice, GARCH(1,1) fits financial return data remarkably well, and higher-order GARCH models rarely improve the fit significantly.

The relationship between ARCH and GARCH is analogous to the relationship between moving average and autoregressive models in time series analysis. The autoregressive component (the lagged variance term) gives GARCH a parsimonious way to represent long memory - the same reason AR models are more efficient than long MA models for persistent processes.

---

The GARCH(1,1) Equation

The GARCH(1,1) model is by far the most widely used specification. It defines the conditional variance sigma_t^2 as:

sigma_t^2 = omega + alpha * epsilon_{t-1}^2 + beta * sigma_{t-1}^2

where:

• sigma_t^2 is the conditional variance at time t - the model's estimate of today's variance given all information up to yesterday.
• omega (omega > 0) is a constant baseline. It ensures the variance has a positive floor and, together with alpha and beta, determines the long-run average variance.
• alpha (alpha >= 0) is the ARCH coefficient. It controls how much yesterday's squared shock (epsilon_{t-1}^2) influences today's variance. A larger alpha means the model reacts more sharply to recent surprises.
• beta (beta >= 0) is the GARCH coefficient. It controls how much yesterday's variance estimate carries over into today's estimate. A larger beta means the model has longer memory.
• epsilon_{t-1} is the return innovation (residual) at time t-1 - the unexpected portion of yesterday's return.

The model requires omega > 0, alpha >= 0, and beta >= 0 to ensure the variance is always positive. For the model to be stationary (so that variance doesn't explode to infinity), we need alpha + beta < 1.

What the Equation Means Intuitively

Think of today's variance as a weighted combination of three things: a long-run baseline (omega), a reaction to yesterday's news (alpha * epsilon_{t-1}^2), and persistence from yesterday's volatility level (beta * sigma_{t-1}^2).

When nothing unusual happens - the return yesterday was close to its mean - the squared innovation is small, and today's variance is mostly determined by the persistent component beta * sigma_{t-1}^2. Variance drifts slowly back towards its long-run average.

When a shock hits - a large positive or negative return - the squared innovation spikes, and today's variance jumps. The size of the jump is governed by alpha. Then over subsequent days, the elevated variance decays gradually through the beta term, because tomorrow's variance inherits a fraction beta of today's already-elevated variance.

This is exactly the volatility clustering pattern observed in financial markets: shocks cause volatility to spike, and the spike decays slowly over time.

---

Interpreting GARCH Parameters

Understanding what alpha and beta tell you about a time series is essential for using the model effectively.

The Role of Alpha

Alpha measures the model's sensitivity to new information. A high alpha (say 0.15 or above) means the model responds quickly and strongly to surprises. A low alpha (say 0.03) means the model is sluggish and doesn't revise its variance estimate much in response to a single large return.

For equity indices, alpha is typically between 0.04 and 0.10. Individual stocks tend to have slightly higher alpha because their returns are more prone to idiosyncratic jumps.

The Role of Beta

Beta controls memory. A high beta (say 0.92) means today's variance is heavily influenced by yesterday's, which was heavily influenced by the day before's, and so on. Volatility changes are sticky - once variance increases, it stays elevated for a long time.

For most financial assets, beta is between 0.85 and 0.95. This high persistence is the single most consistent finding across thousands of GARCH studies.

Persistence: Alpha + Beta

The sum alpha + beta is called the persistence of the model. It determines how quickly variance reverts to its long-run mean after a shock. If alpha + beta = 0.98, volatility shocks take a very long time to die out. If alpha + beta = 0.90, the reversion is faster.

When alpha + beta equals exactly 1, the model is called an Integrated GARCH (IGARCH). In this case, shocks to variance never fully die out - the process has a unit root in variance. Some researchers argue that financial data is genuinely IGARCH, while others say it's a sign of structural breaks in the sample being misidentified as extreme persistence.

Unconditional Variance

The long-run (unconditional) variance of the GARCH(1,1) model is:

sigma^2 = omega / (1 - alpha - beta)

This is the variance the process reverts to in the long run. It only exists when alpha + beta < 1. If you've estimated omega = 0.000005, alpha = 0.07, and beta = 0.91, the unconditional variance is 0.000005 / (1 - 0.07 - 0.91) = 0.00025, corresponding to an annualised volatility of about sqrt(0.00025 * 252) = 25.1%.

---

Fitting a GARCH Model in Python

The arch library is the standard tool for fitting GARCH models in Python. Here's a complete workflow: downloading return data, fitting a GARCH(1,1), extracting the conditional volatility, and producing a forecast.

import numpy as np
import pandas as pd
from arch import arch_model

np.random.seed(42)
n = 2000

# Simulate returns with GARCH(1,1) dynamics:
# omega=0.00001, alpha=0.08, beta=0.90
returns = np.zeros(n)
sigma2 = np.zeros(n)
sigma2[0] = 0.0001

for t in range(1, n):
    sigma2[t] = 0.00001 + 0.08 * returns[t - 1] ** 2 + 0.90 * sigma2[t - 1]
    returns[t] = np.sqrt(sigma2[t]) * np.random.normal()

# Scale to percentage returns (arch library convention)
pct_returns = pd.Series(returns * 100, name="returns")

# Fit a GARCH(1,1) model
model = arch_model(pct_returns, vol="Garch", p=1, q=1, mean="Constant")
result = model.fit(disp="off")

print(result.summary())
print()

# Extract estimated parameters
omega_hat = result.params["omega"]
alpha_hat = result.params["alpha[1]"]
beta_hat = result.params["beta[1]"]

print(f"omega:       {omega_hat:.6f}")
print(f"alpha:       {alpha_hat:.4f}")
print(f"beta:        {beta_hat:.4f}")
print(f"persistence: {alpha_hat + beta_hat:.4f}")

# Unconditional annualised volatility
uncond_var = omega_hat / (1 - alpha_hat - beta_hat)
annual_vol = np.sqrt(uncond_var * 252) / 100
print(f"Unconditional annualised vol: {annual_vol:.2%}")

The arch_model function accepts percentage returns by default. Set p=1 for one GARCH lag and q=1 for one ARCH lag. The mean="Constant" argument specifies a constant mean model for the returns.

Extracting Conditional Volatility

Once the model is fitted, you can extract the full time series of conditional volatility - the model's real-time estimate of how volatile the asset was at each point.

# Conditional volatility (annualised)
cond_vol = result.conditional_volatility * np.sqrt(252) / 100

print(f"Mean conditional vol:   {cond_vol.mean():.2%}")
print(f"Max conditional vol:    {cond_vol.max():.2%}")
print(f"Min conditional vol:    {cond_vol.min():.2%}")
print(f"Current conditional vol: {cond_vol.iloc[-1]:.2%}")

The conditional volatility series is one of the most practically useful outputs. It tells you how volatile the market was at each moment according to the model, and it's the foundation for time-varying risk measures.

Forecasting Volatility

GARCH forecasts are straightforward. The model uses the latest estimated parameters and the most recent data point to project variance forward.

# Forecast 10 days ahead
forecasts = result.forecast(horizon=10)
forecast_var = forecasts.variance.iloc[-1]
forecast_vol = np.sqrt(forecast_var) * np.sqrt(252) / 100

print("Volatility forecast (annualised):")
for i, vol in enumerate(forecast_vol, 1):
    print(f"  Day {i}: {vol:.2%}")

GARCH forecasts revert to the unconditional variance over longer horizons. If current volatility is above the long-run average, the forecast will slope downward; if below, it will slope upward. This mean-reverting property is central to how GARCH volatility forecasts are used in practice.

---

GARCH Variants

The standard GARCH model treats positive and negative shocks symmetrically - a 3% drop and a 3% rally have the same impact on tomorrow's variance. In reality, negative returns tend to increase volatility more than positive returns of the same size. Several GARCH variants address this and other limitations.

EGARCH (Exponential GARCH)

Nelson (1991) proposed the EGARCH model, which models the log of the conditional variance:

log(sigma_t^2) = omega + alpha * (|z_{t-1}| - E[|z_{t-1}|]) + gamma * z_{t-1} + beta * log(sigma_{t-1}^2)

where z_t = epsilon_t / sigma_t is the standardised residual.

The key advantage is the gamma parameter, which captures asymmetric effects. When gamma < 0 (the typical finding for equities), negative returns increase volatility more than positive returns. Because the model is specified in logs, the conditional variance is guaranteed to be positive regardless of parameter values - no non-negativity constraints are needed.

GJR-GARCH

Glosten, Jagannathan, and Runkle (1993) proposed a simpler way to capture asymmetry:

sigma_t^2 = omega + (alpha + gamma * I_{t-1}) * epsilon_{t-1}^2 + beta * sigma_{t-1}^2

where I_{t-1} = 1 if epsilon_{t-1} < 0, and 0 otherwise.

The indicator function I_{t-1} means that negative shocks contribute an additional gamma * epsilon_{t-1}^2 to the variance. When gamma > 0, bad news has a bigger effect than good news. This is sometimes called the threshold GARCH or TGARCH.

Comparison of GARCH Variants

Fitting EGARCH and GJR-GARCH in Python

from arch import arch_model

# EGARCH
egarch = arch_model(pct_returns, vol="EGARCH", p=1, q=1, mean="Constant")
egarch_result = egarch.fit(disp="off")
print("=== EGARCH ===")
print(f"omega: {egarch_result.params['omega']:.4f}")
print(f"alpha: {egarch_result.params['alpha[1]']:.4f}")
print(f"gamma: {egarch_result.params['gamma[1]']:.4f}")
print(f"beta:  {egarch_result.params['beta[1]']:.4f}")
print()

# GJR-GARCH
gjr = arch_model(pct_returns, vol="Garch", p=1, o=1, q=1, mean="Constant")
gjr_result = gjr.fit(disp="off")
print("=== GJR-GARCH ===")
print(f"omega: {gjr_result.params['omega']:.6f}")
print(f"alpha: {gjr_result.params['alpha[1]']:.4f}")
print(f"gamma: {gjr_result.params['gamma[1]']:.4f}")
print(f"beta:  {gjr_result.params['beta[1]']:.4f}")

When fitting to real equity return data, you'll almost always find a significant asymmetric term - confirming that negative shocks drive more subsequent volatility than positive shocks.

---

Applications of GARCH Models

GARCH models are used across quantitative finance wherever time-varying volatility matters. Here are the most important applications in 2026.

Value at Risk (VaR) Calculation

VaR estimates the maximum loss over a given period at a specified confidence level. A GARCH-based VaR uses the conditional variance forecast rather than a fixed historical estimate, making it responsive to current market conditions.

from scipy.stats import norm

confidence = 0.99
portfolio_value = 1_000_000  # GBP

# Use the latest conditional volatility from our GARCH model
daily_vol = result.conditional_volatility.iloc[-1] / 100
z_score = norm.ppf(confidence)

var_1day = portfolio_value * z_score * daily_vol
var_10day = var_1day * np.sqrt(10)

print(f"Portfolio value:   GBP {portfolio_value:,.0f}")
print(f"Daily vol:         {daily_vol:.4%}")
print(f"1-day 99% VaR:     GBP {var_1day:,.0f}")
print(f"10-day 99% VaR:    GBP {var_10day:,.0f}")

The advantage over fixed-variance VaR is clear: when volatility spikes, the GARCH-based VaR immediately increases, signalling higher risk. A static VaR would only catch up after the elevated volatility appeared in the trailing historical window. This makes GARCH VaR essential for risk management at banks and hedge funds.

Options Pricing

The Black-Scholes model assumes constant volatility, which is plainly wrong. One practical approach is to use a GARCH forecast as the volatility input. Since GARCH provides a term structure of variance forecasts (different forecasts for different horizons), you can compute the average expected variance over the life of the option and take its square root to get a GARCH-implied volatility.

This creates a connection between GARCH and implied volatility. If the GARCH-implied vol is lower than the market-implied vol, options look expensive relative to your model. If it's higher, options look cheap. This comparison drives many volatility trading strategies.

Risk Budgeting and Position Sizing

If you're running a portfolio with a target volatility - say 10% annualised - you need real-time estimates of each asset's volatility and cross-asset correlations. GARCH provides the per-asset volatility estimates. Multivariate extensions like DCC-GARCH (Dynamic Conditional Correlation) model time-varying correlations as well, giving you a complete covariance matrix that updates daily.

With these estimates, you can scale position sizes inversely with volatility. When an asset becomes more volatile, you reduce exposure to keep the portfolio's overall risk constant. This is the basis of volatility-targeting strategies used widely by systematic funds.

Volatility Forecasting for Trading Signals

GARCH volatility forecasts can be combined with return forecasts to produce risk-adjusted trading signals. A signal that predicts a 1% return is much more interesting when daily vol is 0.5% (a 2-sigma move) than when daily vol is 3% (a 0.33-sigma move). Normalising return forecasts by GARCH volatility estimates is standard practice in quantitative trading.

---

Limitations of the GARCH Model

GARCH models are powerful but not perfect. Understanding their limitations helps you apply them appropriately.

Distributional Assumptions

The standard GARCH model with normal errors underestimates the frequency of extreme returns. Financial returns have fatter tails than the normal distribution predicts. You can partially fix this by fitting GARCH with Student's t-distributed or skewed-t errors (both supported by the arch library), but the model still imposes a parametric distribution. Extreme tail events - the kind that matter most for risk management - are inherently difficult to model.

Structural Breaks

GARCH assumes the parameters omega, alpha, and beta are constant over the entire sample. But markets change. A regulatory shift, a new monetary policy regime, or a structural change in market microstructure can alter the volatility dynamics permanently. When you fit GARCH over a sample that includes a structural break, the model tries to compromise between the two regimes, often producing misleadingly high persistence. If alpha + beta is suspiciously close to 1, consider whether a structural break is the real explanation.

Symmetric Response (Standard GARCH)

The basic GARCH(1,1) treats positive and negative shocks identically. In equity markets, negative returns almost always increase volatility more than positive returns of the same size. The EGARCH and GJR-GARCH variants address this, and in 2026 there's little reason to use symmetric GARCH for equity indices. For other assets - currencies, some commodities - the asymmetry is less pronounced, and standard GARCH may be adequate.

No Mechanism for Jumps

GARCH models smooth transitions in volatility through the autoregressive structure. They can't capture sudden jumps - a flash crash, an unexpected central bank announcement, or a geopolitical event that instantly doubles volatility. Jump-diffusion models or regime-switching models are better suited to these dynamics, though they're considerably more complex to estimate.

Forecast Horizon

GARCH forecasts are most accurate at short horizons (one to five days). As the forecast horizon extends, the prediction reverts towards the unconditional variance and loses discriminatory power. For horizons beyond a month, GARCH adds diminishing value over a simple historical average. This is consistent with the broader finding that autocorrelation in squared returns - the feature GARCH is designed to capture - decays over time.

---

Frequently Asked Questions

What does GARCH stand for?

GARCH stands for Generalised Autoregressive Conditional Heteroscedasticity. Breaking it down: "Generalised" because it extends the earlier ARCH model by adding lagged variance terms; "Autoregressive" because today's variance depends on its own past values; "Conditional" because the variance is conditional on past information; and "Heteroscedasticity" because the variance isn't constant - it changes over time. The name is a mouthful, but the idea is simple: variance today depends on what happened yesterday, and this dependence can be modelled explicitly. Tim Bollerslev introduced the GARCH framework in 1986 as an extension of Robert Engle's ARCH model from 1982.

What is the difference between ARCH and GARCH?

ARCH models today's variance as a function of past squared residuals only. GARCH adds lagged conditional variance terms. In practice, this means a GARCH(1,1) with just three parameters can capture the same long memory in volatility that would require an ARCH model with 20 or more parameters. The GARCH term (beta * sigma_{t-1}^2) acts as an exponentially decaying summary of all past squared shocks, making the model far more parsimonious. For this reason, GARCH almost entirely replaced pure ARCH models in applied work. You'll rarely encounter ARCH models beyond order 1 in practice today.

What does GARCH(1,1) mean?

The (1,1) specifies the model order. The first number is p, the number of lagged conditional variance terms (GARCH terms). The second number is q, the number of lagged squared residual terms (ARCH terms). So GARCH(1,1) uses one lag of each: sigma_t^2 = omega + alpha * epsilon_{t-1}^2 + beta * sigma_{t-1}^2. Higher-order models like GARCH(2,1) or GARCH(1,2) are sometimes tested but rarely improve the fit for financial return data. Empirical research across equities, bonds, currencies, and commodities consistently finds that GARCH(1,1) is sufficient. It's the default starting point for almost all applied work.

How do I choose between GARCH, EGARCH, and GJR-GARCH?

Start with GARCH(1,1) as a baseline. Then fit EGARCH and GJR-GARCH and compare them using information criteria (AIC or BIC) and likelihood ratio tests. For equity indices and individual stock returns, the asymmetric models will almost always fit better because negative returns increase volatility more than positive returns. For currencies and some commodities, the asymmetry is weaker and GARCH(1,1) may be adequate. In 2026, the computational cost of fitting all three is negligible, so there's no reason not to compare them. The arch library makes switching between specifications a one-line change.

Can GARCH be used for cryptocurrency volatility?

Yes, and it's increasingly common. Cryptocurrency returns exhibit strong volatility clustering - arguably even stronger than traditional assets - making GARCH models highly applicable. The main considerations are that crypto trades 24/7 (so "daily" returns cover different time spans than equity returns) and that the tails are extremely fat. Using Student's t or skewed-t error distributions rather than normal errors is particularly important for crypto. Researchers have found that GARCH(1,1) fits Bitcoin and Ethereum return series well, with persistence (alpha + beta) often very close to 1, indicating that volatility shocks dissipate very slowly.

What is the unconditional variance in a GARCH model?

The unconditional variance is the long-run average variance that the process reverts to over time. For GARCH(1,1), it equals omega / (1 - alpha - beta), and it exists only when alpha + beta < 1. Think of it as the "normal" level of volatility when no recent shock is pushing variance above or below equilibrium. If you estimate omega = 0.00001, alpha = 0.07, and beta = 0.91, the unconditional variance is 0.00001 / 0.02 = 0.0005. Converting to annualised volatility: sqrt(0.0005 * 252) is roughly 35.5%. This figure is useful as a benchmark - it tells you where volatility is heading in the long run, regardless of where it sits today.