---
title: "How does LUSID calculate exposure?"
slug: "how-does-lusid-calculate-exposure"
tags: ["risk", "exposure"]
updated: 2026-11-06T13:53:49Z
published: 2026-11-06T13:53:49Z
canonical: "support.lusid.com/how-does-lusid-calculate-exposure"
---

> ## Documentation Index
> Fetch the complete documentation index at: https://support.lusid.com/llms.txt
> Use this file to discover all available pages before exploring further.

# How does LUSID calculate exposure?

Exposure tells you how much market risk a holding carries.

LUSID's calculation of exposure for each instrument type is based on the commitment approach in the [guidance provided by ESMA](https://www.esma.europa.eu/sites/default/files/library/2015/11/10_788.pdf) (the European Securities and Markets Authority). Where that guidance doesn't cover an instrument type, or its inputs aren't readily available, LUSID uses a calculation in the spirit of the guidance.

To report exposure for a holding when [valuing a portfolio](/v1/docs/how-do-i-perform-a-valuation), include metrics such as (not a definitive list):

- `Valuation/Exposure`: the holding's exposure in the currency the calculation uses (usually the instrument currency).
- `Valuation/InstrumentExposure`: the exposure of one unit of the instrument.
- `Valuation/ExposureInPortfolioCcy` and `Valuation/ExposureInReportCcy`: the holding's exposure converted at the spot rate.
- `Valuation/TotalPortfolioExposureInPortfolioCcy` and `Valuation/TotalPortfolioExposureInReportCcy`.
- `Aggregation/NetExposureFraction` and `Aggregation/GrossExposureFraction`: total exposure, and total absolute exposure, as a fraction of total PV. Every holding must be in the same currency; otherwise LUSID returns no value.
- `Aggregation/NetExposureWeight` and `Aggregation/GrossExposureWeight`: each holding's exposure, and absolute exposure, as a fraction of the portfolio's total PV, in the portfolio currency.
- `Valuation/ExposureMSCI`: exposure using the [MSCI methodology](/v1/docs/how-does-lusid-calculate-exposure#exposure-using-the-msci-methodology).

Note the following:

- You can call APIs in advance to understand which metrics might be [useful or valid to include in a valuation report](/v1/docs/which-metrics-can-i-include-in-my-valuation-report).
- Some instrument types [do not report exposure](/v1/docs/how-does-lusid-calculate-exposure#instruments-with-no-exposure).

## How LUSID calculates `Valuation/Exposure`

Every pricing model calculates the exposure of *one unit* of the instrument. LUSID then multiplies by the holding's `units`, so a short holding has a negative exposure. For a PIK bond, and for other bonds if you specify the `fixedIncomeValuationsUsingCurrentFace` [recipe option](/v1/docs/recipes-changing-default-recipe-options#bonds-asset-backed-securities-and-loans), LUSID multiplies by the holding's current face instead.

For one unit, LUSID uses the first of these rules that applies:

1. The pricing model calculates exposure itself. Futures, options, contracts for difference, equity swaps and FX forwards work this way.
2. The instrument type has a notional. For an `InterestRateSwap`, `ForwardRateAgreement`, `CreditDefaultSwap`, `CdsIndex`, `CapFloor`, `TermDeposit` or `FlexibleRepo`, exposure is a notional or a cash amount, not a value.
3. Otherwise, exposure is the value. For a `Bond`, `ComplexBond` or `InflationLinkedBond` it is the PV. For other instrument types it is PV minus accrued interest, where appropriate.

Note the following:

- Exposure isn't affected by an override of the holding's PV, clean PV or accrued interest. [See how to override delta or exposure](/v1/docs/how-does-lusid-calculate-exposure#overriding-delta-or-exposure).
- For an instrument that has matured, LUSID returns zero exposure if you specify the `returnZeroPv.instrumentMatured` [recipe option](/v1/docs/recipes-changing-default-recipe-options#handling-failures-matured-and-forward-starting-instruments). Otherwise the valuation fails for that holding, as it does for PV.
- Some instruments can report each leg as a separate row if you specify the `produceSeparateResultForLinearOtcLegs` [recipe option](/v1/docs/recipes-changing-default-recipe-options#legs-and-units).

In the equations below:

- *Price* is a quote's value divided by the quote's own `scaleFactor`.
- *Underlying price* is the price of the instrument underneath a derivative: the equity for an equity option, the future for an option on a future, and so on. LUSID looks it up in the Quote Store.
- *Delta* is the change in the option's value for a small change in the underlying price. It is between 0 and 1 for a call and between −1 and 0 for a put. In some circumstances you can [override LUSID's delta with your own](/v1/docs/how-does-lusid-calculate-exposure#overriding-delta-or-exposure).

### Equities

| **Instrument type (flavour)** | `Valuation/Exposure` **calculation** | Notes |
| --- | --- | --- |
| [Equity](/v1/docs/modelling-equities-in-lusid) (incl. ETF) | `(price / scale factor) * contract size * units` | The calculation is the [same as PV](/v1/docs/how-does-lusid-calculate-pv). |
| [ContractForDifference](/v1/docs/modelling-cfds-in-lusid) | `contract size * underlying price * FX rate * units`, where the FX rate converts the underlying's currency to the CFD's currency. For a `Futures`-type CFD, LUSID also discounts this from the maturity date. | Under the `SimpleStatic` pricing model, the calculation is the [same as PV](/v1/docs/how-does-lusid-calculate-pv#equity): `(price / scale factor) * contract size * units` |
| [EquitySwap](/v1/docs/modelling-equity-swaps-in-lusid) | `underlying price * quantity * units`, where quantity is the equity leg's quantity on the valuation date, adjusted for any stock split. | Under `SimpleStatic`, the calculation is the [same as clean PV](/v1/docs/how-does-lusid-calculate-pv#equity): `(price / scale factor) * contract size * units`, where contract size is the funding leg's notional. |
| [Future](/v1/docs/modelling-exchange-traded-futures-and-options-in-lusid) (equity, index, commodity, bond, and FX without a foreign currency) | `price * contract size * units`, where contract size is `contractDetails.contractSize`. This is the full contract value, whereas PV is the gain since the reference price. |  |
| `Future` (FX, with `contractDetails.fgnCcy` set) | `contract size * units`, in the foreign currency. |  |
| `Future` (with a `calculationType` of `IMM_1Month` or `IMM_3Month`) | `contract size * (100 - ((100 - price) / n)) / 100 * units`, where n is 12 for `IMM_1Month` and 4 for `IMM_3Month`. Example: contract size 1,000,000 and price 97 for `IMM_3Month` gives 992,500 per contract. An interest rate future without a `calculationType` uses the first row. |  |
| `Future` (ASX bank bill and bond futures) | The full contract value, calculated with the ASX pricing formula, `* units`. LUSID applies this automatically for exchange code `ASX`. |  |
| `Future` (with a `calculationType` of `B3_DI1`) | The full contract value `* units`, which is also its PV. |  |
| [ExchangeTradedOption](/v1/docs/modelling-exchange-traded-options-in-lusid) (equity, index, bond underlying) | `contract size * underlying price * delta * units`, where contract size is `contractDetails.contractSize`, the underlying is the instrument identified by `contractDetails.underlyingCode`, and delta is 1 unless you [override with your own](/v1/docs/how-does-lusid-calculate-exposure#overriding-delta-or-exposure). |  |
| `ExchangeTradedOption` (future underlying) | `contract size * underlying price * underlying contract size * delta * units`, where underlying contract size is the future's `contractDetails.contractSize`. |  |
| [EquityOption](/v1/docs/modelling-equity-options-in-lusid) | `number of shares * underlying price * delta * units`, where number of shares is `numberOfShares` (default 1). LUSID uses the underlying's price, not the option's. Under `BlackScholes`, `Bachelier` and `Discounting`, number of shares is adjusted for any stock split, and the underlying price is converted to the option's currency. | `delta` depends on the pricing model chosen: - `SimpleStatic`: 1 unless you [override with your own](/v1/docs/how-does-lusid-calculate-exposure#overriding-delta-or-exposure). - `BlackScholes` and `Bachelier`: Calculated by the pricing model. - `Discounting`: The discount factor to expiry if the option is in the money (negative for a put), and 0 otherwise. Under `ConstantTimeValueOfMoney`, the calculation is the [same as PV](/v1/docs/how-does-lusid-calculate-pv#equity). Note the `BjerksundStensland1993` pricing model [does not calculate exposure](/v1/docs/how-does-lusid-calculate-exposure#instruments-with-no-exposure). |

### Debt

The `Valuation/Exposure` calculation for the following instrument types is the [same as PV](/v1/docs/how-does-lusid-calculate-pv#debt):

- `Bond`
- `ComplexBond` (including PIK and asset-backed)
- `InflationLinkedBond`
- `BondForward`
- `ToBeAnnounced`
- `ToBeAnnouncedOption`
- `BondOption`

### Rates

| **Instrument type (flavour)** | `Valuation/Exposure` **calculation** | Notes |
| --- | --- | --- |
| `ForwardRateAgreement` | `notional * units` |  |
| [InterestRateSwap](/v1/docs/modelling-interest-rate-swaps-in-lusid) (vanilla, basis, OIS, amortising, cross-currency) | `notional * units`, where notional is the first leg's notional outstanding on the valuation date, in that leg's currency. It is positive whether you pay or receive the fixed rate. For a cross-currency swap with the `produceSeparateResultForLinearOtcLegs` [recipe option](/v1/docs/recipes-changing-default-recipe-options#legs-and-units) set, each leg reports its own notional outstanding in its own currency. This has no effect under `SimpleStatic`, which always reports one row. |  |
| [InflationSwap](/v1/docs/modelling-inflation-swaps-in-lusid) | Under `SimpleStatic`, the calculation is the [same as clean PV](/v1/docs/how-does-lusid-calculate-pv#rates): `(price / scale factor) * contract size * units` | Other pricing models [do not calculate exposure](/v1/docs/how-does-lusid-calculate-exposure#instruments-with-no-exposure). |
| `TermDeposit` | `(notional + interest to maturity) * units`, that is, the amount repaid at maturity. |  |
| `InterestRateSwaption` (European) | `notional * delta * units`, where notional is the first leg's notional of the underlying swap. | `delta` depends on the pricing model chosen: - `BlackScholes` and `Bachelier`: Calculated by the pricing model; negative for a receiver swaption. - `Discounting`: 1 if the swaption is in the money, 0 if it is out of the money, and 0.5 at the money (negative for a receiver swaption). Under the following pricing models, the calculation is [the same as PV](/v1/docs/how-does-lusid-calculate-pv#rates): - `SimpleStatic`: `(price / scale factor) * contract size * units`, where contract size is 1. - `DiscountedForward`: `contract size * discount factor * forward price * units`, from a forward premium quote and where contract size is 1. Note the `ConstantTimeValueOfMoney` pricing model [does not calculate exposure](/v1/docs/how-does-lusid-calculate-exposure#instruments-with-no-exposure), and nor does `Discounting` if the underlying swap has no single fixed rate. |
| `CapFloor` | `notional * units`, where notional is the underlying floating leg's notional. |  |

### Credit

| **Instrument type (flavour)** | `Valuation/Exposure` **calculation** | Notes |
| --- | --- | --- |
| `CreditDefaultSwap` | `notional * units` |  |
| [CdsIndex](/v1/docs/modelling-cds-index-instruments-in-lusid) | `notional * units`, where notional is the index's original notional. It isn't reduced for defaulted constituents. |  |
| `CdsOption` | `(price / scale factor) * contract size * units`, where contract size is the notional. | The calculation is the [same as PV](/v1/docs/how-does-lusid-calculate-pv#credit). |

### FX

| **Instrument type (flavour)** | `Valuation/Exposure` **calculation** | Notes |
| --- | --- | --- |
| [FxForward](/v1/docs/modelling-fxforwards-in-lusid) (deliverable, NDF) | The amount of each leg that isn't in the exposure currency, ignoring its sign and converted to the exposure currency at spot, added together and `* units`. The exposure currency is the report currency, if you specify one, otherwise the forward's domestic currency. So for a GBP/USD forward reported in GBP, exposure is the USD amount in GBP. | For a deliverable with the `produceSeparateResultForLinearOtcLegs` [recipe option](/v1/docs/recipes-changing-default-recipe-options#legs-and-units) set, each leg reports its own amount, signed, in its own currency. Under `SimpleStatic`, the calculation is the [same as PV](/v1/docs/how-does-lusid-calculate-pv#fx). |
| [FxSwap](/v1/docs/modelling-fx-swaps-in-lusid) | The exposure of the near forward plus the exposure of the far forward, calculated as for `FxForward`. A forward that has already settled contributes nothing. | Under `SimpleStatic`, the calculation is the [same as PV](/v1/docs/how-does-lusid-calculate-pv#fx). |
| [FxOption](/v1/docs/modelling-fx-options-in-lusid) (vanilla) | `delta * (domestic amount * strike / spot rate) * units`, in the option's contract currency. | `delta` depends on the pricing model chosen: - `BlackScholes`, `BjerksundStensland1993`: Calculated by the pricing model. - `Discounting`: 1 if the option is in the money and 0 otherwise. Under `SimpleStatic` (any flavour, including barrier and touch), `ConstantTimeValueOfMoney`, and `BlackScholesDigital` for a digital option, the calculation is the [same as PV](/v1/docs/how-does-lusid-calculate-pv#fx). Note the `Bachelier` pricing model [does not calculate exposure](/v1/docs/how-does-lusid-calculate-exposure#instruments-with-no-exposure). |

### Commodities

| **Instrument type (flavour)** | `Valuation/Exposure` **calculation** | Notes |
| --- | --- | --- |
| `CommodityForward` | `(price / scale factor) * contract size * units`, where contract size is 1. | The calculation is the [same as PV](/v1/docs/how-does-lusid-calculate-pv#commodities). |
| `CommodityCalendarSwap` |

### Volatility

| **Instrument type (flavour)** | `Valuation/Exposure` **calculation** | Notes |
| --- | --- | --- |
| `VolatilitySwap` | `(price / scale factor) * contract size * units`, where contract size is the notional divided by the price denominator. | The calculation is the [same as PV](/v1/docs/how-does-lusid-calculate-pv#volatility). |

### Securitised finance

| **Instrument type (flavour)** | `Valuation/Exposure` **calculation** | Notes |
| --- | --- | --- |
| [FlexibleRepo](/v1/docs/modelling-repurchase-agreements-in-lusid) | `collateral value * (purchase price outstanding / purchase price) * units` if the repo specifies a collateral value, otherwise `purchase price outstanding * units`. Purchase price outstanding allows for any partial closure. Exposure is positive for the buyer and negative for the seller. |  |
| `SimpleInstrument` (portfolio securitisation) | `(price / scale factor) * contract size * units`, where contract size is set in the instrument definition (default 1). | The calculation is the [same as PV](/v1/docs/how-does-lusid-calculate-pv#securitised-finance). |
| `TotalReturnSwap` | The PV of the whole swap minus accrued interest (its [clean PV](/v1/docs/how-does-lusid-calculate-pv#securitised-finance)), asset and funding legs together. Exposure is not the value of the underlying asset. | Under `SimpleStatic`: `(price / scale factor) * contract size * units`, where contract size is the bond's principal for a bond underlying; otherwise the funding leg's notional. |
| `PreferredShare` | `(price / scale factor) * contract size * units`, where contract size is 1. | The calculation is the [same as clean PV](/v1/docs/how-does-lusid-calculate-pv#securitised-finance). |

## Instrument types with no exposure

LUSID does not calculate exposure for the following instrument type and pricing model combinations. The `Valuation/Exposure` metric is blank for these holdings.

- `FlexibleLoan` and `FlexibleDeposit`, priced with `FlexibleLoanPricer`.
- `LoanFacility` and `WholeLoanFacility`, priced with `LoanFacilityPricer`.
- `CapitalInterest`, priced with `CapitalInterestPricer`.
- `InflationSwap`, priced with `InflationForward` or `ConstantTimeValueOfMoney`.
- `EquityOption` priced with `BjerksundStensland1993`.
- `FxOption` priced with `Bachelier`.
- `InterestRateSwaption` priced with `ConstantTimeValueOfMoney`, or with `Discounting` if the underlying swap has no single fixed rate.
- Any instrument priced with `OverrideOnly`, unless you [supply the exposure yourself](/v1/docs/how-does-lusid-calculate-exposure#overriding-delta-or-exposure).

## Exposure using the MSCI methodology

The `Valuation/ExposureMSCI` returns exposure using the [MSCI methodology](https://www.msci.com/). Note the following:

- For an option with a premium, it is the PV, which under an option pricing model is the option's value minus the discounted premium.
- For `ContractForDifference` under `ConstantTimeValueOfMoney` or `Discounting`, it is the same as `Valuation/Exposure`.
- It is blank for `FlexibleLoan`, `FlexibleDeposit`, `LoanFacility`, `WholeLoanFacility` and `CapitalInterest` priced with their own pricing models.
- It can have a value where `Valuation/Exposure` is blank, for example 0 for an `InterestRateSwaption` priced with `ConstantTimeValueOfMoney`, or the PV for an `FxOption` priced with `Bachelier`.

The `Aggregation/*ExposureFraction` and `Aggregation/*ExposureWeight` metrics each have an MSCI version, for example `Aggregation/GrossExposureFractionMSCI`.

## Exposure in lookthrough portfolios

When LUSID [looks through a holding to the portfolio underneath](/v1/docs/setting-up-and-valuing-a-fund-of-funds-portfolio), the `conservedQuantityForLookthroughExpansion` [recipe option](/v1/docs/recipes-changing-default-recipe-options#look-through-portfolios) decides what the expanded holdings preserve:

- `PV` (the default): each underlying holding is valued as normal, so its exposure follows the rules in this article.
- `Exposure`: each underlying holding's exposure is its weight multiplied by the parent holding's exposure, in the report currency.

## Overriding delta or exposure

You can load your own values into LUSID's [Structured Result Store](/v1/docs/what-is-structured-result-data) (SRS), and LUSID uses them instead of the values it calculates. Two addresses affect exposure:

- `UnitResult/Valuation/Delta` replaces the delta in the exposure calculation for an `ExchangeTradedOption` or `EquityOption` priced with `SimpleStatic`.
- `UnitResult/Valuation/InstrumentExposure` replaces the exposure of one unit of the instrument for any instrument type.

LUSID applies the value it finds as it is. For a meaningful delta, use a number between −1 and 1 that is positive for a call and negative for a put.

### Example: loading a delta into the SRS

To load a delta for an equity option:

1. Prepare a JSON or CSV document with a delta keyed by the LUID of the instrument, for example:

| **LUID** | **Delta** |
| --- | --- |
| LUID_JKGH56FT | 0.6 |
2. Call the [CreateDataMap](https://www.lusid.com/docs/api/lusid/endpoints/structured-result-data/CreateDataMap) API to create a data map for the document. Map the **LUID** column to the `UnitResult/LusidInstrumentId` address and the **Delta** column to the `UnitResult/Valuation/Delta` address:

```json
curl -X POST 'https://<your-domain>.lusid.com/api/api/unitresults/datamap/ExternalEquityOptionDeltas'
 -H 'Content-Type: application/json-patch+json'
 -H 'Authorization: Bearer <your-API-access-token>'
 -d '{
 "MyDeltaDataMap": {
   "id": {
     "version": "1.0.0",
     "code": "DeltaDataMap"
   },
   "data": {
     "dataDefinitions": [
       {
         "address": "UnitResult/LusidInstrumentId",
         "name": "LUID",
         "dataType": "String",
         "keyType": "Unique"
       },
       {
         "address": "UnitResult/Valuation/Delta",
         "name": "Delta",
         "dataType": "Decimal",
         "keyType": "Leaf"
       }
     ]
   }
 }
}'
```
3. Call the [UpsertStructuredResultData](https://www.lusid.com/docs/api/lusid/endpoints/structured-result-data/UpsertStructuredResultData) API to upsert the document to the SRS with the `UnitResult/Analytic` result type:

```json
curl -X POST 'https://<your-domain>.lusid.com/api/api/unitresults/ExternalEquityOptionDeltas'
 -H 'Content-Type: application/json-patch+json'
 -H 'Authorization: Bearer <your-API-access-token>'
 -d '{
 "first-item": {
   "MyDeltaDocument": {
     "source": "Client",
     "code": "DeltaDocument",
     "effectiveAt": "2024-08-31T00:00:00.0000000+00:00",
     "resultType": "UnitResult/Analytic"
   },
   "data": {
     "documentFormat": "Csv",
     "version": "1.0.0",
     "name": "My delta document",
     "document": "LUID,Delta\nLUID_JKGH56FT,0.6",
     "dataMapKey": {
       "version": "1.0.0",
       "code": "DeltaDataMap"
     }
   }
 }
}'
```
4. Call the [UpsertConfigurationRecipe](https://www.lusid.com/docs/api/lusid/endpoints/configuration-recipe/UpsertConfigurationRecipe) API to create a recipe, or amend an existing one, with a `pricing.resultDataRules` object that locates the document in the SRS:

```json
curl -X POST 'https://<your-domain>.lusid.com/api/api/recipes'
 -H 'Content-Type: application/json-patch+json'
 -H 'Authorization: Bearer <your-API-access-token>'
 -d '{
  "MyRecipe": {
    "scope": "ExternalEquityOptionDeltas",
    "code": "SRSRecipe",
    "pricing": {
      "resultDataRules": [
        {
          "resourceKey": "UnitResult/*",
          "supplier": "Client",
          "dataScope": "ExternalEquityOptionDeltas",
          "documentCode": "DeltaDocument",
          "quoteInterval": "1M.0D",
          "documentResultType": "UnitResult/Analytic",
          "resultKeyRuleType": "ResultDataKeyRule"
        }
      ]
    }
  }
}'
```

When you [value the portfolio](/v1/docs/how-do-i-perform-a-valuation), LUSID calculates `Valuation/Exposure` with the delta from the SRS. Include `Valuation/Delta` to see the delta it used:

```json
curl -X POST 'https://<your-domain>.lusid.com/api/api/aggregation/$valuation'
  -H 'Authorization: Bearer <your-API-access-token>'
  -H 'Content-Type: application/json-patch+json'
  -d '{
    "portfolioEntityIds": [ {"scope": "EquityOptions", "code": "UK"} ],
    "valuationSchedule": {"effectiveAt": "2024-08-31T00:00:00.0000000+00:00" },
    "recipeId": {"scope": "ExternalEquityOptionDeltas", "code": "SRSRecipe"},
    "metrics": [
      {"key": "Instrument/default/Name", "op": "Value"},
      {"key": "Valuation/Exposure", "op": "Value"},
      {"key": "Valuation/Delta", "op": "Value"}
    ]
  }'
```

![](https://cdn.document360.io/d575ad81-c0ed-4980-bbd1-d59ac5c3de82/Images/Documentation/image-1725873096163.png?sv=2026-02-06&spr=https&st=2026-11-09T06%3A06%3A15Z&se=2026-11-09T07%3A06%3A15Z&sr=c&sp=r&sig=Whc4WhrJpirmwElYHCcqKIDxBrdI7dgidsXf9jYVhDY%3D)