> ## 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 2: Capital Goods
> Learn how to calculate emissions from purchased capital goods including buildings, machinery, equipment, and IT infrastructure
## Understanding Scope 3 Category 2
**Capital goods** are physical assets with an extended life that your organization uses to manufacture products, provide services, or sell, store, and deliver merchandise. Unlike Category 1 (purchased goods and services), capital goods are **amortized over their useful life** rather than consumed immediately.
According to the [GHG Protocol Scope 3 Standard](https://ghgprotocol.org/sites/default/files/2022-12/Chapter2.pdf), Category 2 includes emissions from:
* **Buildings and facilities**: Offices, warehouses, manufacturing plants, retail stores
* **Machinery and equipment**: Production lines, HVAC systems, generators, industrial equipment
* **Vehicles**: Company fleet vehicles (if purchased, not leased)
* **IT infrastructure**: Servers, data centers, computer equipment, networking hardware
* **Furniture and fixtures**: Office furniture, shelving, storage systems
```
┌─────────────────────────────────────────────────────────────────────────────┐
│ SCOPE 3 CATEGORY 2: Capital Goods │
├─────────────────────┬─────────────────────┬─────────────────────────────────┤
│ Buildings & │ Machinery & │ IT & Other │
│ Facilities │ Equipment │ Assets │
├─────────────────────┼─────────────────────┼─────────────────────────────────┤
│ • Office buildings │ • Production lines │ • Servers & data centers │
│ • Warehouses │ • HVAC systems │ • Computer equipment │
│ • Manufacturing │ • Generators │ • Furniture & fixtures │
│ • Retail stores │ • Fleet vehicles │ • Networking hardware │
└─────────────────────┴─────────────────────┴─────────────────────────────────┘
```
**Category 1 vs Category 2: What's the Difference?**
| Aspect | Category 1 (Purchased Goods) | Category 2 (Capital Goods) |
| ---------------- | ----------------------------------- | --------------------------------- |
| **Type** | Operational expenditure (OPEX) | Capital expenditure (CAPEX) |
| **Consumption** | Consumed/used within reporting year | Multi-year useful life |
| **Examples** | Raw materials, services, supplies | Buildings, machinery, vehicles |
| **Accounting** | Full emissions in year of purchase | Can be amortized over useful life |
| **Dcycle field** | `expense_type: "opex"` | `expense_type: "capex"` |
## Prerequisites
Before starting, ensure you have:
* Dcycle API credentials ([get them here](/docs/quickstart#step-1-get-your-api-key))
* Capital asset data: fixed asset register, procurement records, or investment records
* Understanding of your capital asset categories and their acquisition costs or physical specifications
**Using the Dcycle App?**
You can also manage capital goods through our web interface:
* [Upload purchases manually](https://scribehow.com/shared/Upload_your_purchases_manually__8h4StuskTYC90g8g1s0SPw) ([ES](https://scribehow.com/shared/Sube_tus_compras_manualmente__fJG4jcu-SamP2bekdZFb0A)) - Set expense type to "CAPEX"
* [Upload purchases automatically](https://scribehow.com/shared/How_to_Upload_Purchases_Automatically__eW_8NvwfTG6VCT96YX1Qpg) ([ES](https://scribehow.com/shared/Sube_tus_compras_automaticamente__4fz0eldlQSK3JRs_2VK_pw)) - Bulk import from fixed asset register
## Data Map: Capital Goods Requirements Overview
Before diving into the calculations, here's a complete overview of the data you'll need:
```
┌─────────────────────────────────────────────────────────────────────────────────────────┐
│ CAPITAL GOODS DATA REQUIREMENTS │
├─────────────────────────────────────────────────────────────────────────────────────────┤
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────────┐ │
│ │ CAPITAL GOODS DATA (Steps 4.2.1 - 4.2.3) │ │
│ ├─────────────────────────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ Spend-Based Activity-Based Supplier-Specific │ │
│ │ ──────────────────── ──────────────── ───────────────── │ │
│ │ • quantity (€) • quantity (kg, units) • quantity │ │
│ │ • unit_id (€) • unit_id (kg, m², etc.) • unit_id │ │
│ │ • sector • product_name • custom_emission_ │ │
│ │ • product_name • sector factor_id │ │
│ │ • country • country • supplier_id │ │
│ │ • purchase_date • purchase_date • purchase_date │ │
│ │ • expense_type: "capex" • expense_type: "capex" • expense_type: "capex" │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────────────────────┘ │
│ │
│ ┌─────────────────────────────────────────────────────────────────────────────────┐ │
│ │ KEY DIFFERENCE FROM CATEGORY 1 │ │
│ ├─────────────────────────────────────────────────────────────────────────────────┤ │
│ │ │ │
│ │ ⚠️ Set expense_type = "capex" (not "opex") │ │
│ │ │ │
│ │ This field determines whether emissions are classified as: │ │
│ │ • Category 1 (Purchased goods & services) → expense_type: "opex" │ │
│ │ • Category 2 (Capital goods) → expense_type: "capex" │ │
│ │ │ │
│ └─────────────────────────────────────────────────────────────────────────────────┘ │
│ │
└─────────────────────────────────────────────────────────────────────────────────────────┘
```
## Calculation Methods
Capital goods use the same calculation methods as purchased goods, with identical emission factor sources:
The **spend-based method** uses economic input-output (EEIO) emission factors based on the monetary value of capital purchases.
```
Acquisition Cost (€) → Sector/Product Category → Exiobase EF → CO₂e
↓ ↓ ↓ ↓
Invoice/PO amount Product mapping kg CO₂e/€ Total emissions
```
**Key characteristics:**
* Uses Exiobase 3.8.2 input-output emission factors
* Best for buildings, infrastructure, and mixed assets
* Lower accuracy but easiest to implement
* Use when you only have financial data
For spend-based calculations, Dcycle uses emission factors from:
* **Exiobase 3.8.2** - Multi-Regional Environmentally Extended Supply-Use Tables
* Covers construction, manufacturing, and equipment sectors
* Source: [Exiobase](https://www.exiobase.eu/)
Common capital goods sectors:
* `Construction` - Buildings and infrastructure
* `Manufacture of machinery and equipment n.e.c.` - Industrial equipment
* `Manufacture of motor vehicles` - Fleet vehicles
* `Manufacture of computer, electronic and optical products` - IT equipment
Spend-based emissions are calculated as:
**CO₂e = Acquisition Cost (€) × Economic Intensity Factor (kg CO₂e/€)**
Where:
* **Acquisition Cost**: Total purchase price including installation/commissioning
* **Economic Intensity Factor**: Exiobase emission factor for the asset category
**Example (Office Building):**
```
€2,000,000 × 0.35 kg CO₂e/€ = 700,000 kg CO₂e (700 tCO₂e)
```
**Example (Industrial Machinery):**
```
€500,000 × 0.45 kg CO₂e/€ = 225,000 kg CO₂e (225 tCO₂e)
```
The **activity-based method** uses physical quantities and product-specific emission factors.
```
Quantity (kg, m², units) → Product Category → Activity-Based EF → CO₂e
↓ ↓ ↓ ↓
Physical specs Asset type kg CO₂e/unit Total emissions
```
**Key characteristics:**
* Uses physical quantities (weight, area, units)
* More accurate than spend-based
* Ideal for standardized equipment
* Requires detailed asset specifications
For activity-based calculations, Dcycle uses emission factors from:
* **Ecoinvent** - Life cycle inventory database (latest version available)
* **Industry-specific databases** - Equipment-specific factors
* **Construction sector databases** - Building material factors
Common activity-based metrics:
* Buildings: m² of floor area, tonnes of construction materials
* Vehicles: units, vehicle type
* IT equipment: units, weight (kg)
* Machinery: weight (kg), power rating (kW)
Activity-based emissions are calculated as:
**CO₂e = Quantity × Emission Factor (kg CO₂e/unit)**
Where:
* **Quantity**: Physical measure (kg, m², units, etc.)
* **Emission Factor**: Product-specific factor from database
**Example (Steel Equipment - 5,000 kg):**
```
5,000 kg × 2.8 kg CO₂e/kg = 14,000 kg CO₂e
```
**Example (Office Building - 2,000 m²):**
```
2,000 m² × 350 kg CO₂e/m² = 700,000 kg CO₂e
```
The **supplier-specific method** uses verified emission data from asset manufacturers (EPDs, PCFs).
```
Quantity → Manufacturer EPD/PCF → Verified EF → CO₂e
↓ ↓ ↓ ↓
Physical Third-party kg CO₂e/unit Total emissions
specs verified (most accurate)
```
**Key characteristics:**
* Uses Environmental Product Declarations (EPDs)
* Highest accuracy (±5-15%)
* Available for many construction products and equipment
* Reflects actual manufacturing processes
Supplier-specific emission factors come from:
* **Building material EPDs** - Concrete, steel, glass, insulation
* **Equipment manufacturer PCFs** - HVAC, machinery, vehicles
* **IT equipment disclosures** - Servers, computers
* **Vehicle manufacturer data** - Fleet vehicles
EPD databases:
* [EPD International](https://www.environdec.com/) - Global EPD registry
* [IBU EPD](https://ibu-epd.com/) - German EPD program
* [INIES](https://www.inies.fr/) - French construction database
Supplier-specific emissions are calculated as:
**CO₂e = Quantity × Custom Emission Factor (kg CO₂e/unit)**
Where:
* **Quantity**: Physical amount from specifications
* **Custom Emission Factor**: Manufacturer-provided factor (from EPD/PCF)
**Example (Low-carbon concrete from certified supplier):**
```
Standard: 500 m³ × 300 kg CO₂e/m³ = 150,000 kg CO₂e
Low-carbon: 500 m³ × 180 kg CO₂e/m³ = 90,000 kg CO₂e
Savings: 60,000 kg CO₂e (40% reduction)
```
## Amortization Approaches
The GHG Protocol allows two approaches for reporting capital goods emissions:
**Report all emissions in the year the asset is acquired.**
This is the simpler approach and Dcycle's default behavior.
**Pros:**
* Simple to implement
* Matches accounting treatment timing
* No tracking of asset useful life needed
**Cons:**
* Creates emissions "spikes" in years with major investments
* Year-over-year comparisons more difficult
* May not reflect when the asset is actually used
```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
# Default behavior: full emissions in purchase year
capital_asset = {
"description": "New manufacturing facility",
"expense_type": "capex",
"quantity": 5000000, # €5M full cost
"purchase_date": "2024-01-15", # All emissions in 2024
# ...
}
```
**Spread emissions over the asset's useful life, matching financial depreciation.**
This approach requires manual calculation and multiple annual entries.
**Pros:**
* Smoother emissions profile
* Better reflects when asset value is consumed
* Aligns with financial depreciation schedules
**Cons:**
* More complex to implement
* Requires tracking useful life for each asset
* Must create entries for multiple years
```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
# Example: €5M building with 25-year useful life
annual_emissions_value = 5000000 / 25 # €200,000 per year
# Create 25 annual entries
for year in range(2024, 2049):
capital_asset = {
"description": f"Manufacturing facility - Year {year - 2023} of 25",
"expense_type": "capex",
"quantity": 200000, # €200K annual portion
"purchase_date": f"{year}-01-01",
# ...
}
```
Contact Dcycle support for guidance on implementing the depreciation approach for your organization.
### Data Flow
Review your fixed asset register to identify assets acquired during the reporting period
Categorize assets (buildings, machinery, vehicles, IT, etc.) for appropriate emission factors
Select spend-based, activity-based, or supplier-specific based on available data
Record assets via API with `expense_type: "capex"` to classify as Category 2
View Category 2 emissions separately from Category 1 in reports
### Step 4.2.1: Create a Spend-Based Capital Good
| Field | Type | Required | Description | Example |
| --------------- | ------ | -------- | ---------------------- | ---------------------------------- |
| `description` | string | ❌ | Asset description | `"New manufacturing equipment"` |
| `sector` | string | ✅ | Economic sector | `"Manufacture of machinery"` |
| `product_name` | string | ✅ | Product/asset category | `"Machinery and equipment n.e.c."` |
| `quantity` | number | ✅ | Acquisition cost | `500000` |
| `unit_id` | UUID | ✅ | Currency unit (€) | `"eur-unit-uuid"` |
| `country` | string | ✅ | Country of manufacture | `"DE"` |
| `purchase_date` | date | ✅ | Acquisition date | `"2024-03-15"` |
| `expense_type` | string | ✅ | **Must be "capex"** | `"capex"` |
| `supplier_id` | UUID | ❌ | Linked supplier | `"supplier-uuid"` |
**Where to get this data:**
* **Quantity**: From fixed asset register, purchase orders, or invoices
* **Sector/Product**: Map from your asset categories (see Exiobase mapping)
* **Country**: Country where the asset was manufactured
Record a capital asset using the spend-based method:
```python Python theme={"theme":{"light":"github-light","dark":"github-dark"}}
import requests
import os
headers = {
"Authorization": f"Bearer {os.getenv('DCYCLE_API_KEY')}",
"Content-Type": "application/json",
"x-organization-id": os.getenv("DCYCLE_ORG_ID"),
"x-user-id": os.getenv("DCYCLE_USER_ID"),
}
# Get the EUR unit
units = requests.get(
"https://api.dcycle.io/v1/units",
headers=headers,
params={"page": 1, "size": 100}
).json()
eur_unit = next(u for u in units['items'] if u['abbreviation'] == '€')
# Create capital good (manufacturing equipment - spend-based)
capital_good_data = {
"description": "CNC Machining Center - Model X500",
"sector": "Manufacture of machinery and equipment n.e.c.",
"product_name": "Machinery and equipment n.e.c.",
"quantity": 500000, # €500,000 acquisition cost
"unit_id": eur_unit['id'],
"country": "DE", # Manufactured in Germany
"purchase_date": "2024-03-15",
"expense_type": "capex", # ⚠️ IMPORTANT: This makes it Category 2
"purchase_type": "spend_based",
}
response = requests.post(
"https://api.dcycle.io/v1/purchases",
headers=headers,
json=capital_good_data,
)
capital_good = response.json()
print(f"✅ Capital good recorded: {capital_good['id']}")
print(f" Description: {capital_good['description']}")
print(f" Cost: €{capital_good['quantity']:,.2f}")
print(f" CO₂e: {capital_good.get('co2e', 'Calculating...')} kg")
print(f" Category: Scope 3 - Category 2 (Capital Goods)")
```
```javascript JavaScript theme={"theme":{"light":"github-light","dark":"github-dark"}}
const axios = require('axios');
const headers = {
Authorization: `Bearer ${process.env.DCYCLE_API_KEY}`,
'Content-Type': 'application/json',
'x-organization-id': process.env.DCYCLE_ORG_ID,
'x-user-id': process.env.DCYCLE_USER_ID,
};
// Get the EUR unit
const unitsResponse = await axios.get(
'https://api.dcycle.io/v1/units',
{ headers, params: { page: 1, size: 100 } }
);
const units = unitsResponse.data;
const eurUnit = units.items.find(u => u.abbreviation === '€');
// Create capital good (manufacturing equipment - spend-based)
const capitalGoodData = {
description: 'CNC Machining Center - Model X500',
sector: 'Manufacture of machinery and equipment n.e.c.',
product_name: 'Machinery and equipment n.e.c.',
quantity: 500000, // €500,000 acquisition cost
unit_id: eurUnit.id,
country: 'DE', // Manufactured in Germany
purchase_date: '2024-03-15',
expense_type: 'capex', // ⚠️ IMPORTANT: This makes it Category 2
purchase_type: 'spend_based',
};
const response = await axios.post(
'https://api.dcycle.io/v1/purchases',
capitalGoodData,
{ headers }
);
const capitalGood = response.data;
console.log(`✅ Capital good recorded: ${capitalGood.id}`);
console.log(` Description: ${capitalGood.description}`);
console.log(` Cost: €${capitalGood.quantity.toLocaleString()}`);
console.log(` CO₂e: ${capitalGood.co2e || 'Calculating...'} kg`);
console.log(` Category: Scope 3 - Category 2 (Capital Goods)`);
```
**Critical: Set `expense_type: "capex"`**
The `expense_type` field determines which Scope 3 category the emissions are assigned to:
* `expense_type: "opex"` → Category 1 (Purchased Goods & Services)
* `expense_type: "capex"` → Category 2 (Capital Goods)
If you omit this field or set it to "opex", emissions will be incorrectly classified as Category 1.
### Step 4.2.2: Create an Activity-Based Capital Good
| Field | Type | Required | Description | Example |
| --------------- | ------ | -------- | ---------------------- | ------------------------------- |
| `description` | string | ❌ | Asset description | `"Steel production equipment"` |
| `sector` | string | ✅ | Product sector | `"Manufacture of basic metals"` |
| `product_name` | string | ✅ | Specific product | `"Basic iron and steel"` |
| `quantity` | number | ✅ | Physical quantity | `15000` |
| `unit_id` | UUID | ✅ | Physical unit (kg) | `"kg-unit-uuid"` |
| `country` | string | ✅ | Country of manufacture | `"DE"` |
| `purchase_date` | date | ✅ | Acquisition date | `"2024-03-15"` |
| `expense_type` | string | ✅ | **Must be "capex"** | `"capex"` |
| `supplier_id` | UUID | ❌ | Equipment manufacturer | `"supplier-uuid"` |
**Where to get this data:**
* **Quantity**: From equipment specifications, shipping documents, or technical data sheets
* **Unit**: Match the physical characteristic (kg for weight, m² for buildings)
Use activity-based method when you have physical specifications:
```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
import requests
import os
headers = {
"Authorization": f"Bearer {os.getenv('DCYCLE_API_KEY')}",
"Content-Type": "application/json",
"x-organization-id": os.getenv("DCYCLE_ORG_ID"),
"x-user-id": os.getenv("DCYCLE_USER_ID"),
}
# Get the kg unit
units = requests.get(
"https://api.dcycle.io/v1/units",
headers=headers,
params={"page": 1, "size": 100}
).json()
kg_unit = next(u for u in units['items'] if u['abbreviation'] == 'kg')
# Create capital good (industrial equipment - activity-based)
capital_good_data = {
"description": "Industrial Steel Press - 15 tonnes",
"sector": "Manufacture of fabricated metal products",
"product_name": "Structural metal products",
"quantity": 15000, # 15,000 kg (15 tonnes)
"unit_id": kg_unit['id'],
"country": "IT", # Manufactured in Italy
"purchase_date": "2024-06-01",
"expense_type": "capex", # Category 2
"purchase_type": "activity_based",
}
response = requests.post(
"https://api.dcycle.io/v1/purchases",
headers=headers,
json=capital_good_data,
)
capital_good = response.json()
print(f"✅ Capital good recorded (activity-based): {capital_good['id']}")
print(f" Weight: {capital_good['quantity']:,.0f} kg")
print(f" CO₂e: {capital_good.get('co2e', 'Calculating...')} kg")
```
**When to Use Activity-Based for Capital Goods**
Activity-based is particularly useful for:
* **Heavy equipment**: Weight-based calculation (kg CO₂e/kg of steel, aluminum, etc.)
* **Buildings**: Area-based calculation (kg CO₂e/m² of floor space)
* **Vehicles**: Unit-based calculation (kg CO₂e/vehicle by type)
* **Standardized equipment**: When physical specs are readily available
### Step 4.2.3: Create a Supplier-Specific Capital Good
| Field | Type | Required | Description | Example |
| --------------------------- | ------ | -------- | ------------------------------- | -------------------------- |
| `description` | string | ❌ | Asset description | `"Low-carbon HVAC system"` |
| `quantity` | number | ✅ | Physical quantity | `1` |
| `unit_id` | UUID | ✅ | Unit | `"unit-uuid"` |
| `purchase_date` | date | ✅ | Acquisition date | `"2024-03-15"` |
| `expense_type` | string | ✅ | **Must be "capex"** | `"capex"` |
| `supplier_id` | UUID | ✅ | Equipment manufacturer | `"supplier-uuid"` |
| `custom_emission_factor_id` | UUID | ✅ | Custom EF from manufacturer EPD | `"custom-ef-uuid"` |
**Where to get this data:**
* **Custom Emission Factor**: Create from manufacturer's EPD or Product Carbon Footprint
* **Supplier**: Link to the equipment manufacturer
For highest accuracy, use manufacturer-provided emission data:
```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
import requests
import os
headers = {
"Authorization": f"Bearer {os.getenv('DCYCLE_API_KEY')}",
"Content-Type": "application/json",
"x-organization-id": os.getenv("DCYCLE_ORG_ID"),
"x-user-id": os.getenv("DCYCLE_USER_ID"),
}
# Step 1: Create custom emission factor from manufacturer's EPD
kg_unit_id = "61743a63-ff70-459c-9567-5eee8f7dfd5c" # kg unit UUID
group = requests.post(
"https://api.dcycle.io/v1/custom_emission_groups",
headers=headers,
json={
"name": "GreenTech HVAC - 2024 Product Line",
"description": "EPD-verified emission factors for GreenTech HVAC systems",
"category": "capex", # Note: use capex category
"ghg_type": 1,
},
).json()
# Create emission factor from the EPD
factor = requests.post(
f"https://api.dcycle.io/v1/custom_emission_factors/{group['id']}",
headers=headers,
json={
"ef_name": "GreenTech HVAC System Model GT-500 (EPD S-P-54321)",
"unit_id": "unit-uuid", # per unit
"factor_uploaded_by": "procurement@yourcompany.com",
"tag": "advanced",
"uncertainty_grade": 10,
"factor_start_date": "2024-01-01",
"factor_end_date": "2024-12-31",
"additional_docs": "EPD No. S-P-54321, Verified by SGS",
"emission_factor_values": [
{"gas_type": "CO2", "value": 2500}, # kg CO2 per unit
{"gas_type": "CH4", "value": 5.0},
{"gas_type": "N2O", "value": 0.5},
],
},
).json()
# Step 2: Create capital good using the custom emission factor
capital_good_data = {
"description": "GreenTech HVAC System GT-500 (EPD verified)",
"quantity": 3, # 3 units
"unit_id": "unit-uuid",
"purchase_date": "2024-04-01",
"expense_type": "capex",
"supplier_id": "greentech-supplier-uuid",
"custom_emission_factor_id": factor['id'],
}
response = requests.post(
"https://api.dcycle.io/v1/purchases",
headers=headers,
json=capital_good_data,
)
capital_good = response.json()
print(f"✅ Capital good recorded (supplier-specific): {capital_good['id']}")
print(f" Units: {capital_good['quantity']}")
print(f" CO₂e: {capital_good.get('co2e', 'Calculating...')} kg")
print(f" Method: EPD-verified (highest accuracy)")
```
**Finding EPDs for Capital Equipment**
Environmental Product Declarations (EPDs) are increasingly available for:
* **Construction products**: Concrete, steel, insulation, windows
* **HVAC equipment**: Heating, cooling, ventilation systems
* **Vehicles**: Major manufacturers publish vehicle PCFs
* **IT equipment**: Servers, computers (check manufacturer websites)
EPD registries:
* [EPD International](https://www.environdec.com/) - Global
* [IBU EPD](https://ibu-epd.com/) - Germany
* [INIES](https://www.inies.fr/) - France
## Bulk Upload Capital Goods
For large capital investments or fixed asset registers:
### CSV Format for Capital Goods
```csv theme={"theme":{"light":"github-light","dark":"github-dark"}}
description,sector,product_name,quantity,unit_id,country,purchase_date,expense_type,supplier_id,purchase_type
"Manufacturing facility expansion",Construction,Construction work,2000000,eur-uuid,ES,2024-01-15,capex,,spend_based
"CNC Machine Model X500",Manufacture of machinery,Machinery and equipment,500000,eur-uuid,DE,2024-02-01,capex,supplier-uuid-1,spend_based
"Fleet vehicles (10 trucks)",Manufacture of motor vehicles,Motor vehicles,750000,eur-uuid,ES,2024-03-01,capex,supplier-uuid-2,spend_based
"Server infrastructure",Manufacture of computers,Computer and electronic products,300000,eur-uuid,US,2024-04-01,capex,supplier-uuid-3,spend_based
```
**Key points:**
* `expense_type` must be `capex` for all capital goods
* Use appropriate sector/product mapping for each asset type
* Include supplier\_id when available for tracking
### Upload Process
```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
# Get presigned URL for bulk upload
upload_response = requests.post(
"https://api.dcycle.io/v1/purchases/bulk/csv",
headers=headers,
json={"file_name": "capital_goods_2024.csv"},
).json()
# Upload CSV to presigned URL
with open('capital_goods_2024.csv', 'rb') as f:
requests.put(upload_response['upload_url'], data=f)
print(f"✅ Capital goods CSV uploaded")
print(f" Processing will begin automatically")
```
## Common Capital Goods Sectors
Here are the most common Exiobase sectors for capital goods:
| Asset Type | Exiobase Sector | Typical EF (kg CO₂e/€) |
| -------------------------- | -------------------------------------------------------- | ---------------------- |
| **Buildings - Commercial** | Construction | 0.30 - 0.45 |
| **Buildings - Industrial** | Construction | 0.35 - 0.50 |
| **Machinery - General** | Manufacture of machinery and equipment n.e.c. | 0.40 - 0.55 |
| **Vehicles - Trucks** | Manufacture of motor vehicles | 0.35 - 0.45 |
| **Vehicles - Cars** | Manufacture of motor vehicles | 0.30 - 0.40 |
| **IT - Servers** | Manufacture of computer, electronic and optical products | 0.25 - 0.40 |
| **IT - Computers** | Manufacture of computer, electronic and optical products | 0.20 - 0.35 |
| **HVAC Systems** | Manufacture of electrical equipment | 0.35 - 0.50 |
| **Furniture** | Manufacture of furniture | 0.25 - 0.40 |
**Construction Projects**
For major construction projects (new buildings, facility expansions), consider:
1. **Spend-based** for initial estimates (total project cost × construction EF)
2. **Activity-based** for major materials (steel, concrete, glass tonnage)
3. **EPDs** for specific materials from suppliers
This hybrid approach improves accuracy while remaining practical.
## Query Capital Goods Emissions
### Separate Category 1 and Category 2 in Reports
```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
# Query purchases filtered by expense_type
capital_goods = requests.get(
"https://api.dcycle.io/v1/purchases",
headers=headers,
params={
"page": 1,
"size": 50,
"expense_type": "capex", # Only capital goods
"start_date": "2024-01-01",
"end_date": "2024-12-31",
},
).json()
purchased_goods = requests.get(
"https://api.dcycle.io/v1/purchases",
headers=headers,
params={
"page": 1,
"size": 50,
"expense_type": "opex", # Only regular purchases
"start_date": "2024-01-01",
"end_date": "2024-12-31",
},
).json()
# Calculate totals
cat2_total = sum(p['co2e'] for p in capital_goods['items'])
cat1_total = sum(p['co2e'] for p in purchased_goods['items'])
print(f"📊 Scope 3 Purchases Summary (2024)")
print(f" Category 1 (Purchased goods): {cat1_total:,.0f} kg CO₂e")
print(f" Category 2 (Capital goods): {cat2_total:,.0f} kg CO₂e")
print(f" Total: {cat1_total + cat2_total:,.0f} kg CO₂e")
```
### Analyze Capital Goods by Asset Type
```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
from collections import defaultdict
# Aggregate by sector
by_sector = defaultdict(lambda: {'co2e': 0, 'cost': 0, 'count': 0})
for asset in capital_goods['items']:
sector = asset['sector']
by_sector[sector]['co2e'] += asset['co2e']
by_sector[sector]['cost'] += asset['quantity']
by_sector[sector]['count'] += 1
# Sort by emissions
sorted_sectors = sorted(
by_sector.items(),
key=lambda x: x[1]['co2e'],
reverse=True
)
print(f"\n📊 Capital Goods by Asset Type")
for sector, data in sorted_sectors:
pct = (data['co2e'] / cat2_total) * 100 if cat2_total > 0 else 0
print(f"\n{sector}:")
print(f" Assets: {data['count']}")
print(f" Investment: €{data['cost']:,.0f}")
print(f" CO₂e: {data['co2e']:,.0f} kg ({pct:.1f}%)")
```
## Troubleshooting
### Issue: Capital Good Showing as Category 1
```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
# Check the expense_type field
purchase = requests.get(
f"https://api.dcycle.io/v1/purchases/{purchase_id}",
headers=headers,
).json()
print(f"Expense type: {purchase['expense_type']}")
if purchase['expense_type'] != 'capex':
print("⚠️ This is classified as Category 1, not Category 2")
print("💡 Update the expense_type to 'capex':")
# Fix the classification
requests.patch(
f"https://api.dcycle.io/v1/purchases/{purchase_id}",
headers=headers,
json={"expense_type": "capex"},
)
```
### Issue: What Counts as a Capital Good?
```python theme={"theme":{"light":"github-light","dark":"github-dark"}}
"""
CAPITAL GOODS (Category 2 - use expense_type: "capex"):
✅ Buildings, facilities, infrastructure
✅ Machinery and production equipment
✅ Vehicles (if purchased, not leased)
✅ IT servers, data centers
✅ Office furniture (if capitalized)
✅ Major renovations/improvements
PURCHASED GOODS (Category 1 - use expense_type: "opex"):
✅ Raw materials, components
✅ Office supplies
✅ Services (consulting, cleaning, etc.)
✅ Maintenance and repairs
✅ Leased assets (Category 8)
✅ Items expensed in year of purchase
RULE OF THUMB:
- If it's capitalized on your balance sheet → Category 2 (capex)
- If it's expensed in P&L → Category 1 (opex)
"""
```
## Next Steps
Track regular purchased goods and services
Use manufacturer EPDs for equipment
Complete supply chain management
Back to all Scope 3 categories