# Building ESG API - Carbon, Energy, Certifications (`nabeelbaghoor/building-esg-carbon-data-api`) Actor

Building ESG and decarbonisation data: portfolios and funds, buildings with floor area, type and ownership share, energy, water and waste meters and their readings, green building certifications and ratings, and modelled carbon and energy estimates with building performance ordinances.

- **URL**: https://apify.com/nabeelbaghoor/building-esg-carbon-data-api.md
- **Developed by:** [Nabeel Hassan](https://apify.com/nabeelbaghoor) (community)
- **Categories:** Real estate, Business, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $12.00 / 1,000 building or asset record returneds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Building ESG API - Carbon, Energy and Certifications

Pull a real estate portfolio's ESG reporting data out of the platform it lives in and into your own systems.

### What it collects

- **Portfolios and funds** an account can see, which is where the identifiers everything else needs come from.
- **Buildings** with name, full address, primary property type, gross floor area in square feet, year built, ownership percentage, single tenant flag, purchase and disposal dates, and whether the asset is still active.
- **Meters** for energy, water and waste, and their readings period by period with the unit each consumption figure is measured in.
- **Certifications and ratings**: the green building certifications held across a portfolio, the certification types relevant to it, and the energy and performance ratings on individual buildings and spaces.
- **Modelled asset level data**: carbon estimates, energy estimates, certification lookups and ordinance lookups, plus the building performance ordinance catalogue behind them.
- **Securities level reports** for listed real estate, and the partner views for portfolios and monthly utility data.

### FAQ

#### What building ESG data can I export?

Portfolios and funds, buildings with floor area and property type, energy, water and waste meters with their readings, green building certifications and ratings, and modelled carbon and energy estimates per building. The building performance ordinance catalogue and per-building ordinance lookups come through the same run.

#### How do I get a portfolio ID?

Run the portfolios dataset first. It needs no identifier and returns every portfolio the account can see, each with the UUID that the buildings, meters, certifications and ratings datasets take. A fund ID works anywhere a portfolio ID does.

#### Can this actor change data in my ESG account?

No. Every route it calls is a GET. This provider's write endpoints add buildings, meters and readings to a customer's own regulatory reporting, and a data collector has no business touching those, so the actor is read only by construction rather than by configuration. A scheduled run cannot create, change or delete anything.

#### What authentication does this API use?

A key and secret pair, issued together by the provider to your organisation, exchanged at the start of the run for a bearer token that lasts twenty four hours. One exchange serves a whole run. Both halves of the pair are required, and both are stored encrypted and never written into the dataset.

#### Why do I only get one page of results?

You should not, and the reason this is worth mentioning is that this API spells its page size two different ways. The portfolio endpoints take `size` and the asset level and partner endpoints take `pageSize`, and sending the wrong one is not an error: the provider ignores it and returns its default page. The actor sends whichever spelling the dataset you chose accepts, so a run collects everything rather than looking like it did.

#### Does it drop buildings that were sold?

No. Inactive buildings are collected and flagged with an active indicator you can filter on. A portfolio total that quietly lost its disposed assets would be a different number from the one the platform reports, so the decision to exclude them is left to you.

#### Can I collect only what changed since last week?

Yes, on the portfolio datasets. The filter input passes the provider's own expression straight through, so `updatedAt=ge=2026-09-01` returns only records changed on or after that date. On datasets that do not accept a filter, the actor says so in the log rather than sending one the provider would silently ignore.

#### What does it cost?

Pay per result. Modelled estimates cost the most, buildings and meters less, readings and monthly utility rows least because they are high volume by nature, and portfolios, funds and catalogues are priced near zero so you can find your identifiers before committing to a real run. Platform usage is included.

### Example output

```json
{
  "recordType": "building",
  "requested": "buildings portfolioId=134b372e-34e7-49bf-a45a-acf452bf4fd2",
  "found": true,
  "recordId": "702e7fdf-1b3a-451e-9dfe-3b408c6fff80",
  "resourceType": "buildings",
  "portfolioId": "134b372e-34e7-49bf-a45a-acf452bf4fd2",
  "name": "Warehouse Distribution Center",
  "addressLine1": "123 Warehouse Dr",
  "addressCity": "San Diego",
  "addressState": "CA",
  "addressZip": "92120",
  "addressCountry": "United States",
  "primaryPropertyType": "Distribution Center",
  "floorAreaSqFt": 1111,
  "yearBuilt": 1969,
  "percentOwned": 100.0,
  "isSingleTenant": true,
  "isActive": true,
  "updatedAt": "2026-05-18 00:00:00"
}
```

### Keyword map

building ESG data API, carbon emissions data API, real estate decarbonisation data, energy and water meter readings API, utility data API, green building certification data, LEED BREEAM certification lookup, ENERGY STAR rating data, building performance ordinance data, CRREM pathway data, GRESB reporting data export, portfolio ESG reporting API, Scope 1 2 3 building emissions, asset level carbon estimates.

### Notes

Bring your own key. Read only by construction: every route is a GET. Rate limiting, retries, token exchange and per-product pagination are handled for you, and missing or refused credentials end the run cleanly with an explanation rather than failing it. Floor areas are square feet and readings carry their own unit, as the provider publishes them.

# Actor input Schema

## `dataset` (type: `string`):

Which dataset to collect. Start with portfolios to get the portfolio ID that most of the other datasets need. Buildings, meters and readings are the reported data; carbon and energy estimates, certification lookups and ordinance lookups are the modelled asset level data.

## `portfolioId` (type: `string`):

The portfolio or fund UUID most datasets read from. Run the portfolios dataset first to get it. A fund ID works anywhere a portfolio ID does.

## `buildingId` (type: `string`):

The building UUID, for the datasets that read one building: meter readings, building ratings, building spaces and partner utility data.

## `meterId` (type: `string`):

The meter UUID, for the meter readings dataset. Run the meters dataset on the portfolio to find it.

## `filter` (type: `string`):

The provider's own filter expression, passed through as written. For example updatedAt=ge=2022-11-01 returns only records changed since that date. Only the portfolio datasets accept it; on the others the actor says so in the log rather than sending a filter the provider would silently ignore.

## `startDate` (type: `string`):

First month to include, as YYYY-MM-DD, for the partner monthly utility dataset.

## `endDate` (type: `string`):

Last month to include, as YYYY-MM-DD, for the partner monthly utility dataset.

## `pageSize` (type: `integer`):

How many records to ask for per request. The provider caps this at 200, and the actor clamps to that. This API spells the page size two different ways across its products, and the actor sends whichever spelling the chosen dataset accepts, because the wrong one is ignored rather than rejected and would quietly return only a default page.

## `maxResults` (type: `integer`):

Stop after this many rows. Counts every row the run collects.

## `requestsPerMinute` (type: `integer`):

How fast to call the provider. The default of 120 is two a second. The provider publishes throughput guidance per dataset, so lower this if you are reading estimates in bulk.

## `apiKey` (type: `string`):

Your own account key, issued by the provider to your organisation. Exchanged with the secret below for a token that lasts a day. Stored encrypted and never written into the dataset. Can also be supplied as the DATA\_API\_KEY environment secret.

## `apiSecret` (type: `string`):

The secret issued together with the key. Both are needed: the pair is exchanged for a bearer token at the start of the run. Stored encrypted and never written into the dataset. Can also be supplied as the DATA\_API\_SECRET environment secret.

## `baseUrl` (type: `string`):

Overrides the host the API is called on. Leave empty unless the provider has given you a different one.

## Actor input object example

```json
{
  "dataset": "portfolios",
  "pageSize": 100,
  "maxResults": 100,
  "requestsPerMinute": 120
}
```

# Actor output Schema

## `records` (type: `string`):

One row per record, alongside the dataset and identifiers that produced it.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("nabeelbaghoor/building-esg-carbon-data-api").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("nabeelbaghoor/building-esg-carbon-data-api").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call nabeelbaghoor/building-esg-carbon-data-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nabeelbaghoor/building-esg-carbon-data-api"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/a0aFd1Izk47eWJl4J/builds/jESHsH3kwXTrwuZsf/openapi.json