Request

Response

    Beta APIs are subject to change. Please avoid using them in production environments.

    Filter Generic Estimate Impact Indicators

    This task shows you how to retrieve and filter environmental impact indicators for a specific generic estimate. Impact indicators provide detailed lifecycle assessment (LCA) data across different lifecycle stages, helping you understand the environmental footprint of building materials and products.

    By the end of this task, you will know how to:

    • Call the impact indicators filter endpoint for a generic estimate
    • Understand different impact indicator types (GWP, ADPE, AP, etc.)
    • Interpret lifecycle stage data (A1-A3, A4-A5, B1-B5, C1-C4, D)
    • Work with reference periods for use-stage impacts
    • Compare environmental impacts across different indicators

    You use the following operation for this task:

    OperationHTTP Request
    Filter Impact Indicators for Generic Estimates POST /v3/datasets/{datasetId}/generic-estimates/details/{genericEstimateId}/impacts:filter

    Prerequisites

    Before starting this task, ensure you have:


    Step 1: Call the Impact Indicators Filter Endpoint

    Use the access token from Obtain an Access Token, a dataset ID from Get the List of Supported Datasets, and a generic estimate ID from Filter Generic Estimates to retrieve impact indicators for a specific generic estimate.

    Replace <YOUR_ACCESS_TOKEN>, <DATASET_ID>, and <GENERIC_ESTIMATE_ID> with your values.

    curl -v 'https://developer.api.autodesk.com/sustainability/v3/datasets/<DATASET_ID>/generic-estimates/details/<GENERIC_ESTIMATE_ID>/impacts:filter' \
      -X 'POST' \
      -H 'Authorization: Bearer <YOUR_ACCESS_TOKEN>' \
      -H 'Content-Type: application/json' \
      -H 'Accept: application/json' \
      -d '{
        "filters": {}
      }'
    
    Show More
    const accessToken = "<YOUR_ACCESS_TOKEN>";
    const datasetId = "<DATASET_ID>";
    const genericEstimateId = "<GENERIC_ESTIMATE_ID>";
    const url = `https://developer.api.autodesk.com/sustainability/v3/datasets/${datasetId}/generic-estimates/details/${genericEstimateId}/impacts:filter`;
    
    fetch(url, {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${accessToken}`,
        'Content-Type': 'application/json',
        'Accept': 'application/json'
      },
      body: JSON.stringify({ filters: {} })
    })
    .then(res => res.json())
    .then(data => {
      const impacts = data.results || [];
      console.log(`=== Impact Indicators (${impacts.length} indicators found) ===\n`);
    
      impacts.forEach((impact, index) => {
        console.log(`\n--- Indicator ${index + 1}: ${String(impact.indicator || '').toUpperCase()} ---`);
        console.log(`Methodology: ${impact.methodology}`);
    
        if (impact.declaredUnit) {
          console.log(`Declared Unit: ${impact.declaredUnit.qty} ${impact.declaredUnit.unit}`);
        }
    
        const stages = [
          { name: 'A1-A3 (Raw Materials & Manufacturing)', key: 'a1a2a3' },
          { name: 'A1', key: 'a1' }, { name: 'A2', key: 'a2' }, { name: 'A3', key: 'a3' },
          { name: 'A4 (Transport)', key: 'a4' },
          { name: 'A5 (Installation)', key: 'a5' },
          { name: 'B1 (Use)', key: 'b1' },
          { name: 'B2 (Maintenance)', key: 'b2' },
          { name: 'B3 (Repair)', key: 'b3' },
          { name: 'B4 (Replacement)', key: 'b4' },
          { name: 'B5 (Refurbishment)', key: 'b5' },
          { name: 'B1-B5 (Aggregate)', key: 'b1b2b3b4b5' },
          { name: 'C1 (Deconstruction)', key: 'c1' },
          { name: 'C2 (Transport to Disposal)', key: 'c2' },
          { name: 'C3 (Waste Processing)', key: 'c3' },
          { name: 'C4 (Disposal)', key: 'c4' },
          { name: 'C1-C4 (Aggregate)', key: 'c1c2c3c4' },
          { name: 'D (Beyond System Boundary)', key: 'd' }
        ];
    
        console.log('\nLifecycle Stages:');
        stages.forEach(stage => {
          const v = impact[stage.key];
          if (v && v.qty != null && v.unit != null) {
            let out = `  ${stage.name}: ${v.qty} ${v.unit}`;
            if (v.referencePeriod) {
              out += ` (over ${v.referencePeriod.qty} ${v.referencePeriod.unit})`;
            }
            console.log(out);
          }
        });
      });
    
      if (data.pagination) {
        console.log(`\nPagination: offset=${data.pagination.offset}, limit=${data.pagination.limit}, nextUrl=${data.pagination.nextUrl}`);
      }
    })
    .catch(err => console.error('Error:', err));
    
    Show More
    import requests
    
    access_token = "<YOUR_ACCESS_TOKEN>"
    dataset_id = "<DATASET_ID>"
    generic_estimate_id = "<GENERIC_ESTIMATE_ID>"
    url = f"https://developer.api.autodesk.com/sustainability/v3/datasets/{dataset_id}/generic-estimates/details/{generic_estimate_id}/impacts:filter"
    
    headers = {
        'Authorization': f'Bearer {access_token}',
        'Content-Type': 'application/json',
        'Accept': 'application/json'
    }
    
    resp = requests.post(url, headers=headers, json={"filters": {}})
    resp.raise_for_status()
    data = resp.json()
    
    impacts = data.get('results', [])
    print(f"=== Impact Indicators ({len(impacts)} indicators found) ===\n")
    
    stages = [
        ('A1-A3 (Raw Materials & Manufacturing)', 'a1a2a3'),
        ('A1', 'a1'), ('A2', 'a2'), ('A3', 'a3'),
        ('A4 (Transport)', 'a4'),
        ('A5 (Installation)', 'a5'),
        ('B1 (Use)', 'b1'),
        ('B2 (Maintenance)', 'b2'),
        ('B3 (Repair)', 'b3'),
        ('B4 (Replacement)', 'b4'),
        ('B5 (Refurbishment)', 'b5'),
        ('B1-B5 (Aggregate)', 'b1b2b3b4b5'),
        ('C1 (Deconstruction)', 'c1'),
        ('C2 (Transport to Disposal)', 'c2'),
        ('C3 (Waste Processing)', 'c3'),
        ('C4 (Disposal)', 'c4'),
        ('C (Aggregate)', 'c1c2c3c4'),
        ('D (Beyond System Boundary)', 'd')
    ]
    
    for idx, impact in enumerate(impacts, start=1):
        print(f"\n--- Indicator {idx}: {impact.get('indicator','').upper()} ---")
        print(f"Methodology: {impact.get('methodology')}")
        du = impact.get('declaredUnit')
        if du:
            print(f"Declared Unit: {du.get('qty')} {du.get('unit')}")
    
        print('\nLifecycle Stages:')
        for stage_name, stage_key in stages:
            v = impact.get(stage_key)
            if v and v.get('qty') is not None and v.get('unit') is not None:
                out = f"  {stage_name}: {v['qty']} {v['unit']}"
                rp = v.get('referencePeriod')
                if rp:
                    out += f" (over {rp.get('qty')} {rp.get('unit')})"
                print(out)
    
    if 'pagination' in data:
        p = data['pagination']
        print(f"\nPagination: offset={p.get('offset')}, limit={p.get('limit')}, nextUrl={p.get('nextUrl')}")
    
    Show More
    using System;
    using System.Net.Http;
    using System.Text;
    using System.Threading.Tasks;
    using Newtonsoft.Json.Linq;
    
    public class GenericEstimateImpactsService
    {
        private readonly HttpClient _httpClient = new HttpClient();
    
        public async Task GetImpactsAsync(string accessToken, string datasetId, string genericEstimateId)
        {
            string url = $"https://developer.api.autodesk.com/sustainability/v3/datasets/{datasetId}/generic-estimates/details/{genericEstimateId}/impacts:filter";
    
            var req = new StringContent("{\"filters\": {}}", Encoding.UTF8, "application/json");
            _httpClient.DefaultRequestHeaders.Clear();
            _httpClient.DefaultRequestHeaders.Add("Authorization", $"Bearer {accessToken}");
            _httpClient.DefaultRequestHeaders.Add("Accept", "application/json");
    
            var res = await _httpClient.PostAsync(url, req);
            res.EnsureSuccessStatusCode();
    
            var json = await res.Content.ReadAsStringAsync();
            var data = JObject.Parse(json);
            var impacts = (JArray)(data["results"] ?? new JArray());
    
            Console.WriteLine($"=== Impact Indicators ({impacts.Count} indicators found) ===\n");
    
            string[,] stages = new string[,] {
                {"A1-A3 (Raw Materials & Manufacturing)", "a1a2a3"},
                {"A1", "a1"}, {"A2", "a2"}, {"A3", "a3"},
                {"A4 (Transport)", "a4"},
                {"A5 (Installation)", "a5"},
                {"B1 (Use)", "b1"},
                {"B2 (Maintenance)", "b2"},
                {"B3 (Repair)", "b3"},
                {"B4 (Replacement)", "b4"},
                {"B5 (Refurbishment)", "b5"},
                {"B (Aggregate)", "b1b2b3b4b5"},
                {"C1 (Deconstruction)", "c1"},
                {"C2 (Transport to Disposal)", "c2"},
                {"C3 (Waste Processing)", "c3"},
                {"C4 (Disposal)", "c4"},
                {"C1C2C3C4 (Aggregate)", "c1c2c3c4"},
                {"D (Beyond System Boundary)", "d"}
            };
    
            for (int i = 0; i < impacts.Count; i++)
            {
                var impact = (JObject)impacts[i];
                Console.WriteLine($"\n--- Indicator {i + 1}: {impact["indicator"]?.ToString().ToUpper()} ---");
                Console.WriteLine($"Methodology: {impact["methodology"]}");
    
                if (impact["declaredUnit"] != null)
                {
                    Console.WriteLine($"Declared Unit: {impact["declaredUnit"]["qty"]} {impact["declaredUnit"]["unit"]}");
                }
    
                Console.WriteLine("\nLifecycle Stages:");
                for (int r = 0; r < stages.GetLength(0); r++)
                {
                    var key = stages[r, 1];
                    var name = stages[r, 0];
                    var v = impact[key];
                    if (v != null && v["qty"] != null && v["unit"] != null)
                    {
                        string outLine = $"  {name}: {v["qty"]} {v["unit"]}";
                        if (v["referencePeriod"] != null)
                        {
                            var rp = v["referencePeriod"];
                            outLine += $" (over {rp["qty"]} {rp["unit"]})";
                        }
                        Console.WriteLine(outLine);
                    }
                }
            }
    
            if (data["pagination"] != null)
            {
                var p = (JObject)data["pagination"];
                Console.WriteLine($"\nPagination: offset={p["offset"]}, limit={p["limit"]}, nextUrl={p["nextUrl"]}");
            }
        }
    }
    
    Show More

    Note

    You can paginate results using optional query parameters limit and offset. For details, see the API reference linked above.

    Step 2: Understanding the Response

    The response provides comprehensive environmental impact data across different lifecycle stages following LCA (Life Cycle Assessment) methodology.

    Example Response

    {
      "results": [
        {
          "declaredUnit": { "qty": 1, "unit": "m3" },
          "indicator": "gwp",
          "methodology": "TRACI2.1",
          "a1": { "qty": 12.5, "unit": "kgCO2eq" },
          "a2": { "qty": 12.5, "unit": "kgCO2eq" },
          "a3": { "qty": 12.5, "unit": "kgCO2eq" },
          "a1a2a3": { "qty": 12.5, "unit": "kgCO2eq" },
          "a4": { "qty": 12.5, "unit": "kgCO2eq" },
          "a5": { "qty": 12.5, "unit": "kgCO2eq" },
          "b1": { "qty": 12.5, "unit": "kgCO2eq", "referencePeriod": { "qty": 50, "unit": "year" } },
          "b2": { "qty": 12.5, "unit": "kgCO2eq", "referencePeriod": { "qty": 50, "unit": "year" } },
          "b3": { "qty": 12.5, "unit": "kgCO2eq", "referencePeriod": { "qty": 50, "unit": "year" } },
          "b4": { "qty": 12.5, "unit": "kgCO2eq", "referencePeriod": { "qty": 50, "unit": "year" } },
          "b5": { "qty": 12.5, "unit": "kgCO2eq", "referencePeriod": { "qty": 50, "unit": "year" } },
          "b1b2b3b4b5": { "qty": 12.5, "unit": "kgCO2eq", "referencePeriod": { "qty": 50, "unit": "year" } },
          "c1": { "qty": 12.5, "unit": "kgCO2eq" },
          "c2": { "qty": 12.5, "unit": "kgCO2eq" },
          "c3": { "qty": 12.5, "unit": "kgCO2eq" },
          "c4": { "qty": 12.5, "unit": "kgCO2eq" },
          "c1c2c3c4": { "qty": 12.5, "unit": "kgCO2eq" },
          "d": { "qty": 12.5, "unit": "kgCO2eq" }
        }
      ],
      "pagination": {
        "offset": 0,
        "limit": 25,
        "nextUrl": "https://developer.api.autodesk.com/sustainability/v3/datasets/<DATASET_ID>/generic-estimates/details/<GENERIC_ESTIMATE_ID>/impacts:filter?offset=25&limit=25",
        "totalResults": 150
      },
      "appliedFilters": {},
      "ignoredFilters": {}
    }
    
    Show More

    Key Response Fields:

    • results: Array of impact indicators, each with lifecycle stage data
    • indicator: Type of environmental impact (gwp, adpe, ap, etc.)
    • methodology: Assessment standard used (e.g., TRACI2.1, EN 15804+A2)
    • declaredUnit: Reference unit for the measurements
    • a1a2a3: Product stage impacts (raw materials, transport, manufacturing)
    • a4 / a5: Construction stage impacts (transport, installation)
    • b1-b5 and b1b2b3b4b5: Use stage impacts (individual and aggregate; may include referencePeriod)
    • c1-c4 and c1c2c3c4: End-of-life stage impacts (individual and aggregate)
    • d: Benefits and loads beyond system boundary
    • pagination: Pagination metadata for navigating large result sets
    • appliedFilters: Map of filter keys to the requested vs. applied filter values (with optional warnings when a value was dropped)
    • appliedFilters.*.requested: The filter value the client asked for (object with op and value)
    • appliedFilters.*.applied: The filter value the connector actually applied (object with op and value)
    • appliedFilters.*.warnings: Optional human-readable notes about values that could not be applied
    • ignoredFilters: Map of unrecognised filter keys to the reason they were ignored
    • ignoredFilters.*.reason: Human-readable explanation of why the filter key was not used

    Step 3: Understanding Impact Indicators

    Common Impact Indicator Types:

    1. GWP (Global Warming Potential) - Measures carbon footprint and climate change impact - Units: kgCO2eq (kilograms of CO2 equivalent) - Variants: gwp (total), gwp_fossil, gwp_biogenic, gwp_luluc
    2. ADPE (Abiotic Depletion Potential - Elements) - Measures depletion of mineral resources - Units: kg Sb eq (antimony equivalent)
    3. ADPF (Abiotic Depletion Potential - Fossil) - Measures depletion of fossil fuel resources - Units: MJ (megajoules)
    4. AP (Acidification Potential) - Measures acid rain and soil acidification - Units: kg SO2 eq or mol H+ eq
    5. EP (Eutrophication Potential) - Measures nutrient pollution in water bodies - Variants: ep_freshwater, ep_marine, ep_terrestrial - Units: kg N eq or kg P eq
    6. ODP (Ozone Depletion Potential) - Measures stratospheric ozone layer depletion - Units: kg CFC-11 eq
    7. POCP (Photochemical Ozone Creation Potential) - Measures smog formation potential - Units: kg NMVOC eq
    8. WDP (Water Deprivation Potential) - Measures water scarcity impact - Units: m3 world eq

    Understanding Lifecycle Stages:

    Product Stage (A1-A3): - A1: Raw material extraction and processing - A2: Transport to manufacturer - A3: Manufacturing

    Construction Stage (A4-A5): - A4: Transport to construction site - A5: Installation and construction process

    Use Stage (B1-B5): - B1: Use (direct emissions during use) - B2: Maintenance - B3: Repair - B4: Replacement - B5: Refurbishment - Note: B-stages often include a reference period (e.g., impacts over 50 years)

    End-of-Life Stage (C1-C4): - C1: Deconstruction and demolition - C2: Transport to waste processing - C3: Waste processing - C4: Final disposal

    Beyond System Boundary (D): - Benefits from recycling, energy recovery, or reuse - Often shows negative values (environmental benefits)


    Step 4: Practical Applications

    Comparing Materials:

    # Compare GWP across two generic estimates
    a_gwp = 12.5  # kgCO2eq
    b_gwp = 8.3   # kgCO2eq
    
    diff = a_gwp - b_gwp
    print(f"Estimate B has {diff} kgCO2eq lower GWP")
    print(f"Percentage reduction: {(diff/a_gwp)*100:.1f}%")
    

    Analyzing Lifecycle Hotspots:

    stages = {
        'Product (A1-A3)': 12.5,
        'Construction (A4-A5)': 3.1,
        'Use (B1-B5)': 0.5,
        'End-of-Life (C1-C4)': 0.55,
        'Beyond Boundary (D)': -2.1
    }
    
    total = sum(stages.values())
    
    print("Impact Distribution:")
    for stage, value in stages.items():
        percentage = (value / total) * 100
        print(f"{stage}: {percentage:.1f}%")
    
    Show More

    Calculating Whole-Life Carbon:

    a_stages = 12.5 + 2.3 + 0.8  # A1-A3 + A4 + A5
    b_stages = 0.5               # Use stage impacts
    c_stages = 0.2 + 0.1 + 0.05  # End-of-life
    d_stage = -2.1               # Beyond boundary
    
    whole_life_carbon = a_stages + b_stages + c_stages + d_stage
    print(f"Whole-life carbon: {whole_life_carbon} kgCO2eq")
    

    Integration Best Practices:

    • Store and cache impact data to enable comparison
    • Track methodology to ensure you’re comparing like-with-like
    • Consider all stages relevant to your use case (not just A1-A3)
    • Account for reference periods when analyzing B-stage impacts
    • Check for null values as not all stages may have data available
    • Use declared units to normalize comparisons across different products

    Data Quality Considerations:

    • Not all records include all lifecycle stages
    • B-stage data often requires building-specific assumptions
    • Reference periods may vary (e.g., 25 vs. 50 years)
    • Methodology differences affect comparability
    • Always verify data completeness before making decisions

    Troubleshooting:

    If you encounter any errors while making this request, please refer to the Error Handling section of this guide for detailed information about common error codes and their solutions.