S3. Category 11: Use of Sold Products

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, 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)                  │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

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.

Prerequisites

Before starting, ensure you have:

Dcycle API credentials (get them here)
Completed 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)

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

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:

Create a Sold Product

Define Reporting Periods

Add date ranges for when sales data applies (e.g., 2024-01-01 to 2024-12-31)

Add Country Sales

Record how many units were sold in each country during the period

Configure Use-Phase Consumption

Define what the product consumes during its lifetime: electricity, fuel, and/or water

Automatic Calculation

Dcycle calculates total use-phase emissions: Units sold × Consumption per unit × Lifespan × Country-specific emission factor

Country-Specific Emission FactorsDcycle 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.

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

📋 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)

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

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.

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']})")

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})`);
}

Step 11.2: Define Reporting Periods

📋 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

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

# 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

📋 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

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.

# 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}")

// 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}`);
}

CSV Upload for Country SalesFor 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.

Step 11.4: Configure Use-Phase Consumption

📋 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

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.

# 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")

// 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`);

Consistency Between FieldsWhen 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.

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:

# 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")

// 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`);
}

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

🏢 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

Examples by Industry

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

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

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

Updating Use-Phase Data

If product specifications change or you have more accurate data:

# 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")

Automatic RecalculationUpdating use-of-product data automatically triggers a recalculation of all emissions for the affected period. You don’t need to manually re-trigger calculations.

Connection with LCA

If you have detailed Life Cycle Assessment (LCA) data for your products, you can use Dcycle’s LCA module 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

LCA Overview

Build complete life cycle assessments

Resource Manager

Manage materials and processes for LCA

Next Steps

Sold Products API

Full API reference for sold products endpoints

Category 1: Purchased Goods

Track upstream emissions from purchases

Custom Emission Factors

Use supplier EPDs and PCFs for upstream data

GHG Protocol Scope 3

Return to the Scope 3 overview

​Understanding Scope 3 Category 11

​Prerequisites

​Data Map: Use of Sold Products Requirements Overview

​How It Works

​Calculation Methodology

​Step 11.1: Create a Sold Product

​Step 11.2: Define Reporting Periods

​Step 11.3: Add Country Sales Data

​Step 11.4: Configure Use-Phase Consumption

​Step 11.5: View Emissions Results

​Emission Statuses

​Examples by Industry

​Updating Use-Phase Data

​Connection with LCA

LCA Overview

Resource Manager

​Next Steps

Sold Products API

Category 1: Purchased Goods

Custom Emission Factors

GHG Protocol Scope 3

Understanding Scope 3 Category 11

Prerequisites

Data Map: Use of Sold Products Requirements Overview

How It Works

Calculation Methodology

Step 11.1: Create a Sold Product

Step 11.2: Define Reporting Periods

Step 11.3: Add Country Sales Data

Step 11.4: Configure Use-Phase Consumption

Step 11.5: View Emissions Results

Emission Statuses

Examples by Industry

Updating Use-Phase Data

Connection with LCA

Next Steps