--- title: "Setting up and valuing a 'fund of funds' portfolio" slug: "setting-up-and-valuing-a-fund-of-funds-portfolio" updated: 2026-01-21T16:53:50Z published: 2026-01-21T16:53:50Z canonical: "support.lusid.com/setting-up-and-valuing-a-fund-of-funds-portfolio" --- > ## 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. # Setting up and valuing a 'fund of funds' portfolio In this tutorial we'll see how to set up a ‘parent’ portfolio so that it holds a position in a ‘child’ portfolio. The child portfolio must first be securitised; that is, turned into an instrument. We can then purchase a quantity of this instrument in the parent portfolio in the normal way. We can then value the parent portfolio and drill down (or ‘lookthrough’) to value individual holdings in the securitised child portfolio. We can choose to scale the value of each child holding relative to the value of the child portfolio holding in the parent portfolio. For further information and a more complex example, see [this Jupyter Notebook](https://github.com/finbourne/sample-notebooks/blob/master/examples/use-cases/valuation/Look-through%20valuation%20(multi-level).ipynb). In particular, the Notebook includes an example of pricing a future on an equity index, and then expanding the price over the constituents of the underlying index. ## Understanding an example ‘fund of funds’ hierarchy Consider the following example of a parent portfolio holding positions in three child portfolios, two of which themselves have children: ![](https://cdn.document360.io/d575ad81-c0ed-4980-bbd1-d59ac5c3de82/Images/Documentation/9d60429d-bf88-482b-b17c-266121272528.png) Note the following: - The root portfolio must be a [transaction portfolio](/v1/docs/how-do-i-create-a-transaction-portfolio). - A child portfolio can either be a transaction portfolio or a [reference portfolio](/v1/docs/how-do-i-create-a-reference-portfolio). - A child portfolio can itself be a parent portfolio; that is, you can nest to any depth. However, looping is not permitted; a parent portfolio cannot hold a position in a child that holds a position in the parent, and so on. ## Securitising an existing child transaction portfolio Imagine we have a GBP-denominated transaction portfolio with a `scope` of `Lookthrough`, a `code` of `Child` and holdings in a mix of US and UK equities and bonds: ![](https://cdn.document360.io/d575ad81-c0ed-4980-bbd1-d59ac5c3de82/Images/Documentation/156acd77-b75a-4d5b-8bcc-fe67381ebf3e.png) The first step is to securitise this portfolio by calling the [UpsertInstruments](https://www.lusid.com/docs/api#operation/UpsertInstruments) API and specifying: - A friendly `name` for the instrument. - At least one of the unique `identifiers` ([see a list](/v1/docs/what-are-unique-and-non-unique-identifiers)), for example `ClientInternal`. - A suitable economic `definition`. This can use any of the [supported templates](/v1/docs/what-instruments-does-lusid-support), but `SimpleInstrument` is recommended. Note the `domCcy` of the instrument should be set to the base currency of the child portfolio. - A `lookthroughPortfolioId` consisting of the `scope` and `code` of the child portfolio. Note that instead of hard-coding a particular child portfolio you can [dynamically nominate](/v1/docs/setting-up-and-valuing-a-fund-of-funds-portfolio#creating-a-suitable-recipe) a child portfolio using a recipe at valuation time. [More information about creating instruments](/v1/docs/instruments). For example, to create an instrument with a `ClientInternal` identifier value of `ChildInstrument`: ```json curl -X POST "https://.lusid.com/api/api/instruments"  -H "Authorization: Bearer "  -H "Content-Type: application/json"  -d '{  "upsert_request_1": {    "name": "ChildInstrument",    "identifiers": {      "ClientInternal": {        "value": "ChildInstrument",      }    },    "lookThroughPortfolioId": {      "scope": "Lookthrough",      "code": "Child"    },    "definition": {      "instrumentType": "SimpleInstrument",      "domCcy": "GBP",      "assetClass": "Unknown",      "simpleInstrumentType": "Fund"    }  } }' ``` ## Creating a parent transaction portfolio We can call the [CreatePortfolio](https://www.lusid.com/docs/api#operation/CreatePortfolio) API to create a parent transaction portfolio in a particular `scope`, specifying a suitable `code`, `baseCurrency` and a `created` date likely to precede that of any transactions loaded into it. [More information about creating portfolios](/v1/docs/how-do-i-create-a-transaction-portfolio). For example, to create a portfolio with a `scope` of `Lookthrough` and `code` of `Parent`: ```json curl -X POST "https://.lusid.com/api/api/transactionportfolios/Lookthrough"  -H "Authorization: Bearer "  -H "Content-Type: application/json"  -d '{  "displayName": "Parent lookthrough portfolio",  "code": "Parent",  "created": "2022-01-01T00:00:00Z",  "baseCurrency": "GBP" }' ``` ## Purchasing a quantity of the securitised instrument in the parent portfolio We can call the [UpsertTransactions](https://www.lusid.com/docs/api#operation/UpsertTransactions) API with the `scope` and `code` of the parent portfolio to establish a position in the child portfolio, ensuring the `instrumentIdentifiers` section of the transaction contains the unique identifier type and value of the securitised instrument. For example, to purchase `5` units of `ChildInstrument` at a price of `20` per unit: ```json curl -X POST "https://.lusid.com/api/api/transactionportfolios/Lookthrough/Parent/transactions"  -H "Authorization: Bearer "  -H "Content-Type: application/json"  -d '[  {    "transactionId": "Txn-0001",    "type": "StockIn",    "instrumentIdentifiers": {      "instrument/default/ClientInternal": "ChildInstrument"    },    "transactionDate": "2022-03-01T00:00:00Z",    "settlementDate": "2022-03-03T00:00:00Z",    "units": 5,    "transactionPrice": {      "price": 20,      "type": "Price"    },    "totalConsideration": {      "amount": 100,      "currency": "GBP"    },    "transactionCurrency": "GBP"  } ]' ``` [More information about upserting transactions](/v1/docs/transactions). To confirm the position, we can call the [GetHoldings](https://www.lusid.com/docs/api#operation/GetHoldings) API with the `scope` and `code` of the parent portfolio: ![](https://cdn.document360.io/d575ad81-c0ed-4980-bbd1-d59ac5c3de82/Images/Documentation/5b0bcb25-b76a-4641-b119-667d60068591.png) ## Loading market data into the LUSID quote store We can call the [UpsertQuotes](https://www.lusid.com/docs/api#operation/UpsertQuotes) API to load market data (prices and, if necessary, FX rates) for `ChildInstrument`, and for all the instruments in the child portfolio, into a particular quote `scope`. [More information about upserting quotes](/v1/docs/how-do-i-upload-a-market-price-or-fx-spot-rate-to-the-quote-store). For example, to upsert a price of `25` for `ChildInstrument` effective 7 March 2022 into a quote `scope` of `LookthroughQuotes` (in the URL): ```json curl -X POST "https://.lusid.com/api/api/quotes/LookthroughQuotes"  -H "Authorization: Bearer "  -H "Content-Type: application/json"  -d '{  "Quote-0001": {    "quoteId": {      "quoteSeriesId": {        "provider": "Lusid",        "instrumentIdType": "ClientInternal",        "instrumentId": "ChildInstrument",        "quoteType": "Price",        "field": "mid"      },      "effectiveAt": "2022-03-07T00:00:00Z"    },    "metricValue": {      "value": 25,      "unit": "GBP"    }  } }' ``` ## Creating a suitable recipe We can call the [UpsertConfigurationRecipe](https://www.lusid.com/docs/api#operation/UpsertConfigurationRecipe) API to create a valuation recipe. Note the following: - The `market` section must have market rules enabling LUSID to find quotes for `ChildInstrument` and for all the instruments in the child portfolio. - The `pricing` section must have a vendor model rule that enables lookthrough for the securitised instrument type, which in this case is `SimpleInstrument`. [More information about creating recipes](/v1/docs/what-is-a-recipe). In the following example: - The `Quote.Figi.*` market rule locates quotes for the equities and bonds in the child portfolio. - The `Quote.ClientInternal.*` market rule locates quotes for `ChildInstrument`. - The `Fx.USD.GBP` market rule locates USD/GBP exchange rates. - The vendor model rule chooses the `SimpleStatic` pricing model for the `SimpleInstrument` type, and enables lookthrough by setting `portfolioScaling` to `Sum` and `modelOptionsType` to `IndexModelOptions`. Note an alternative portfolio scaling option is `Unity`; [see Appendix A](/v1/docs/setting-up-and-valuing-a-fund-of-funds-portfolio#appendix-a-unity-scaling) for more information. ```json curl -X POST "https://.lusid.com/api/api/recipes"  -H "Authorization: Bearer "  -H "Content-Type: application/json"  -d '{  "configurationRecipe": {    "scope": "Lookthrough",    "code": "ParentIntoChildRecipe",    "market": {      "marketRules": [        {          "key": "Quote.Figi.*",          "supplier": "Lusid",          "dataScope": "LookthroughQuotes",          "quoteType": "Price",          "field": "mid"        },        {          "key": "Quote.ClientInternal.*",          "supplier": "Lusid",          "dataScope": "LookthroughQuotes",          "quoteType": "Price",          "field": "mid"        },        {          "key": "Fx.USD.GBP*",          "supplier": "Lusid",          "dataScope": "LookthroughQuotes",          "quoteType": "Rate",          "field": "mid"        }      ]    },    "pricing": {      "modelRules": [        {          "supplier": "Lusid",          "modelName": "SimpleStatic",          "instrumentType": "SimpleInstrument",          "modelOptions": {            "portfolioScaling": "Sum",            "modelOptionsType": "IndexModelOptions"          }        }      ]    }  } }' ``` Note that if you want to dynamically nominate a child portfolio at valuation time, you can specify the scope and code of a *relationship type* between instruments and portfolios. [See how to set this up](/v1/docs/creating-relationships-between-certain-types-of-entity). For example, consider the alternative vendor model rule below: ```json    "pricing": {      "modelRules": [        {          "supplier": "Lusid",          "modelName": "SimpleStatic",          "instrumentType": "SimpleInstrument",          "modelOptions": {            "portfolioScaling": "Sum",            "modelOptionsType": "IndexModelOptions",            "lookthroughPortfolioRelationshipId": {              "scope": "Relationships",              "code": "InstrumentToChildPortfolios"            }          }        }      ]    } ``` With the `lookthroughPortfolioRelationshipId` object in place, the securitised instrument represents a *related* child portfolio rather than one hard-coded using the `lookThroughPortfolioId` object in its [instrument definition](/v1/docs/setting-up-and-valuing-a-fund-of-funds-portfolio#securitising-an-existing-child-transaction-portfolio). ## Valuing the parent portfolio ### Specifying suitable metrics in the valuation request > **Note**: It is possible to request many metrics when calling the [GetValuation](https://www.lusid.com/docs/api#operation/GetValuation) API, but not all are meaningful in a lookthrough valuation report. In particular, **metrics relating to cost and PnL** do not scale properly, since scaling computation happens at a point in time different to that when the costs were calculated. [More information about metrics](/v1/docs/valuing-a-multi-asset-multi-region-portfolio#deciding-which-metrics-to-report).**​** In our example, we'll request the following metrics: - `Holding/default/Units` to scale the number of units in each child portfolio holding. - `Valuation/PV` to scale PV in the transaction currency for each holding. - `Valuation/Accrued` to scale accrual in the transaction currency for each bond holding. - `Valuation/PVInPortfolioCcy` to scale PV in the portfolio currency for each holding (GBP). - `Valuation/AccruedInPortfolioCcy` to scale accrual in the portfolio currency for each bond holding. - `Holding/FundLineage` to track the `scope` and `code` of the parent and child portfolios Note also that `reportCurrency` should be set to the portfolio currency of the root portfolio in a hierarchy, in this case `GBP`: ```json curl -X POST "https://.lusid.com/api/api/aggregation/$valuation"  -H "Authorization: Bearer "  -H "Content-Type: application/json"  -d '{    "recipeId": {      "scope": "Lookthrough",      "code": "ParentIntoChildRecipe"    },    "metrics": [      { "key": "Holding/default/Units", "op": "Value" },      { "key": "Valuation/PV", "op": "Value" },      { "key": "Valuation/Accrued", "op": "Value" },      { "key": "Valuation/PvInPortfolioCcy", "op": "Value" },      { "key": "Valuation/AccruedInPortfolioCcy", "op": "Value" },      { "key": "Holding/FundLineage", "op": "Value" },    ],    "reportCurrency": "GBP",    "portfolioEntityIds": [      {        "scope": "Lookthrough",        "code": "Parent",      }    ],    "valuationSchedule": {      "effectiveAt": "2022-03-07T00:00:00Z",    } }' ``` ### Understanding valuation results When we value our parent portfolio with lookthrough, holdings in the child portfolio are scaled relative to the value of the securitised instrument in the parent portfolio. The easiest way to understand the scaling calculations is to work through an example. Imagine we value the child portfolio independently on 7 March 2022; we can see that the total **PV in GBP** (the child portfolio currency) is `295,236.04` (the sum of `120,000 + 37,800 + 101,340.11 + 36,095.93`): ![](https://cdn.document360.io/d575ad81-c0ed-4980-bbd1-d59ac5c3de82/Images/Documentation/58669ddc-1c57-4eb6-98d6-64b178a36f50.png) > **Note**: Throughout this example the USD/GBP [trade to portfolio rate](/v1/docs/valuing-a-multi-asset-multi-region-portfolio#loading-transactions-into-the-portfolio-and-establishing-holdings) is fixed at `0.7`. When we value the parent portfolio *without* lookthrough on 7 March 2022, we can see that the **PV in GBP** (the parent portfolio currency) of the securitised instrument is `125`: ![](https://cdn.document360.io/d575ad81-c0ed-4980-bbd1-d59ac5c3de82/Images/Documentation/a0c1e253-10a6-4fbe-85b1-c0b421d43a90.png) Now when we value the parent portfolio *with* lookthrough on 7 March 2022 (using [this recipe and metrics](/v1/docs/setting-up-and-valuing-a-fund-of-funds-portfolio#creating-a-suitable-valuation-recipe)), we see that the unit, PV and accrual figures have been scaled down relative to its value: ![](https://cdn.document360.io/d575ad81-c0ed-4980-bbd1-d59ac5c3de82/Images/Documentation/c817d6ad-c5af-484f-a5d1-097d0e149871.png) The calculations are as follows: | **Scaled metric** | **Calculation** | **BP** | **Microsoft** | **UKT 0 ⅜ 10/22/26** | **T 2.375% Aug 15 2024** | | --- | --- | --- | --- | --- | --- | | **PV in GBP** | ![](https://cdn.document360.io/d575ad81-c0ed-4980-bbd1-d59ac5c3de82/Images/Documentation/51b9c869-f947-40a6-9d22-4bc21f8e1c80.png) | (125 / 295236.04) * 120000 = **50.81** | (125 / 295236.04) * 37800 = **16.00** | (125 / 295236.04) * 101340.11 = **42.91** | (125 / 295236.04) * 36095.93 = **15.28** | | **Units** | ![](https://cdn.document360.io/d575ad81-c0ed-4980-bbd1-d59ac5c3de82/Images/Documentation/29285380-0e41-439f-bc37-6020c743a6fc.png) | (125 / 295236.04) * 4000 = **1.69** | (125 / 295236.04) * 3000 = **1.27** | (125 / 295236.04) * 100000 = **42.34** | (125 / 295236.04) * 50000 = **21.17** | | **Accrual in GBP** | ![](https://cdn.document360.io/d575ad81-c0ed-4980-bbd1-d59ac5c3de82/Images/Documentation/83a8dc47-43c0-4ad0-994b-2839b2807d5f.png) | n/a | n/a | (125 / 295236.04) * 140.11 = **0.06** | (125 / 295236.04) * 45.93 = **0.02** | ## Appendix A: Unity scaling You can select `Unity` rather than `Sum` in your [recipe](/docs/setting-up-and-valuing-a-fund-of-funds-portfolio#create-recipe) to value a parent portfolio with lookthrough and scale holdings in the child portfolio directly by the number of units held in the securitised instrument rather than relative to its value: ```json "pricing": {  "modelRules": [    {      "supplier": "Lusid",      "modelName": "SimpleStatic",      "instrumentType": "SimpleInstrument",      "modelOptions": {        "portfolioScaling": "Unity",        "modelOptionsType": "IndexModelOptions"      }    }  ] } ``` For example, if we hold 5 units of the securitised instrument: ![](https://cdn.document360.io/d575ad81-c0ed-4980-bbd1-d59ac5c3de82/Images/Documentation/a0c1e253-10a6-4fbe-85b1-c0b421d43a90.png) ...then unit, PV and accrual figures are scaled 5 times: ![](https://cdn.document360.io/d575ad81-c0ed-4980-bbd1-d59ac5c3de82/Images/Documentation/1d905242-17be-4beb-b784-03fb6ab85e78.png)