Waste Classification Codes - Dcycle Platform Docs

Legacy API. This page documents the previous version of the API. This particular operation has no documented equivalent in the current API yet, so this remains the documented way to do it. Prefer the current API for everything it already covers.

Retrieve waste classification codes used in the Dcycle system for waste management and emissions calculations. These codes are based on European waste regulations and help classify waste types and disposal methods.

Waste codes are reference data maintained by Dcycle. You cannot create or modify codes through the API - these endpoints are read-only.

Overview

Dcycle uses three types of waste codes:

LER (Lista Europea de Residuos / European Waste List) - Waste type classification
RD (Royal Decree) - Disposal method classification
LOW (List of Waste) - Regional waste codes

Code format. Both endpoints on this page read the same catalog, so the values follow the same rules:

RD codes are zero-padded to two digits: D09, R03. When you filter GET /v1/waste-efs by RD code, D9 and R3 match nothing while D09 and R03 do.
Hazardous LER codes end with an asterisk, which is part of the code: 130507*.
LER codes carry no spaces: 150101, not 15 01 01.
rd_name and ler_name come back as slugs (other_fisic_chemics_not_in_anex), not prose.

To browse the catalog with human-readable descriptions, use GET /v1/waste-efs in the new API instead. Note that waste_efs_id is no longer accepted when creating or updating a waste — use the MultiDB GET /v1/wastes/ler-codes and GET /v1/wastes/rd-codes endpoints for that instead.

GET /api/v1/wastes/rd_ler_list

Get all waste disposal methods (RD codes) with their associated waste types (LER codes). This endpoint returns a complete mapping of which waste types can be processed with which disposal methods.

Request

Headers

string

required

Your API key for authenticationExample: sk_live_1234567890abcdef

string

required

Your organization UUIDExample: ff4adcc7-8172-45fe-9cf1-e90a6de53aa9

string

required

Your user UUIDExample: a1b2c3d4-e5f6-7890-abcd-ef1234567890

No query parameters required.

Response

array

Array of RD-LER mapping objects

string | null

Royal Decree disposal method code, zero-padded to two digits. Entries with no treatment recorded are grouped under null.Examples: "D09", "R03"

string

Disposal method slugExample: "other_fisic_chemics_not_in_anex"

array

Array of LER (waste type) objects applicable to this disposal methodEach LER object contains:

ler_code (string) - European waste code, 6 digits with no spaces (130507). Hazardous codes end with an asterisk (130507*)
ler_name (string) - Waste type slug

Example

curl -X GET "https://api.dcycle.io/api/v1/wastes/rd_ler_list" \
  -H "Authorization: Bearer ${DCYCLE_API_KEY}" \
  -H "x-organization-id: ${DCYCLE_ORG_ID}" \
  -H "x-user-id: ${DCYCLE_USER_ID}"

import requests
import os

api_key = os.getenv("DCYCLE_API_KEY")
org_id = os.getenv("DCYCLE_ORG_ID")
user_id = os.getenv("DCYCLE_USER_ID")

headers = {
    "Authorization": f"Bearer {api_key}",
    "x-organization-id": org_id,
    "x-user-id": user_id
}

response = requests.get(
    "https://api.dcycle.io/api/v1/wastes/rd_ler_list",
    headers=headers
)

rd_ler_mapping = response.json()
print(f"Found {len(rd_ler_mapping)} disposal methods:")

for disposal in rd_ler_mapping:
    print(f"\n{disposal['rd_code']} - {disposal['rd_name']}")
    print(f"  Applicable to {len(disposal['ler_list'])} waste types")
    # Show first 3 waste types
    for ler in disposal['ler_list'][:3]:
        print(f"    - {ler['ler_code']}: {ler['ler_name']}")

const axios = require('axios');

const apiKey = process.env.DCYCLE_API_KEY;
const orgId = process.env.DCYCLE_ORG_ID;
const userId = process.env.DCYCLE_USER_ID;

const headers = {
  'Authorization': `Bearer ${apiKey}`,
  'x-organization-id': orgId,
  'x-user-id': userId
};

axios.get('https://api.dcycle.io/api/v1/wastes/rd_ler_list', { headers })
  .then(response => {
    const rdLerMapping = response.data;
    console.log(`Found ${rdLerMapping.length} disposal methods:`);

    rdLerMapping.forEach(disposal => {
      console.log(`\n${disposal.rd_code} - ${disposal.rd_name}`);
      console.log(`  Applicable to ${disposal.ler_list.length} waste types`);
      // Show first 3 waste types
      disposal.ler_list.slice(0, 3).forEach(ler => {
        console.log(`    - ${ler.ler_code}: ${ler.ler_name}`);
      });
    });
  })
  .catch(error => console.error(error));

Successful Response

[
  {
    "rd_code": "D01",
    "rd_name": "deposit_on_the_floor_or_its_interior",
    "ler_list": [
      {
        "ler_code": "010101",
        "ler_name": "residues_of_metal_mineral_extraction"
      },
      {
        "ler_code": "010102",
        "ler_name": "residues_of_non_metallic_minerals"
      }
    ]
  },
  {
    "rd_code": "R03",
    "rd_name": "recycling_recovery_of_organic_substances",
    "ler_list": [
      {
        "ler_code": "010101",
        "ler_name": "residues_of_metal_mineral_extraction"
      },
      {
        "ler_code": "010102",
        "ler_name": "residues_of_non_metallic_minerals"
      }
    ]
  }
]

Truncated: the real response carries every RD code in the catalog, each with hundreds of LER codes, plus one group with "rd_code": null for entries with no treatment recorded.

GET /api/v1/wastes/low_codes

Get waste type codes (LOW codes) for a specific region. These codes are used when creating waste records to classify the type of waste being disposed.

Request

Headers

string

required

Your API key for authenticationExample: sk_live_1234567890abcdef

string

required

Your organization UUIDExample: ff4adcc7-8172-45fe-9cf1-e90a6de53aa9

string

required

Your user UUIDExample: a1b2c3d4-e5f6-7890-abcd-ef1234567890

Query Parameters

string

required

Region code for waste classificationCommon values:

ES - Spain
EU - European Union (generic)
UK - United Kingdom
Other ISO 3166-1 alpha-2 codes

Example: "ES"

Response

array

Array of LOW (waste type) code objects

string

Unique waste type identifier (UUID)

string

Waste type code: 6 digits with no spaces, plus a trailing * for hazardous wasteExamples: "010101", "150101", "200101"

string

Waste type descriptionExamples: "Paper and cardboard", "Plastic packaging", "Mixed municipal waste"

Example

curl -X GET "https://api.dcycle.io/api/v1/wastes/low_codes?waste_region=GLO" \
  -H "Authorization: Bearer ${DCYCLE_API_KEY}" \
  -H "x-organization-id: ${DCYCLE_ORG_ID}" \
  -H "x-user-id: ${DCYCLE_USER_ID}"

import requests
import os

api_key = os.getenv("DCYCLE_API_KEY")
org_id = os.getenv("DCYCLE_ORG_ID")
user_id = os.getenv("DCYCLE_USER_ID")

headers = {
    "Authorization": f"Bearer {api_key}",
    "x-organization-id": org_id,
    "x-user-id": user_id
}

# Get Spanish waste codes
params = {"waste_region": "GLO"}

response = requests.get(
    "https://api.dcycle.io/api/v1/wastes/low_codes",
    headers=headers,
    params=params
)

low_codes = response.json()
print(f"Found {len(low_codes)} waste type codes for Spain:")

# Group by first 2 digits (waste category)
categories = {}
for waste in low_codes:
    category = waste['low_code'][:2]
    if category not in categories:
        categories[category] = []
    categories[category].append(waste)

# Display waste categories
for category, wastes in sorted(categories.items()):
    print(f"\nCategory {category}: {len(wastes)} waste types")
    for waste in wastes[:3]:  # Show first 3
        print(f"  - {waste['low_code']}: {waste['low_name']}")

const axios = require('axios');

const apiKey = process.env.DCYCLE_API_KEY;
const orgId = process.env.DCYCLE_ORG_ID;
const userId = process.env.DCYCLE_USER_ID;

const headers = {
  'Authorization': `Bearer ${apiKey}`,
  'x-organization-id': orgId,
  'x-user-id': userId
};

// Get Spanish waste codes
const params = { waste_region: 'GLO' };

axios.get('https://api.dcycle.io/api/v1/wastes/low_codes', { headers, params })
  .then(response => {
    const lowCodes = response.data;
    console.log(`Found ${lowCodes.length} waste type codes for Spain:`);

    // Group by first 2 digits (waste category)
    const categories = {};
    lowCodes.forEach(waste => {
      const category = waste.low_code.substring(0, 2);
      if (!categories[category]) {
        categories[category] = [];
      }
      categories[category].push(waste);
    });

    // Display waste categories
    Object.keys(categories).sort().forEach(category => {
      const wastes = categories[category];
      console.log(`\nCategory ${category}: ${wastes.length} waste types`);
      wastes.slice(0, 3).forEach(waste => {
        console.log(`  - ${waste.low_code}: ${waste.low_name}`);
      });
    });
  })
  .catch(error => console.error(error));

Successful Response

[
  {
    "low_id": "e7147c3a-a5cb-444b-afed-fc1101efbf78",
    "low_code": "150101",
    "low_name": "paper_and_cardboard_containers"
  },
  {
    "low_id": "34d01408-134f-4668-8e22-cc78a6b36467",
    "low_code": "150102",
    "low_name": "plastic_bottles"
  },
  {
    "low_id": "2bd97952-ad72-4a3b-abe5-cfc58842da1e",
    "low_code": "150103",
    "low_name": "wooden_containers"
  },
  {
    "low_id": "e357183f-1fdf-4f04-a84d-668f51fcd898",
    "low_code": "150104",
    "low_name": "metal_containers"
  },
  {
    "low_id": "536f81f2-2776-444f-8c75-84f0d261c00b",
    "low_code": "150105",
    "low_name": "compound_containers"
  }
]

Common Errors

400 Bad Request - Missing waste_region

Cause: Field required For /api/v1/wastes/low_codes:

{
  "detail": "Field required",
  "field": "waste_region"
}

Solution: Include the waste_region query parameter.

400 Bad Request - Invalid Region

Cause: Invalid region code

{
  "detail": "Invalid region code",
  "code": "VALIDATION_ERROR"
}

Solution: Use a valid ISO 3166-1 alpha-2 country code.

403 Forbidden

Cause: Organization ID doesn’t match your API key or user doesn’t belong to organization

{
  "detail": "Not authorized",
  "code": "FORBIDDEN"
}

Solution: Verify that x-organization-id matches your API key’s organization.

Use Cases

Build Waste Type Selector

Create a dropdown selector for waste types:

def get_waste_types_for_selector(region="ES"):
    """Get waste types organized by category"""

    response = requests.get(
        "https://api.dcycle.io/api/v1/wastes/low_codes",
        headers=headers,
        params={"waste_region": region}
    )

    waste_codes = response.json()

    # Organize by category (first 2 digits)
    categories = {}
    for waste in waste_codes:
        category_code = waste['low_code'][:2]
        category_name = get_category_name(category_code)

        if category_name not in categories:
            categories[category_name] = []

        categories[category_name].append({
            'id': waste['low_id'],
            'code': waste['low_code'],
            'name': waste['low_name']
        })

    return categories

def get_category_name(code):
    """Map category codes to names"""
    categories = {
        '01': 'Mining and quarrying wastes',
        '02': 'Agricultural wastes',
        '15': 'Packaging wastes',
        '16': 'Wastes not otherwise specified',
        '17': 'Construction and demolition wastes',
        '19': 'Waste treatment wastes',
        '20': 'Municipal wastes'
    }
    return categories.get(code, f'Category {code}')

# Usage
waste_types = get_waste_types_for_selector("ES")
print("Packaging Wastes:")
for waste in waste_types.get('Packaging wastes', []):
    print(f"  {waste['code']}: {waste['name']}")

Find Applicable Disposal Methods

Find which disposal methods can be used for a specific waste type:

def get_disposal_methods_for_waste(waste_ler_code):
    """Find applicable disposal methods for a waste type"""

    response = requests.get(
        "https://api.dcycle.io/api/v1/wastes/rd_ler_list",
        headers=headers
    )

    rd_ler_mapping = response.json()

    # Find disposal methods that accept this waste type
    applicable_methods = []
    for disposal in rd_ler_mapping:
        for ler in disposal['ler_list']:
            if ler['ler_code'] == waste_ler_code:
                applicable_methods.append({
                    'rd_code': disposal['rd_code'],
                    'rd_name': disposal['rd_name']
                })
                break

    if applicable_methods:
        print(f"Disposal methods for {waste_ler_code}:")
        for method in applicable_methods:
            print(f"  - {method['rd_code']}: {method['rd_name']}")
    else:
        print(f"No disposal methods found for {waste_ler_code}")

    return applicable_methods

# Example: Find disposal methods for plastic packaging
methods = get_disposal_methods_for_waste("15 01 02")

Cache Waste Codes

Since waste codes don’t change frequently, cache them:

from datetime import datetime, timedelta

class WasteCodesCache:
    def __init__(self, api_key, org_id, user_id):
        self.headers = {
            "Authorization": f"Bearer {api_key}",
            "x-organization-id": org_id,
            "x-user-id": user_id
        }
        self._low_codes_cache = {}
        self._rd_ler_cache = None
        self._cache_time = {}
        self.cache_duration = timedelta(days=7)  # Waste codes rarely change

    def get_low_codes(self, region):
        """Get LOW codes with caching"""

        if (region not in self._cache_time or
            datetime.now() - self._cache_time[region] > self.cache_duration):
            self._refresh_low_codes(region)

        return self._low_codes_cache.get(region, [])

    def _refresh_low_codes(self, region):
        """Refresh LOW codes cache"""

        response = requests.get(
            "https://api.dcycle.io/api/v1/wastes/low_codes",
            headers=self.headers,
            params={"waste_region": region}
        )

        codes = response.json()
        self._low_codes_cache[region] = codes
        self._cache_time[region] = datetime.now()

        print(f"✅ LOW codes cache refreshed for {region}: {len(codes)} codes")

    def get_rd_ler_mapping(self):
        """Get RD-LER mapping with caching"""

        if (self._rd_ler_cache is None or
            datetime.now() - self._cache_time.get('rd_ler', datetime.min) > self.cache_duration):
            self._refresh_rd_ler_mapping()

        return self._rd_ler_cache

    def _refresh_rd_ler_mapping(self):
        """Refresh RD-LER mapping cache"""

        response = requests.get(
            "https://api.dcycle.io/api/v1/wastes/rd_ler_list",
            headers=self.headers
        )

        self._rd_ler_cache = response.json()
        self._cache_time['rd_ler'] = datetime.now()

        print(f"✅ RD-LER mapping cache refreshed: {len(self._rd_ler_cache)} methods")

    def get_low_code_by_id(self, low_id, region):
        """Get specific LOW code by ID"""

        codes = self.get_low_codes(region)
        for code in codes:
            if code['low_id'] == low_id:
                return code
        return None

    def search_low_codes(self, query, region):
        """Search LOW codes by name or code"""

        codes = self.get_low_codes(region)
        query_lower = query.lower()

        results = []
        for code in codes:
            if (query_lower in code['low_code'].lower() or
                query_lower in code['low_name'].lower()):
                results.append(code)

        return results

# Usage
cache = WasteCodesCache(
    api_key=os.getenv("DCYCLE_API_KEY"),
    org_id=os.getenv("DCYCLE_ORG_ID"),
    user_id=os.getenv("DCYCLE_USER_ID")
)

# Search for plastic-related waste codes
plastic_wastes = cache.search_low_codes("plastic", "ES")
print(f"Found {len(plastic_wastes)} plastic waste codes")

Validate Waste Code Before Creating Waste

Ensure the waste code exists before creating a waste record:

def validate_waste_code(low_code, region):
    """Validate that a waste code exists in the region"""

    response = requests.get(
        "https://api.dcycle.io/api/v1/wastes/low_codes",
        headers=headers,
        params={"waste_region": region}
    )

    waste_codes = response.json()

    # Check if code exists
    for waste in waste_codes:
        if waste['low_code'] == low_code:
            return waste['low_id']

    raise ValueError(f"Waste code '{low_code}' not found in region '{region}'")

# Usage
try:
    low_id = validate_waste_code("15 01 02", "ES")
    print(f"✅ Valid waste code, LOW ID: {low_id}")
except ValueError as e:
    print(f"❌ {e}")

Waste Code Categories

LER Code Structure

LER codes follow a 6-digit hierarchical structure, written without separators (XXXXXX)

First 2 digits: Waste source/activity
Middle 2 digits: Process within activity
Last 2 digits: Specific waste type

Example: 15 01 02

15 - Waste packaging materials
01 - Packaging
02 - Plastic packaging

Common LER Categories

Code Range	Category	Examples
`01 XX XX`	Mining and quarrying	Tailings, excavation waste
`02 XX XX`	Agriculture, forestry	Organic waste, packaging
`15 XX XX`	Packaging	Paper, plastic, metal, glass
`16 XX XX`	Not otherwise specified	Batteries, electronics
`17 XX XX`	Construction & demolition	Concrete, wood, metal
`19 XX XX`	Waste treatment facilities	Residues, sludges
`20 XX XX`	Municipal waste	Household waste, garden waste

Hazardous Waste Codes

Codes ending with an asterisk (*) indicate hazardous waste:

17 05 03* - Soil containing dangerous substances
16 06 01* - Lead batteries
15 01 10* - Packaging containing hazardous residues

Hazardous waste requires special handling, disposal methods, and documentation. Check your local regulations.

Disposal Method Codes (RD)

The tables below use the numbering from the Royal Decree. The API stores and returns these codes zero-padded to two digits, so R3 in the regulation is R03 in the API.

D Codes (Disposal Operations)

Code	`rd_name` as returned
`D01`	`deposit_on_the_floor_or_its_interior`
`D02`	`biodegradation_of_liquid_waste_and_sludge_in_a_terrestrial_medium`
`D03`	`injection_of_in_depth_liquid_waste`
`D05`	`deposit_in_controlled_places`
`D08`	`biological_waste_treatment`
`D09`	`other_fisic_chemics_not_in_anex`
`D10`	`earth_incineration`
`D13`	`combination_or_mixture_prior_to_disposal`
`D15`	`temporary_storage_in_manager`

R Codes (Recovery Operations)

Code	`rd_name` as returned
`R01`	`main_fuel_usage_other_to_produce_energy`
`R02`	`solvents_recovery`
`R03`	`recycling_recovery_of_organic_substances`
`R04`	`metal_recycling`
`R05`	`recycling_of_other_inorganic_subjects`
`R06`	`regeneration_of_acids_and_bases`
`R07`	`component_valuation_for_treatments`
`R08`	`catalyst_valuation`
`R09`	`oil_regeneration`
`R10`	`agricultural_soil_treatment`
`R11`	`use_of_waste_obtained_in_r1_to_r10_operations`
`R12`	`waste_exchange_to_submit_them_to_r1_to_r10_operations`
`R13`	`temporary_storage_in_recycling_manager`
`R14`	`preparation_for_reuse`

Best Practices

1. Cache Reference Data

Waste codes rarely change, so cache them for extended periods:

# Good - Cache for 7 days
cache = WasteCodesCache()
codes = cache.get_low_codes("GLO")

# Bad - Fetch every time
codes = requests.get("https://api.dcycle.io/api/v1/wastes/low_codes?waste_region=GLO")

2. Pass the Catalog Region

waste_region is required, and the catalog Dcycle ships is global: pass GLO. Any other region code is accepted by the endpoint but matches no rows, so it returns an empty list.

# Good - the catalog region
codes = get_low_codes(waste_region="GLO")

# Bad - a country code returns []
codes = get_low_codes(waste_region="ES")

3. Store LOW IDs, Not Codes

When creating waste records, use the low_id, not the low_code:

# Good - Use UUID
waste_data = {
    "low_id": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
    # ... other fields
}

# Bad - Use code string (won't work)
waste_data = {
    "low_code": "15 01 02",  # API expects low_id
    # ... other fields
}

4. Validate Before Creating Waste

Always validate that the waste code exists before submitting:

def create_waste_safely(low_code, region, quantity, **kwargs):
    # 1. Validate code exists
    low_id = validate_waste_code(low_code, region)

    # 2. Create waste with validated ID
    waste_data = {
        "low_id": low_id,
        "quantity": quantity,
        **kwargs
    }

    response = requests.post(
        "https://api.dcycle.io/api/v1/wastes",
        headers=headers,
        json=waste_data
    )

    return response.json()

List Facilities

View facilities where waste is generated

List Units

Get units for waste quantities

List Invoices

View facility consumption data

Authentication

Learn about API authentication

​Overview

​GET /api/v1/wastes/rd_ler_list

​Request

​Headers

​Response

​Example

​Successful Response

​GET /api/v1/wastes/low_codes

​Request

​Headers

​Query Parameters

​Response

​Example

​Successful Response

​Common Errors

​400 Bad Request - Missing waste_region

​400 Bad Request - Invalid Region

​403 Forbidden

​Use Cases

​Build Waste Type Selector

​Find Applicable Disposal Methods

​Cache Waste Codes

​Validate Waste Code Before Creating Waste

​Waste Code Categories

​LER Code Structure

​Common LER Categories

​Hazardous Waste Codes

​Disposal Method Codes (RD)

​D Codes (Disposal Operations)

​R Codes (Recovery Operations)

​Best Practices

​1. Cache Reference Data

​2. Pass the Catalog Region

​3. Store LOW IDs, Not Codes

​4. Validate Before Creating Waste

​Related Endpoints

List Facilities

List Units

List Invoices

Authentication

Overview

GET /api/v1/wastes/rd_ler_list

Request

Headers

Response

Example

Successful Response

GET /api/v1/wastes/low_codes

Request

Headers

Query Parameters

Response

Example

Successful Response

Common Errors

400 Bad Request - Missing waste_region

400 Bad Request - Invalid Region

403 Forbidden

Use Cases

Build Waste Type Selector

Find Applicable Disposal Methods

Cache Waste Codes

Validate Waste Code Before Creating Waste

Waste Code Categories

LER Code Structure

Common LER Categories

Hazardous Waste Codes

Disposal Method Codes (RD)

D Codes (Disposal Operations)

R Codes (Recovery Operations)

Best Practices

1. Cache Reference Data

2. Pass the Catalog Region

3. Store LOW IDs, Not Codes

4. Validate Before Creating Waste

Related Endpoints