Skip to main content
v2026.11,986 entries · CC-BY 4.0

QuantLib: Quantitative Modeling and Valuation Guide

An exhaustive guide to QuantLib for financial quantitative analysis, covering pricing engine architectures, valuation formulas, and multi-language workflows.

Written and maintained by CASRAI Editorial Board

Published

On this page

QuantLib is an open-source, comprehensive C++ software library designed for financial instrument valuation, term structure modeling, risk management, and quantitative finance research across global capital markets. By enforcing a strict object-oriented design that decouples contract terms from pricing engines and stochastic market models, QuantLib provides academic researchers and financial practitioners with a modular, highly extensible platform accessible through native C++ as well as high-level language bindings including Python, R (via RQuantLib), and Excel.

What is QuantLib and how is its architecture structured?

QuantLib originated in the early 2000s as an open-source initiative led by Luigi Ballabio, Ferdinando Ametrano, and Dirk Eddelbuettel to provide a standardized computational foundation for quantitative finance. In institutional finance and empirical research, quantitative modeling often suffers from tight architectural coupling: contract payoff definitions, cash flow schedules, numerical solvers, and stochastic market models are frequently tangled inside monolithic scripts. QuantLib eliminates this structural rigidity by implementing classic software design patterns, primarily the Strategy pattern, the Observer/Observable pattern, and the Template Method pattern.

The central abstraction in QuantLib is the Instrument class representing a financial contract—such as a European stock option, a fixed-coupon bond, or an interest rate swap. Crucially, the instrument does not calculate its own price; it delegates valuation to an independent PricingEngine object. For example, a VanillaOption can be priced analytically using AnalyticEuropeanEngine, through numerical trees using BinomialVanillaEngine, or via stochastic simulation using MCEuropeanEngine. This separation prevents a combinatorial explosion of code: adding a novel pricing engine does not alter existing instruments, and introducing a new instrument does not require rewriting underlying numerical solvers.

Market data dependencies are orchestrated through QuantLib’s reactive Observable and Observer framework. Market quotes, discount curves, and volatility surfaces are wrapped in Quote and Handle structures. When an underlying market quote changes, notifications cascade automatically through dependent term structures, invalidating cached intermediate calculations and signaling observing instruments that their Net Present Value (NPV) must be recalculated upon inquiry. Researchers can integrate these components into modular computational pipelines, similar to how stateful processes are structured in discrete-event simulation with SimPy to coordinate dynamic system events.

Mathematical foundations: Black-Scholes-Merton option pricing and term structure discounting

At the foundation of quantitative option pricing is the Black-Scholes-Merton (BSM) differential framework. Under the risk-neutral measure Q, the price of an underlying asset S follows geometric Brownian motion: dS(t) = (r – q) S(t) dt + σ S(t) dW(t), where r is the risk-free rate, q is the continuous dividend yield, σ is annualized asset volatility, and W(t) is a standard Wiener process. For a plain-vanilla European call option with strike price K and maturity T years, the closed-form valuation formula implemented by QuantLib’s AnalyticEuropeanEngine is defined as:

C(S, K, r, q, σ, T) = S exp(-q T) N(d₁) – K exp(-r T) N(d₂)

Correspondingly, the fair value of a European put option is given by put-call parity as:

P(S, K, r, q, σ, T) = K exp(-r T) N(-d₂) – S exp(-q T) N(-d₁)

The standardized intermediate variables d₁ and d₂ represent normalized distance metrics to exercise, defined by:

d₁ = [ln(S / K) + (r – q + 0.5 σ²) T] / [σ √(T)], and d₂ = d₁ – σ √(T)

Here, N(·) denotes the standard normal cumulative distribution function (CDF), defined as N(x) = (1 / √(2π)) ∫ exp(-u² / 2) du evaluated from negative infinity to x. The term S exp(-q T) N(d₁) reflects the present value of receiving the underlying asset conditional on exercise, while K exp(-r T) N(d₂) reflects the present value of paying the strike price.

Beyond fair pricing, QuantLib calculates analytical parameter sensitivities (the Greeks):

  • Delta (Δ): Spot price sensitivity: Δ_call = exp(-q T) N(d₁); Δ_put = -exp(-q T) N(-d₁).
  • Gamma (Γ): Delta curvature with respect to spot: Γ = [exp(-q T) N'(d₁)] / [S σ √(T)].
  • Vega (ν): Sensitivity to volatility: ν = S exp(-q T) N'(d₁) √(T).
  • Theta (Θ): Time decay rate: Θ_call = -[S σ exp(-q T) N'(d₁)] / [2 √(T)] + q S exp(-q T) N(d₁) – r K exp(-r T) N(d₂).
  • Rho (ρ): Interest rate sensitivity: ρ_call = K T exp(-r T) N(d₂); ρ_put = -K T exp(-r T) N(-d₂).

Where N'(x) = (1 / √(2π)) exp(-x² / 2) is the standard normal probability density function (PDF). For zero-coupon discounting, QuantLib defines the discount factor P(0, T) as P(0, T) = exp(-R(0, T) T), where R(0, T) represents the continuously compounded zero rate for maturity T. Correctly applying discount factors is as fundamental to quantitative valuation as mastering covariance calculation methods when analyzing co-movements across asset returns.

Worked example: Step-by-step European option valuation and Greeks calculation

To illustrate the exact arithmetic performed by QuantLib’s AnalyticEuropeanEngine, consider valuing a European call and put option on an equity index with the following concrete market parameters:

  • Spot price (S): $100.00
  • Strike price (K): $100.00 (at-the-money)
  • Continuously compounded risk-free rate (r): 5.0% per annum (0.05)
  • Continuously compounded dividend yield (q): 2.0% per annum (0.02)
  • Annualized asset volatility (σ): 20.0% per annum (0.20)
  • Time to maturity (T): 1.00 year (365 days)

Step 1: Compute intermediate variables d₁ and d₂
Log moneyness: ln(S / K) = ln(100 / 100) = 0.000000.
Drift term: (r – q + 0.5 σ²) T = (0.05 – 0.02 + 0.5 × 0.20²) × 1.0 = 0.050000.
Volatility scaling: σ √(T) = 0.20 × √(1.0) = 0.200000.
Metrics: d₁ = 0.050000 / 0.200000 = 0.250000; d₂ = 0.250000 – 0.200000 = 0.050000.

Step 2: Evaluate normal distribution and density functions
N(d₁) = N(0.25) = 0.598706; N(d₂) = N(0.05) = 0.519939.
N(-d₁) = N(-0.25) = 0.401294; N(-d₂) = N(-0.05) = 0.480061.
Density: N'(0.25) = (1 / √(2π)) exp(-0.25² / 2) = 0.398942 × 0.969233 = 0.386668.

Step 3: Evaluate discount factors and compute option prices
Dividend discount factor: exp(-q T) = exp(-0.02 × 1.0) = 0.980199.
Risk-free discount factor: exp(-r T) = exp(-0.05 × 1.0) = 0.951229.
Call Price: C = [100.00 × 0.980199 × 0.598706] – [100.00 × 0.951229 × 0.519939] = 58.6850 – 49.4580 = $9.2270.
Put Price: P = [100.00 × 0.951229 × 0.480061] – [100.00 × 0.980199 × 0.401294] = 45.6648 – 39.3347 = $6.3301.
Put-Call Parity Verification: C – P = 9.2270 – 6.3301 = 2.8969; S exp(-q T) – K exp(-r T) = 98.0199 – 95.1229 = 2.8970.

Step 4: Compute analytical Greeks
• Delta (Call): Δ = 0.980199 × 0.598706 = 0.5869; Delta (Put): Δ = -0.980199 × 0.401294 = -0.3933.
• Gamma: Γ = [0.980199 × 0.386668] / [100.00 × 0.20 × 1.0] = 0.018951.
• Vega: ν = 100.00 × 0.980199 × 0.386668 × 1.0 = 37.9012 (value change per unit volatility shift).
• Theta (Call, annual): Θ = -3.7901 + 1.1737 – 2.4729 = -5.0893 per annum (-0.01394 per calendar day).
• Rho (Call): ρ = 100.00 × 1.0 × 0.951229 × 0.519939 = 49.4581 (0.4946 per 100 basis points).

In QuantLib, instantiating ql.VanillaOption(payoff, exercise) with ql.AnalyticEuropeanEngine(bsm_process) yields NPV = 9.2270, Delta = 0.5869, Gamma = 0.01895, Vega = 37.9012, and Theta = -5.0893, demonstrating exact arithmetic parity.

Interpretation of pricing metrics and pricing engine selection

Interpreting QuantLib pricing metrics requires understanding how statistical outputs translate into market risk exposures. The computed call price of $9.2270 represents the theoretical risk-neutral cost of replicating the option payoff using the underlying asset and risk-free cash. A Delta of 0.5869 dictates that an options dealer must purchase 0.5869 shares of underlying stock to form a delta-neutral hedge against one written call. Gamma (0.018951) quantifies the convex sensitivity of Delta to underlying price shifts: a $1.00 move in spot shifts Delta to approximately 0.6058. Vega (37.9012) indicates that a 1 percentage point shift in implied volatility (from 20% to 21%) adds approximately $0.3790 to the option premium.

Choosing the correct pricing engine within QuantLib is a foundational methodological decision. While analytical engines execute instantaneously, they are restricted to contracts with closed-form solutions and European exercise boundaries. The dataset below details the full comparative specifications across QuantLib pricing engines.

  • Closed-Form Analytic Engines: Ideal for European options, caps, floors, and vanilla swaptions. They offer microsecond computation times and exact analytical Greeks, making them the standard choice for real-time risk engines and volatility calibration.
  • Lattice and Tree Engines: Required for early-exercise American and Bermudan contracts. Binomial and trinomial trees step backward through time from expiry to evaluate optimal early exercise boundaries at each intermediate node.
  • Finite Difference Engines: Solves governing partial differential equations over discretized spatial and temporal grids. Best suited for low-dimensional exotic contracts, barrier options, and local volatility specifications.
  • Monte Carlo Simulation Engines: Indispensable for complex path-dependent payoffs (e.g. Asian, lookback, and barrier options) and multi-asset basket derivatives. Researchers frequently combine these tools with Monte Carlo simulation techniques when evaluating high-dimensional asset distributions.

Term structure modeling, yield curve bootstrapping, and day count conventions

A central strength of QuantLib’s financial architecture is its yield curve term structure engine. In contemporary fixed income modeling, there is no single monolithic interest rate. Interest rates vary across maturities, credit risk tiers, and collateral agreements. QuantLib constructs zero-coupon and forward discount curves through piecewise bootstrapping algorithms implemented in PiecewiseYieldCurve. Bootstrapping takes liquid market benchmark quotes—such as short-term deposit rates, overnight index swap (OIS) rates, forward rate agreements (FRAs), and interest rate swap rates—and solves sequentially for discount factors ensuring that every input benchmark instrument reprices to par.

A frequent pitfall in quantitative empirical research is neglecting calendar and day count accrual conventions. QuantLib provides explicit classes governing accrual mathematics:

  • Actual360: Calculates the accrual fraction as actual elapsed days divided by 360. Dominant in US money markets and commercial paper.
  • Actual365Fixed: Computes elapsed days divided by 365, standard in UK money markets and equity derivative benchmarks.
  • Thirty360: Uses 30-day month conventions (such as 30/360 Bond Basis or European 30E/360), widely used in corporate and municipal bond markets.
  • ActualActual: Corrects for leap years according to ISDA, ISMA, or AFB conventions, required for sovereign bond pricing.

Combined with day counters are settlement calendars (such as UnitedStates, TARGET, and UnitedKingdom). QuantLib dynamically adjusts cash flow payment dates using business day rolling conventions (Following, Modified Following, Preceding, and Modified Preceding). Neglecting the precise calendar convention introduces systematic settlement misalignment into yield curve calibration.

Assumptions, methodological constraints, and common implementation mistakes

When deploying QuantLib in academic studies and production systems, analysts must navigate key theoretical assumptions and software architecture rules:

  1. Constant Parameter Misapplication: The basic Black-Scholes-Merton engine assumes constant volatility and risk-free rates across the contract horizon. Empirical market prices demonstrate pronounced volatility skews and smiles across strikes. Using BlackConstantVol for multi-strike options distorts out-of-the-money valuations; researchers should calibrate stochastic volatility engines (AnalyticHestonEngine) instead.
  2. Negative Interest Rate Incompatibility: Classical Black-76 and Black-Scholes frameworks assume log-normal distributions, rendering them mathematically incapable of handling negative rates. In modern post-crisis fixed income markets with sub-zero benchmark yields, log-normal calibration fails. QuantLib resolves this through normal Bachelier engines (such as BachelierCapFloorEngine) and shifted Black models.
  3. Dangling Handles and Quote Lifecycle Leaks: In QuantLib-Python and C++, term structures rely on RelinkableHandle wrappers. A frequent defect occurs when a temporary SimpleQuote falls out of scope while its handle remains referenced by a pricing engine. This can lead to segmentation faults or stale valuation calculations.
  4. Curve Interpolation Artifacts: When bootstrapping piecewise yield curves, choosing an unsuitable interpolation method (such as raw linear interpolation on discount factors) can induce erratic fluctuations in instantaneous forward rates, creating artificial arbitrage opportunities.

How to report QuantLib models and results in academic research (APA 7th)

In academic finance, empirical econometrics, and institutional risk governance, derivative valuation methodologies must meet rigorous transparency requirements. When reporting pricing models, calibrations, or risk simulations conducted with QuantLib, authors should document the library version, stochastic processes, day count conventions, and calibration error statistics.

In accordance with the Publication Manual of the American Psychological Association (APA 7th edition), software libraries and analytical tools must be cited in both text and the reference list. Authors should cite Luigi Ballabio’s foundational architectural text or the interface packages utilized in the study.

APA 7th Reference List Entries:

  • Ballabio, L. (2014). Implementing QuantLib: Quantitative finance in C++. Leanpub. https://implementingquantlib.com/
  • Ballabio, L., and Joshi, M. (2008). QuantLib: An open source framework for quantitative finance [Computer software]. https://www.quantlib.org/
  • Eddelbuettel, D., and Khan, K. (2024). RQuantLib: R interface to the ‘QuantLib’ library (R package version 0.4.23) [Computer software]. Comprehensive R Archive Network. https://cran.r-project.org/package=RQuantLib
  • QuantLib Project. (2024). QuantLib-Python: Python wrappers for QuantLib (Version 1.35) [Computer software]. Python Package Index. https://pypi.org/project/QuantLib/

Illustrative In-Text Reporting Composite:

‘All European and American equity options were valued using QuantLib (Version 1.35; Ballabio and Joshi, 2008) via the Python interface. Discount factor curves were constructed using a piecewise log-linear yield term structure (Actual/365 Fixed day count convention) bootstrapped from sovereign benchmark yields. European contracts were priced via the closed-form Black-Scholes-Merton analytic engine (AnalyticEuropeanEngine), while early-exercise American options were evaluated using a 500-step Cox-Ross-Rubinstein binomial lattice (BinomialVanillaEngine). Calibration error across 1,420 out-of-the-money put options yielded a Root Mean Square Error (RMSE) of $0.142 and a Mean Absolute Percentage Error (MAPE) of 1.18%.’

How to calculate option pricing and Greeks in Excel, R, and Python

QuantLib and its underlying valuation formulas are accessible across multiple computing environments. Below are parallel, verified implementations of the Black-Scholes-Merton European call option valuation from our worked example across Microsoft Excel, R, and Python.

1. Microsoft Excel Formula Implementation

In standard Microsoft Excel, European option pricing and Greeks can be computed directly using native worksheet functions. Assuming parameters are stored in cells: S in B1 (100), K in B2 (100), r in B3 (0.05), q in B4 (0.02), σ in B5 (0.20), and T in B6 (1.0):

=LET(
  S, B1, K, B2, r, B3, q, B4, vol, B5, T, B6,
  d1, (LN(S/K) + (r - q + 0.5 * vol^2) * T) / (vol * SQRT(T)),
  d2, d1 - vol * SQRT(T),
  call_price, S * EXP(-q * T) * NORM.S.DIST(d1, TRUE) - K * EXP(-r * T) * NORM.S.DIST(d2, TRUE),
  delta, EXP(-q * T) * NORM.S.DIST(d1, TRUE),
  gamma, (EXP(-q * T) * NORM.S.DIST(d1, FALSE)) / (S * vol * SQRT(T)),
  vega, S * EXP(-q * T) * NORM.S.DIST(d1, FALSE) * SQRT(T),
  call_price
)

Users with the QuantLib-XL add-in installed can alternatively call the native C++ engine directly: =qlEuropeanOption(B1, B2, B4, B3, B6, B5, "Call").

2. R Implementation via RQuantLib

In R, the CRAN package RQuantLib wraps QuantLib’s C++ pricing engines, providing high-performance vectorized valuation routines:

# Install and load RQuantLib from CRAN
if (!requireNamespace("RQuantLib", quietly = TRUE)) install.packages("RQuantLib")
library(RQuantLib)

# Value a European Call Option matching the worked example
opt <- EuropeanOption(
  type = "call",
  underlying = 100.0,
  strike = 100.0,
  dividendYield = 0.02,
  riskFreeRate = 0.05,
  maturity = 1.0,
  volatility = 0.20
)

# Print computed fair value and Greeks
cat(sprintf("Fair Value: %.4fn", opt$value))
cat(sprintf("Delta:      %.4fn", opt$delta))
cat(sprintf("Gamma:      %.6fn", opt$gamma))
cat(sprintf("Vega:       %.4fn", opt$vega))
cat(sprintf("Theta:      %.4fn", opt$theta))
cat(sprintf("Rho:        %.4fn", opt$rho))

3. Python Implementation via QuantLib-Python

In Python, the QuantLib package (installed via pip install QuantLib) provides full access to the object-oriented architecture. Researchers can combine this workflow with random sampling routines in Python when executing stochastic simulations:

import QuantLib as ql

# 1. Set valuation date
eval_date = ql.Date(14, ql.November, 2026)
ql.Settings.instance().evaluationDate = eval_date

# 2. Specify day count and calendar conventions
day_counter = ql.Actual365Fixed()
calendar = ql.NullCalendar()

# 3. Set contract characteristics
maturity_date = eval_date + ql.Period(1, ql.Years)
strike_price = 100.0
payoff = ql.PlainVanillaPayoff(ql.Option.Call, strike_price)
exercise = ql.EuropeanExercise(maturity_date)
option = ql.VanillaOption(payoff, exercise)

# 4. Construct market quotes and term structures
spot_handle = ql.QuoteHandle(ql.SimpleQuote(100.0))
rate_handle = ql.YieldTermStructureHandle(
    ql.FlatForward(eval_date, 0.05, day_counter)
)
div_handle = ql.YieldTermStructureHandle(
    ql.FlatForward(eval_date, 0.02, day_counter)
)
vol_handle = ql.BlackVolTermStructureHandle(
    ql.BlackConstantVol(eval_date, calendar, 0.20, day_counter)
)

# 5. Assemble Black-Scholes-Merton process and engine
bsm_process = ql.BlackScholesMertonProcess(
    spot_handle, div_handle, rate_handle, vol_handle
)
engine = ql.AnalyticEuropeanEngine(bsm_process)
option.setPricingEngine(engine)

# 6. Extract results
print(f"NPV:   {option.NPV():.4f}")
print(f"Delta: {option.delta():.4f}")
print(f"Gamma: {option.gamma():.6f}")
print(f"Vega:  {option.vega():.4f}")
print(f"Theta: {option.theta():.4f}")
print(f"Rho:   {option.rho():.4f}")

Frequently asked questions

What is the primary difference between QuantLib and scientific libraries like SciPy or NumPy?

While general scientific libraries provide foundational numerical solvers, QuantLib is purpose-built for financial engineering. It encapsulates financial business day conventions, settlement calendars, day count accrual rules, multi-curve yield bootstrapping, and standardized derivative pricing engines, ensuring market-consistent valuations without requiring custom infrastructure.

How does QuantLib handle negative interest rates?

Classical Black-Scholes models assume log-normal distributions that fail in negative interest rate environments. QuantLib addresses sub-zero rates by providing normal Bachelier pricing engines (such as BachelierCapFloorEngine) and shifted log-normal Black engines, allowing robust valuation of interest rate caps, floors, and swaptions.

Can QuantLib price American and Bermudan early-exercise options?

Yes. QuantLib values American and Bermudan options using numerical lattice engines (BinomialVanillaEngine), finite difference partial differential equation solvers (FdBlackScholesVanillaEngine), and Least Squares Monte Carlo algorithms (MCAmericanEngine using the Longstaff-Schwartz method) to identify optimal exercise boundaries.

What is the difference between QuantLib and QuantLib-Python?

QuantLib is implemented in high-performance C++ for execution speed. QuantLib-Python provides official SWIG-generated Python language bindings, allowing researchers to build models and orchestrate financial pipelines using Python while retaining C++ calculation performance.

Why does changing a Quote object in QuantLib automatically update dependent instruments?

QuantLib implements the Observer/Observable software design pattern. Instruments register as observers of market quotes. When a quote is modified via setValue(), it sends notification signals that invalidate cached results across dependent curves and instruments, triggering recalculation upon the next valuation call.

How do calendar and day count conventions impact pricing in QuantLib?

Financial instruments accrue cash flows and discount cash flows according to formal market conventions. For example, switching from Actual365Fixed to Actual360 increases the annual accrual fraction from 1.000 to 1.0139, altering discount factors, forward rate curves, and option time decay.

Sources

  • QuantLib Project. (2026). QuantLib reference documentation. https://www.quantlib.org/docs.shtml (Accessed 2026-11-14).
  • Ballabio, L. (2014). Implementing QuantLib: Quantitative finance in C++. Leanpub. https://implementingquantlib.com/ (Accessed 2026-11-14).
  • Eddelbuettel, D., and Khan, K. (2024). RQuantLib: R interface to the ‘QuantLib’ library. Comprehensive R Archive Network. https://cran.r-project.org/web/packages/RQuantLib/index.html (Accessed 2026-11-14).
  • QuantLib Project. (2024). QuantLib-Python documentation. Python Package Index. https://pypi.org/project/QuantLib/ (Accessed 2026-11-14).
  • Black, F., and Scholes, M. (1973). The pricing of options and corporate liabilities. Journal of Political Economy, 81(3), 637–654. https://www.jstor.org/stable/1831029 (Accessed 2026-11-14).
  • Merton, R. C. (1973). Theory of rational option pricing. Bell Journal of Economics and Management Science, 4(1), 141–183. https://www.jstor.org/stable/3003143 (Accessed 2026-11-14).

Data: QuantLib Pricing Engine Architecture and Numerical Methods Comparison

Comprehensive comparative benchmark of primary QuantLib pricing engines, mapping underlying financial models, numerical solution methods, supported exercise styles, and computational complexity based on official QuantLib documentation and Luigi Ballabio's Implementing QuantLib architecture specifications.

QuantLib Pricing Engine Architecture and Numerical Methods Comparison
Pricing EngineUnderlying ModelNumerical MethodSupported ExerciseComputational ComplexityPrimary Asset / Contract
AnalyticEuropeanEngineBlack-Scholes-MertonClosed-form AnalyticEuropeanO(1) InstantaneousVanilla equity and FX options
BachelierCapFloorEngineBachelier (Normal)Closed-form NormalEuropeanO(1) InstantaneousInterest rate caps and floors in negative rate regimes
BinomialVanillaEngineCox-Ross-Rubinstein / Jarrow-RuddBinomial Tree LatticeAmerican, Bermudan, EuropeanO(N^2) Quadratic in tree stepsSingle-asset early-exercise equity options
MCEuropeanEngineBlack-Scholes-Merton StochasticMonte Carlo Path SimulationEuropeanO(M * N) Linear in paths and stepsPath-dependent and multi-asset European derivatives
FdBlackScholesVanillaEngineLocal / Black-Scholes PDEFinite Difference (Crank-Nicolson)American, Bermudan, EuropeanO(M * N) Spatial and temporal meshBarrier and American options with discrete dividends
AnalyticHestonEngineHeston Stochastic VolatilitySemi-Analytic Fourier TransformEuropeanO(K) Numerical quadratureOptions with volatility skew and smile dynamics
TreeSwaptionEngineHull-White One-Factor Short RateTrinomial Tree LatticeBermudan, EuropeanO(N^2) Lattice backward inductionBermudan and European interest rate swaptions
JamshidianSwaptionEngineOne-Factor Hull-White / GaussianAnalytical One-Dimensional IntegrationEuropeanO(K) Numerical root findingVanilla European interest rate swaptions

Sources

Compiled by CASRAI from the sources above. Free to reuse under CC BY 4.0 with attribution.

Follow CASRAI

Research-administration guidance, standards updates and independent tool reviews.

Ask CASRAI · free to try

Ask about QuantLib: Quantitative Modeling and Valuation Guide

2 free questions a day, no account.

An AI assistant for research: funder rules, compliance, methods and publishing. It links the sources behind its answers and labels answers that come from a web search.

Answers draw on CASRAI's guides and dictionary plus the federal and funder documents we index: Federal Register, Grants.gov, Regulations.gov and UKRI.

Works on this site and inside Claude, Cursor and the AI tools you already use.

Everything CASRAI publishes — this page, the dictionary, the guides and the news — stays open to read, with no account and no card.

Referenced across the research world

University of Cambridge logoColumbia University logoCrossref logoUniversity of Edinburgh logoHarvard University logoUniversity of Oxford logoPrinceton University logoStanford School of Medicine logoUniversity College London logoORCID logoUniversity of Cambridge logoColumbia University logoCrossref logoUniversity of Edinburgh logoHarvard University logoUniversity of Oxford logoPrinceton University logoStanford School of Medicine logoUniversity College London logoORCID logo
  • University of Cambridge logo
  • Columbia University logo
  • Crossref logo
  • University of Edinburgh logo
  • Harvard University logo
  • University of Oxford logo
  • Princeton University logo
  • Stanford School of Medicine logo
  • University College London logo
  • ORCID logo

View CASRAI adoption →