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

# S3. Category 11: Use of Sold Products

> Track downstream emissions from the use phase of energy-consuming products sold by your organization

## Understanding Scope 3 Category 11

**Use of sold products** covers emissions from customers using the products your organization sells. According to the [GHG Protocol Scope 3 Standard](https://ghgprotocol.org/sites/default/files/2022-12/Chapter11.pdf), Category 11 includes emissions from:

* **Direct use-phase emissions**: Emissions from the use of products that directly consume energy or fuels
* **Indirect use-phase emissions**: Emissions from the use of products that indirectly consume energy (e.g., clothing that requires washing)

```
┌─────────────────────────────────────────────────────────────────────────────┐
│              SCOPE 3 CATEGORY 11: Use of Sold Products                      │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  YOUR ORGANIZATION                            YOUR CUSTOMERS                │
│  ─────────────────                            ──────────────                │
│                                                                             │
│  ┌──────────────┐                            ┌──────────────────────┐       │
│  │              │      Product sold           │                      │       │
│  │  Product     │ ─────────────────────────► │  CUSTOMER USE PHASE  │       │
│  │  Manufacturing│                            │                      │       │
│  │  & Sales     │                            │  ⚡ Electricity       │       │
│  │              │                            │  🔥 Fuel combustion   │       │
│  └──────────────┘                            │  💧 Water             │       │
│                                              │                      │       │
│                                              │  Over product's      │       │
│                                              │  entire lifespan     │       │
│                                              └──────────────────────┘       │
│                                                                             │
│  CALCULATION:                                                               │
│  Total emissions = Units sold × Use-phase consumption × Lifespan × EF      │
│                                                                             │
│  EXAMPLES:                                                                  │
│  • Industrial compressors (electricity during operation)                    │
│  • Gas boilers (fuel combustion)                                            │
│  • Vehicles (fuel combustion over lifetime km)                              │
│  • Household appliances (electricity + water)                               │
│  • IT equipment (electricity during use)                                    │
│                                                                             │
│  NOT INCLUDED:                                                              │
│  • Products that don't consume energy (furniture, clothing...)              │
│  • End-of-life treatment (Category 12)                                      │
│  • Manufacturing emissions (Category 1 for your suppliers)                  │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘
```

<Note>
  **When Does Category 11 Apply?**

  Category 11 is most relevant for organizations that sell **energy-consuming products** — anything that uses electricity, burns fuel, or consumes water during its use phase. If your products don't consume energy during use (e.g., passive building materials, textiles), Category 11 emissions are typically zero or negligible.

  For many manufacturers, **Category 11 is the largest Scope 3 category** — often exceeding 50% of total emissions for products with long lifespans or high energy consumption.
</Note>

## Prerequisites

Before starting, ensure you have:

* Dcycle API credentials ([get them here](/docs/quickstart#step-1-get-your-api-key))
* Completed [Step 1: Company Structure](/guides/emissions/ghg-protocol-step-1-company-structure)
* Product data: what you sell, where, and how many units per period
* Use-phase data: energy consumption of your products during their lifetime (from product specs, testing, or LCA studies)

<Tip>
  **Using the Dcycle App?**

  You can manage sold products through our web interface:

  * Navigate to **Scope 3** > **Use of Sold Products**
  * Create products, add periods, and configure use-phase consumption visually
  * Upload country sales data via CSV
</Tip>

## Data Map: Use of Sold Products Requirements Overview

```
┌─────────────────────────────────────────────────────────────────────────────────────────┐
│                   USE OF SOLD PRODUCTS DATA REQUIREMENTS                                 │
├─────────────────────────────────────────────────────────────────────────────────────────┤
│                                                                                         │
│  ┌─────────────────────────────────────────────────────────────────────────────────┐   │
│  │ PRODUCT SETUP (Step 11.1)                                                       │   │
│  ├─────────────────────────────────────────────────────────────────────────────────┤   │
│  │  • product_name                                                                 │   │
│  │  • organization_id                                                              │   │
│  └─────────────────────────────────────────────────────────────────────────────────┘   │
│                                                                                         │
│  ┌─────────────────────────────────────────────────────────────────────────────────┐   │
│  │ PERIOD & SALES (Steps 11.2 - 11.3)                                              │   │
│  ├─────────────────────────────────────────────────────────────────────────────────┤   │
│  │                                                                                 │   │
│  │  Period                         Country Sales                                   │   │
│  │  ─────────────────              ─────────────────                               │   │
│  │  • start_date                   • country (ISO code)                            │   │
│  │  • end_date                     • quantity (units sold)                          │   │
│  │                                 • unit_id                                       │   │
│  └─────────────────────────────────────────────────────────────────────────────────┘   │
│                                                                                         │
│  ┌─────────────────────────────────────────────────────────────────────────────────┐   │
│  │ USE-PHASE CONSUMPTION (Step 11.4)                                               │   │
│  ├─────────────────────────────────────────────────────────────────────────────────┤   │
│  │                                                                                 │   │
│  │  General                Electricity            Combustion           Water       │   │
│  │  ──────────────         ────────────           ──────────           ─────       │   │
│  │  • lifespan             • quantity (kWh)       • fuel_type          • quantity  │   │
│  │  • lifespan_unit        • unit_id              • quantity           • unit_id   │   │
│  │    (day/week/           • frequency            • unit_id            • frequency │   │
│  │     month/year)           (daily/weekly/        • frequency                     │   │
│  │                            monthly/yearly/                                      │   │
│  │                            all_life)                                            │   │
│  │                                                                                 │   │
│  └─────────────────────────────────────────────────────────────────────────────────┘   │
│                                                                                         │
└─────────────────────────────────────────────────────────────────────────────────────────┘
```

## How It Works

Dcycle calculates Category 11 emissions using a **product-centric approach** with four layers of data:

<Steps>
  <Step title="Create a Sold Product">
    Register each product or product family your organization sells
  </Step>

  <Step title="Define Reporting Periods">
    Add date ranges for when sales data applies (e.g., 2024-01-01 to 2024-12-31)
  </Step>

  <Step title="Add Country Sales">
    Record how many units were sold in each country during the period
  </Step>

  <Step title="Configure Use-Phase Consumption">
    Define what the product consumes during its lifetime: electricity, fuel, and/or water
  </Step>

  <Step title="Automatic Calculation">
    Dcycle calculates total use-phase emissions:
    **Units sold × Consumption per unit × Lifespan × Country-specific emission factor**
  </Step>
</Steps>

<Note>
  **Country-Specific Emission Factors**

  Dcycle applies country-specific emission factors for electricity consumption. A product sold in France (low-carbon grid) will have lower use-phase emissions than the same product sold in Poland (coal-heavy grid). This is why country-level sales data matters.
</Note>

## Calculation Methodology

```
┌──────────────────────────────────────────────────────────────────────────────┐
│                       CALCULATION FLOW                                       │
├──────────────────────────────────────────────────────────────────────────────┤
│                                                                              │
│  For each country where the product is sold:                                │
│                                                                              │
│  Electricity emissions:                                                      │
│  = Units sold × kWh per [frequency] × Lifespan × Grid EF (country)         │
│                                                                              │
│  Combustion emissions:                                                       │
│  = Units sold × Fuel quantity per [frequency] × Lifespan × Fuel EF          │
│                                                                              │
│  Water emissions:                                                            │
│  = Units sold × Water per [frequency] × Lifespan × Water EF (country)      │
│                                                                              │
│  Total = Σ (Electricity + Combustion + Water) across all countries           │
│                                                                              │
│  Where [frequency] is normalized to match lifespan:                         │
│  • daily → × 365 × lifespan_years                                          │
│  • monthly → × 12 × lifespan_years                                         │
│  • yearly → × lifespan_years                                               │
│  • all_life → × 1 (total over entire lifespan)                             │
│                                                                              │
└──────────────────────────────────────────────────────────────────────────────┘
```

## Step 11.1: Create a Sold Product

<Accordion title="📋 Data Map: Sold Product">
  | Field  | Type   | Required | Description            | Example                        |
  | ------ | ------ | -------- | ---------------------- | ------------------------------ |
  | `name` | string | ✅        | Product name or family | `"Industrial Compressor X200"` |

  **Where to get this data:**

  * **Product catalog**: Your product management system or ERP
  * **Naming**: Use consistent names across periods (one product record per product family)

  <Note>
    Product names must be unique within your organization. Use product families rather than individual SKUs when products have similar use-phase consumption profiles.
  </Note>
</Accordion>

Products are created implicitly when you first upload country sales data through the Dcycle App, or explicitly via the API. Each sold product record groups all periods and sales for that product.

<CodeGroup>
  ```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
  import requests
  import os

  headers = {
      "x-api-key": os.getenv("DCYCLE_API_KEY"),
      "Content-Type": "application/json",
      "x-organization-id": os.getenv("DCYCLE_ORG_ID"),
  }

  # List existing sold products
  products = requests.get(
      "https://api.dcycle.io/v2/sold-products/",
      headers=headers,
  ).json()

  print(f"📦 Sold Products:")
  for product in products["items"]:
      print(f"   {product['product_name']} (ID: {product['product_id']})")
  ```

  ```javascript JavaScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
  const axios = require('axios');

  const headers = {
    'x-api-key': process.env.DCYCLE_API_KEY,
    'Content-Type': 'application/json',
    'x-organization-id': process.env.DCYCLE_ORG_ID,
  };

  // List existing sold products
  const response = await axios.get(
    'https://api.dcycle.io/v2/sold-products/',
    { headers }
  );

  const products = response.data;
  console.log('📦 Sold Products:');
  for (const product of products.items) {
    console.log(`   ${product.product_name} (ID: ${product.product_id})`);
  }
  ```
</CodeGroup>

## Step 11.2: Define Reporting Periods

<Accordion title="📋 Data Map: Reporting Period">
  | Field        | Type | Required | Description  | Example        |
  | ------------ | ---- | -------- | ------------ | -------------- |
  | `start_date` | date | ✅        | Period start | `"2024-01-01"` |
  | `end_date`   | date | ✅        | Period end   | `"2024-12-31"` |

  **Constraints:**

  * Periods for the same product **cannot overlap**
  * Each product must have at least one period (you cannot delete the last period)

  **Where to get this data:**

  * **Reporting cycle**: Typically annual, aligned with your GHG Protocol reporting year
</Accordion>

Each sold product has one or more reporting periods. Periods define the timeframe for which sales data applies.

```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
# Check for overlapping periods before creating
overlap_check = requests.get(
    "https://api.dcycle.io/v2/sold-products/periods/check-overlap",
    headers=headers,
    params={
        "start_date": "2024-01-01",
        "end_date": "2024-12-31",
    },
).json()

print(f"Overlap exists: {overlap_check}")
```

## Step 11.3: Add Country Sales Data

<Accordion title="📋 Data Map: Country Sales">
  | Field      | Type   | Required | Description                   | Example                             |
  | ---------- | ------ | -------- | ----------------------------- | ----------------------------------- |
  | `country`  | string | ✅        | Country where sold (ISO code) | `"ES"`, `"DE"`, `"FR"`              |
  | `quantity` | number | ✅        | Units sold in this country    | `250`                               |
  | `unit_id`  | UUID   | ✅        | Unit of measurement           | Unit UUID (`u`, `kg`, `m³`, `tons`) |

  **Constraints:**

  * One entry per country per period (unique combination)
  * All sales within the same period must use the same unit

  **Where to get this data:**

  * **Sales system / ERP**: Units sold by country by period
  * **Distribution records**: Shipping destinations, invoicing addresses
  * **Market reports**: Regional sales breakdowns
</Accordion>

Country sales tell Dcycle how many units of each product were sold in each market. This is critical because electricity emission factors vary significantly by country.

<CodeGroup>
  ```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
  # Get country sales for a product period
  product_id = "your-product-uuid"
  period_id = "your-period-uuid"

  country_sales = requests.get(
      f"https://api.dcycle.io/v2/sold-products/{product_id}/periods/{period_id}/country-sales",
      headers=headers,
  ).json()

  print(f"📊 Sales Breakdown:")
  print(f"   Total: {country_sales['total_quantity']} units")
  for sale in country_sales["items"]:
      country = sale["location"]["country_name"]
      qty = sale["quantity"]
      unit = sale["unit"]["symbol"]
      print(f"   {country}: {qty} {unit}")
  ```

  ```javascript JavaScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
  // Get country sales for a product period
  const productId = 'your-product-uuid';
  const periodId = 'your-period-uuid';

  const countrySales = await axios.get(
    `https://api.dcycle.io/v2/sold-products/${productId}/periods/${periodId}/country-sales`,
    { headers }
  );

  const data = countrySales.data;
  console.log('📊 Sales Breakdown:');
  console.log(`   Total: ${data.total_quantity} units`);
  for (const sale of data.items) {
    const country = sale.location.country_name;
    console.log(`   ${country}: ${sale.quantity} ${sale.unit.symbol}`);
  }
  ```
</CodeGroup>

<Tip>
  **CSV Upload for Country Sales**

  For large datasets, upload country sales via CSV through the Dcycle App. The CSV should contain columns for country and quantity. The app will validate and detect duplicates automatically.
</Tip>

## Step 11.4: Configure Use-Phase Consumption

<Accordion title="📋 Data Map: Use-Phase Consumption Data">
  | Field              | Type   | Required | Description      | Example     |
  | ------------------ | ------ | -------- | ---------------- | ----------- |
  | `period_id`        | UUID   | ✅        | Reporting period | Period UUID |
  | `lifespan`         | number | ✅        | Product lifespan | `10`        |
  | `lifespan_unit_id` | UUID   | ✅        | Temporal unit    | Year UUID   |

  **Electricity consumption (if applicable):**

  | Field                   | Type    | Required | Description                  | Example    |
  | ----------------------- | ------- | -------- | ---------------------------- | ---------- |
  | `consumes_electricity`  | boolean | ✅        | Does it consume electricity? | `true`     |
  | `electricity_quantity`  | number  | ✅\*      | Amount per frequency         | `500`      |
  | `electricity_unit_id`   | UUID    | ✅\*      | Unit (typically kWh)         | kWh UUID   |
  | `electricity_frequency` | enum    | ✅\*      | How often                    | `"yearly"` |

  **Fuel combustion (if applicable):**

  | Field                  | Type    | Required | Description            | Example          |
  | ---------------------- | ------- | -------- | ---------------------- | ---------------- |
  | `consumes_combustion`  | boolean | ✅        | Does it burn fuel?     | `true`           |
  | `combustion_fuel_id`   | UUID    | ✅\*      | Fuel type              | Natural gas UUID |
  | `combustion_quantity`  | number  | ✅\*      | Amount per frequency   | `1200`           |
  | `combustion_unit_id`   | UUID    | ✅\*      | Unit (liters, m³, kWh) | m³ UUID          |
  | `combustion_frequency` | enum    | ✅\*      | How often              | `"yearly"`       |

  **Water consumption (if applicable):**

  | Field             | Type    | Required | Description            | Example    |
  | ----------------- | ------- | -------- | ---------------------- | ---------- |
  | `consumes_water`  | boolean | ✅        | Does it consume water? | `false`    |
  | `water_quantity`  | number  | ✅\*      | Amount per frequency   | `50`       |
  | `water_unit_id`   | UUID    | ✅\*      | Unit (typically m³)    | m³ UUID    |
  | `water_frequency` | enum    | ✅\*      | How often              | `"yearly"` |

  \*Required only when the corresponding `consumes_*` flag is `true`.

  **Frequency options:** `daily`, `weekly`, `monthly`, `yearly`, `all_life`
</Accordion>

This is the core data that defines how much energy your product consumes during its use phase. You define what the product consumes (electricity, fuel, water) and how much, over what frequency and lifespan.

<CodeGroup>
  ```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
  # Create use-of-product consumption data
  use_of_product_data = {
      "period_id": period_id,
      "lifespan": 10,  # 10-year lifespan
      "lifespan_unit_id": "22651595-5867-49bd-ad9b-e44259e68378",  # year

      # Electricity consumption
      "consumes_electricity": True,
      "electricity_quantity": 2400,  # 2,400 kWh per year
      "electricity_unit_id": "ba80e6cb-86a4-4bb1-a0c5-8104365d523c",  # kWh
      "electricity_frequency": "yearly",

      # Fuel combustion (if applicable)
      "consumes_combustion": False,

      # Water consumption (if applicable)
      "consumes_water": False,
  }

  response = requests.post(
      f"https://api.dcycle.io/v2/sold-products/{product_id}/use-of-product",
      headers=headers,
      json=use_of_product_data,
  )

  result = response.json()
  print(f"✅ Use-of-product data created: {result['id']}")
  print(f"   Lifespan: {result['lifespan']} years")
  print(f"   Electricity: {result['electricity_quantity']} kWh/year")
  ```

  ```javascript JavaScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
  // Create use-of-product consumption data
  const useOfProductData = {
    period_id: periodId,
    lifespan: 10, // 10-year lifespan
    lifespan_unit_id: '22651595-5867-49bd-ad9b-e44259e68378', // year

    // Electricity consumption
    consumes_electricity: true,
    electricity_quantity: 2400, // 2,400 kWh per year
    electricity_unit_id: 'ba80e6cb-86a4-4bb1-a0c5-8104365d523c', // kWh
    electricity_frequency: 'yearly',

    // Fuel combustion (if applicable)
    consumes_combustion: false,

    // Water consumption (if applicable)
    consumes_water: false,
  };

  const response = await axios.post(
    `https://api.dcycle.io/v2/sold-products/${productId}/use-of-product`,
    useOfProductData,
    { headers }
  );

  const result = response.data;
  console.log(`✅ Use-of-product data created: ${result.id}`);
  console.log(`   Lifespan: ${result.lifespan} years`);
  console.log(`   Electricity: ${result.electricity_quantity} kWh/year`);
  ```
</CodeGroup>

<Warning>
  **Consistency Between Fields**

  When `consumes_electricity` is `true`, you **must** provide `electricity_quantity`, `electricity_unit_id`, and `electricity_frequency`. The same applies for combustion and water. Setting a flag to `true` without the related fields will cause a validation error.
</Warning>

## Step 11.5: View Emissions Results

Once you've configured the use-phase data, Dcycle triggers an asynchronous calculation. You can check the status and results:

<CodeGroup>
  ```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
  # Get emissions for a product period
  emissions = requests.get(
      f"https://api.dcycle.io/v2/sold-products/{product_id}/periods/{period_id}/emissions",
      headers=headers,
  ).json()

  for emission in emissions["items"]:
      status = emission["status"]
      quantity = emission.get("quantity")
      emission_type = emission["type"]

      if status == "calculation_completed":
          print(f"✅ {emission_type}: {quantity:,.2f} kgCO₂e")
      elif status == "calculation_running":
          print(f"⏳ {emission_type}: Calculating...")
      elif status == "missing_data":
          print(f"⚠️  {emission_type}: Missing data — check use-of-product configuration")
      elif status == "calculation_completed_with_errors":
          print(f"❌ {emission_type}: Completed with errors")

  # Get detailed breakdown by country
  use_of_product_data_id = emissions["items"][0]["use_of_product_data_id"]

  details = requests.get(
      f"https://api.dcycle.io/v2/sold-products/{product_id}/use-of-product/{use_of_product_data_id}/details",
      headers=headers,
  ).json()

  print(f"\n📊 Emissions by Country:")
  for detail in details["items"]:
      print(f"   {detail['country_name']}: {detail['quantity']:,.2f} kgCO₂e")
  ```

  ```javascript JavaScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
  // Get emissions for a product period
  const emissions = await axios.get(
    `https://api.dcycle.io/v2/sold-products/${productId}/periods/${periodId}/emissions`,
    { headers }
  );

  for (const emission of emissions.data.items) {
    const { status, quantity, type } = emission;

    if (status === 'calculation_completed') {
      console.log(`✅ ${type}: ${quantity.toLocaleString()} kgCO₂e`);
    } else if (status === 'calculation_running') {
      console.log(`⏳ ${type}: Calculating...`);
    } else if (status === 'missing_data') {
      console.log(`⚠️  ${type}: Missing data — check use-of-product configuration`);
    }
  }

  // Get detailed breakdown by country
  const useOfProductDataId = emissions.data.items[0].use_of_product_data_id;

  const details = await axios.get(
    `https://api.dcycle.io/v2/sold-products/${productId}/use-of-product/${useOfProductDataId}/details`,
    { headers }
  );

  console.log('\n📊 Emissions by Country:');
  for (const detail of details.data.items) {
    console.log(`   ${detail.country_name}: ${detail.quantity.toLocaleString()} kgCO₂e`);
  }
  ```
</CodeGroup>

### Emission Statuses

| Status                              | Meaning                                  | Action                                                |
| ----------------------------------- | ---------------------------------------- | ----------------------------------------------------- |
| `missing_data`                      | Use-phase consumption not yet configured | Add use-of-product data (Step 11.4)                   |
| `calculation_running`               | Emissions are being calculated           | Wait and re-check in a few seconds                    |
| `calculation_completed`             | Results ready                            | View emissions and details                            |
| `calculation_completed_with_errors` | Partial results                          | Check for missing emission factors for some countries |

<Accordion title="🏢 Typical Data Sources">
  | Data                    | Where it typically lives                                 | Notes                          |
  | ----------------------- | -------------------------------------------------------- | ------------------------------ |
  | Product catalog         | PLM (product lifecycle management), ERP                  | Product names and families     |
  | Units sold by country   | ERP, CRM, sales reporting                                | Quantity per market per period |
  | Product lifespan        | Product specifications, warranty terms, LCA studies      | Expected useful life           |
  | Electricity consumption | Product testing reports, energy labels (EU), spec sheets | kWh per year or per use cycle  |
  | Fuel consumption        | Product testing, performance certificates                | Liters/m³ per year             |
  | Water consumption       | Product testing, water labels                            | m³ per year or per cycle       |

  **Automation options:**

  * **CSV upload** → Upload country sales data via the Dcycle App
  * **API** → Push from ERP/CRM for sales data; configure use-phase manually or via API
  * **Product specs** → Use-phase data typically comes from R\&D or product engineering
</Accordion>

## Examples by Industry

<AccordionGroup>
  <Accordion title="Industrial Equipment Manufacturer">
    **Product:** Industrial Compressor X200

    | Parameter            | Value          |
    | -------------------- | -------------- |
    | Lifespan             | 15 years       |
    | Electricity          | 8,000 kWh/year |
    | Fuel                 | None           |
    | Water                | None           |
    | Units sold (Spain)   | 250            |
    | Units sold (Germany) | 180            |

    **Total use-phase emissions** = (250 + 180) × 8,000 kWh/year × 15 years × country EFs
  </Accordion>

  <Accordion title="Gas Boiler Manufacturer">
    **Product:** Residential Gas Boiler Pro

    | Parameter           | Value                        |
    | ------------------- | ---------------------------- |
    | Lifespan            | 12 years                     |
    | Electricity         | 150 kWh/year (controls/pump) |
    | Fuel                | 12,000 kWh/year natural gas  |
    | Water               | None                         |
    | Units sold (France) | 5,000                        |

    **Total use-phase emissions** = 5,000 × (150 kWh elec + 12,000 kWh gas)/year × 12 years × EFs
  </Accordion>

  <Accordion title="Household Appliance Manufacturer">
    **Product:** Washing Machine EcoWash 9kg

    | Parameter             | Value        |
    | --------------------- | ------------ |
    | Lifespan              | 10 years     |
    | Electricity           | 200 kWh/year |
    | Fuel                  | None         |
    | Water                 | 10 m³/year   |
    | Units sold (Spain)    | 15,000       |
    | Units sold (Portugal) | 3,000        |

    **Total use-phase emissions** = (15,000 + 3,000) × (200 kWh + 10 m³)/year × 10 years × country EFs
  </Accordion>
</AccordionGroup>

## Updating Use-Phase Data

If product specifications change or you have more accurate data:

```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
# Update use-of-product consumption data
update_data = {
    "lifespan": 12,  # Updated lifespan to 12 years
    "electricity_quantity": 2200,  # Updated to 2,200 kWh/year
    "electricity_frequency": "yearly",
}

response = requests.patch(
    f"https://api.dcycle.io/v2/sold-products/{product_id}/use-of-product/{use_of_product_data_id}",
    headers=headers,
    json=update_data,
)

print(f"✅ Updated — recalculation triggered automatically")
```

<Note>
  **Automatic Recalculation**

  Updating use-of-product data automatically triggers a recalculation of all emissions for the affected period. You don't need to manually re-trigger calculations.
</Note>

## Connection with LCA

If you have detailed **Life Cycle Assessment (LCA)** data for your products, you can use Dcycle's [LCA module](/guides/lca/overview) to build a complete cradle-to-grave model. The LCA module uses the **ecoinvent** database and provides more granular impact categories beyond just climate change.

Category 11 and LCA complement each other:

* **Category 11 (this guide)**: Estimates use-phase emissions from sales volumes and product specs — ideal for GHG Protocol reporting
* **LCA module**: Detailed product-level environmental impact across the full lifecycle — ideal for EPDs, product design, and ecodesign

<CardGroup cols={2}>
  <Card title="LCA Overview" icon="recycle" href="/guides/lca/overview">
    Build complete life cycle assessments
  </Card>

  <Card title="Resource Manager" icon="database" href="/guides/lca/resource-manager">
    Manage materials and processes for LCA
  </Card>
</CardGroup>

## Next Steps

<CardGroup cols={2}>
  <Card title="Sold Products API" icon="box" href="/api-reference/sold-products/overview">
    Full API reference for sold products endpoints
  </Card>

  <Card title="Category 1: Purchased Goods" icon="bag-shopping" href="/guides/emissions/scope-3-category-1-purchased-goods">
    Track upstream emissions from purchases
  </Card>

  <Card title="Custom Emission Factors" icon="chart-line" href="/guides/advanced/custom-emission-factors">
    Use supplier EPDs and PCFs for upstream data
  </Card>

  <Card title="GHG Protocol Scope 3" icon="leaf" href="/guides/emissions/ghg-protocol-step-4-scope-3">
    Return to the Scope 3 overview
  </Card>
</CardGroup>