# DPE F/G Leads 🇫🇷 Passoires Thermiques, SCI Owners (SIREN) (`tagadanar/french-dpe-leads`) Actor

Transformez les passoires thermiques en leads B2B : chaque DPE F/G d'une commune, relié au propriétaire (SCI, SARL) via la DGFiP, enrichi SIRENE avec les dirigeants. Seul actor du store à croiser DPE et propriétaire. Mode veille avec digests Slack.

- **URL**: https://apify.com/tagadanar/french-dpe-leads.md
- **Developed by:** [Tagada Data](https://apify.com/tagadanar) (community)
- **Categories:** Lead generation, Real estate, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.40 / 1,000 dpe records

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## French DPE F/G Leads: Passoires Thermiques Owned by Companies (SCI, SARL)

Turn France's energy-sieve properties into a renovation lead list. Give it a commune and it returns every DPE class F or G diagnostic there, then matches each property to the company that owns its parcel (SCI, SARL, SAS...) using the state's own open data, and enriches that company with its SIRENE record and named dirigeants. The output is a lead you can act on: a specific poorly-rated building, the legal entity that holds it, and the person who runs that entity.

Class G properties are banned from rental since 2025 and class F follows on 1 January 2028 (loi Climat et Résilience). Their owners have to renovate, sell, or lose rental income. Lead sellers retail exactly this data at 4.90 to 9.90 euros per lead (RenovIndex), and marketplace renovation leads run 60 to 100 euros each (Effy Pro). This actor is the wholesale layer: same public sources, a few cents per lead, by the commune.

No other actor on Apify does the owner matching. The closest one sells raw ADEME diagnostic rows with no owner, no syndic and no dedup; everything else returning a "DPE" field is a listing scraper, which by definition only sees property already on the market. This actor surfaces the off-market stock and tells you who holds it.

### What you get per diagnostic

| Field | Description |
| --- | --- |
| `dpeClass`, `gesClass` | Energy and emissions class (F/G are the rental-ban targets) |
| `buildingType`, `livingAreaM2`, `constructionPeriod` | House or apartment, size, build era |
| `mainHeatingEnergy`, `energyKwhM2Year`, `gesKgCo2M2Year` | Why it's rated F/G |
| `establishedDate`, `validUntil` | Diagnostic date and validity |
| `address`, `postalCode`, `city`, `latitude`, `longitude` | Where it is (BAN-geocoded) |
| `parcelleId` | Cadastre parcel the dwelling sits on |
| `leadType` | `company-owner`, `syndic`, or `none` |
| `owner` | Owning company: SIREN, name, legal form, confidence, data vintage |
| `syndic` | Property manager of the copropriété when that's what the register shows |
| `company` | SIRENE enrichment of the owner: active status, NAF, headquarters, `dirigeants[]` with names and roles |

### Where the owner match comes from, stated honestly

The owner layer joins three official open datasets: the ADEME DPE register (the diagnostic and its geolocation), the Etalab cadastre (which parcel that point sits on), and the DGFiP register of real estate held by legal entities (who owns the parcel, with SIREN).

- Only **company-owned** property is matched. Private individuals never appear: the DGFiP source itself only covers personnes morales, which is what keeps this GDPR-clean. Dirigeant names come from the public company register, in their professional capacity.
- For a **house**, the parcel owner owns the dwelling: `confidence: "high"`.
- For an **apartment**, the company owns at least part of the parcel the building sits on, not provably that exact flat: `confidence: "parcel-level"`. Treat those as building-level leads.
- The ownership register is an **annual snapshot** (current vintage stated in every record). A parcel sold since then may have a new owner.
- When the register shows a **syndic de copropriété** instead of an owner, the record says so (`leadType: "syndic"`). A syndic managing an F/G building is a real lead too if you sell to copropriétés.
- Roughly 80% of F/G diagnostics are geocoded precisely enough to match a parcel; the rest come back with `leadType: "none"` and full DPE data.

### How it compares

| Alternative | What you get | Price | The catch |
| --- | --- | --- | --- |
| **This actor** | DPE F/G + owning company + SIREN + dirigeants, via API/MCP | $0.002/record, $0.04/owner lead | Companies only, by design |
| Raw ADEME scrapers on Apify | Diagnostic rows | ~$2 per 1,000 | No owner, no syndic, no dedup: rows, not leads |
| RenovIndex | DPE + owner leads, web UI | €4.90 to €9.90 per lead | RGE vetting gate, reserved territories, no API |
| Effy Pro, Hellio | Inbound renovation leads | €60 to €100 per lead | Declared-intent leads, priced accordingly |
| CarteDPE.fr, ONB+ | DPE maps and address exports | Free to €49/month | Stops at the address; no idea who owns it |
| DIY on the open data | The same three datasets | Free | The cadastre and DGFiP joins are days of work; this is one call |

### The 2026 DPE reform, and why it works in your favor

On 1 January 2026 the primary-energy coefficient for electricity dropped from 2.3 to 1.9 and roughly 850,000 dwellings left class F/G overnight, without any work done. Two consequences for prospecting:

- Any F/G file computed before 2026 is stale by hundreds of thousands of addresses. This actor reads the live ADEME register, so you only ever get post-reform classes.
- The properties still rated F/G today are disproportionately fossil-heated: exactly the heating-swap and insulation jobs renovation pros want, with the 2028 F rental ban as the built-in deadline.

### Input

```json
{
    "communes": ["Rennes", "35051"],
    "classes": ["F", "G"],
    "typeBatiment": "any",
    "ownerFilter": "company-owned",
    "maxResults": 500
}
````

`communes` takes INSEE codes or plain names, up to 20 per run. `ownerFilter` controls what you receive (and pay for): everything, company-owned only, or company-owned plus syndic-managed.

Monitor mode is a standing veille DPE: schedule it, point it at Slack, and every run reports only never-seen diagnostics. Works for any class selection, so real-estate agents can watch all new DPE in their sector (a fresh diagnostic often precedes a sale) while renovation pros stick to F/G:

```json
{
    "communes": ["Rennes"],
    "classes": ["F", "G"],
    "sinceDays": 30,
    "ownerFilter": "company-or-syndic",
    "monitorMode": true,
    "webhookUrl": "https://hooks.slack.com/services/XXX/YYY/ZZZ"
}
```

Every scheduled run then returns only diagnostics it has never reported before, so you are never charged twice for the same lead.

### Pricing

Pay per event, no subscription. Platform usage (compute) is billed to your run at Apify cost.

| Event | Price | When |
|---|---|---|
| DPE record | $0.002 | Per diagnostic returned |
| Company-owner lead | **$0.04** | On top, when the record carries a matched owning company with its SIRENE enrichment |
| Syndic lead | $0.01 | On top, when the record carries the copropriété's syndic instead |
| Digest sent | $0.03 | Monitor mode only, per webhook/Slack digest actually posted |

A commune sweep returning 400 diagnostics of which 34 are company-owned costs about $2.20. The same 34 leads cost 170 to 340 euros at RenovIndex retail prices, which is the arbitrage this actor exists for.

### Who uses it

- **Renovation lead resellers**: wholesale F/G + owner data in, retail leads out, per reserved territory.
- **RGE artisan networks and energy-renovation SaaS**: feed "passoires owned by companies in my clients' zones" into a CRM.
- **Real-estate investors**: SCI-owned F/G stock is exactly the discount-and-renovate pipeline; the register says who to call.
- **Real-estate agents (veille DPE)**: monitor all new diagnostics in a sector, not just F/G; a fresh DPE is one of the earliest sale signals there is.
- **Proptech and analysts**: structured F/G + ownership rows by commune, via API or MCP for AI agents.

### FAQ

**Where does the data come from?** Three official open sources: ADEME's DPE register (data.ademe.fr, refreshed weekly, 15M+ diagnostics since mid-2021), the Etalab cadastre parcel geometries, and the DGFiP register of parcels held by legal entities. Company enrichment comes from recherche-entreprises.api.gouv.fr (SIRENE + RNE). No scraping, no keys.

**Is this legal under GDPR?** The lead layer is deliberately restricted to companies. Property held by private individuals is not in the source data at all, so you are prospecting personnes morales, not people, and skip the Article 14 notification problem that individual-owner files carry. Dirigeant names are open public-register data about people acting in a professional capacity.

**Why did some diagnostics come back with no owner?** Either the parcel belongs to a private individual (most of the housing stock, by design not matched), the diagnostic isn't geocoded precisely enough, or the register lists no legal entity there. You only pay the lead price when a match is delivered.

**Can I run a whole department?** Run its main communes (up to 20 per run) and split the rest across runs or a schedule. Commune-level runs keep the owner matching fast and the costs predictable.

**How fresh are the leads?** DPE data refreshes weekly and monitor mode picks up new diagnostics as they appear. The ownership register is the state's annual vintage, labeled in every record.

**Does it work with AI agents?** Yes, like every Apify actor it is exposed via REST API and **MCP**, so an agent can ask for "company-owned G-class buildings in Bordeaux" as a tool call.

### Part of the French data suite

- [French Company Email Finder](https://apify.com/tagadanar/french-company-contacts): turn the SIREN this actor gives you into a scored dirigeant email.
- [French Company KYC](https://apify.com/tagadanar/french-company-kyc): due-diligence dossier on any SIREN, with BODACC insolvency flags.
- [French Real Estate DVF](https://apify.com/tagadanar/french-real-estate-dvf): sold-price history for the same communes.

***

### Something missing?

If you need an extra field, another source, or a different output, open an issue on this Actor and describe it. I read every request and small additions usually ship within days. More French real estate Actors (pige, DVF, deal score, DPE leads) are on [my profile](https://apify.com/tagadanar).

*Keywords: passoire thermique, passoires thermiques propriétaires, fichier passoires thermiques, DPE F G leads, veille DPE, prospection DPE, nouveau DPE 2026, DPE scraper, ADEME DPE API, leads rénovation énergétique, propriétaire SCI, interdiction location DPE G 2025 F 2028, cadastre personnes morales, French energy renovation leads, SIREN enrichment, loi Climat.*

# Actor input Schema

## `communes` (type: `array`):

Communes to scan: 5-character INSEE codes ("35238") or names ("Rennes"). Up to 20 per run.

## `classes` (type: `array`):

Energy classes to match. F and G are the rental-ban "passoires thermiques".

## `typeBatiment` (type: `string`):

Houses give the highest owner-match confidence (the parcel owner owns the dwelling).

## `sinceDays` (type: `integer`):

Only diagnostics established in the last N days. 0 = no date filter.

## `ownerFilter` (type: `string`):

Which records to output. Owner matching always runs; this only filters what you receive and pay for.

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

Hard cap on DPE diagnostics fetched per run (before the owner filter).

## `monitorMode` (type: `boolean`):

Remember diagnostics from previous runs and return only new ones. Schedule the actor to get a feed of fresh F/G leads.

## `webhookUrl` (type: `string`):

Monitor mode only: POST a digest of new leads to this URL (Slack incoming webhooks work as-is).

## Actor input object example

```json
{
  "communes": [
    "Rennes"
  ],
  "classes": [
    "F",
    "G"
  ],
  "typeBatiment": "any",
  "sinceDays": 365,
  "ownerFilter": "all",
  "maxResults": 25,
  "monitorMode": false
}
```

# Actor output Schema

## `leads` (type: `string`):

One item per DPE diagnostic in the default dataset, with the owning company or syndic when matched.

# 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 = {
    "communes": [
        "Rennes"
    ],
    "classes": [
        "F",
        "G"
    ],
    "sinceDays": 365,
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("tagadanar/french-dpe-leads").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 = {
    "communes": ["Rennes"],
    "classes": [
        "F",
        "G",
    ],
    "sinceDays": 365,
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("tagadanar/french-dpe-leads").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "communes": [
    "Rennes"
  ],
  "classes": [
    "F",
    "G"
  ],
  "sinceDays": 365,
  "maxResults": 25
}' |
apify call tagadanar/french-dpe-leads --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=tagadanar/french-dpe-leads",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DPE F/G Leads 🇫🇷 Passoires Thermiques, SCI Owners (SIREN)",
        "description": "Transformez les passoires thermiques en leads B2B : chaque DPE F/G d'une commune, relié au propriétaire (SCI, SARL) via la DGFiP, enrichi SIRENE avec les dirigeants. Seul actor du store à croiser DPE et propriétaire. Mode veille avec digests Slack.",
        "version": "0.1",
        "x-build-id": "XLa1WGLXKpQK1CQMf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/tagadanar~french-dpe-leads/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-tagadanar-french-dpe-leads",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/tagadanar~french-dpe-leads/runs": {
            "post": {
                "operationId": "runs-sync-tagadanar-french-dpe-leads",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/tagadanar~french-dpe-leads/run-sync": {
            "post": {
                "operationId": "run-sync-tagadanar-french-dpe-leads",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "communes"
                ],
                "properties": {
                    "communes": {
                        "title": "Communes",
                        "type": "array",
                        "description": "Communes to scan: 5-character INSEE codes (\"35238\") or names (\"Rennes\"). Up to 20 per run.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "classes": {
                        "title": "DPE classes",
                        "type": "array",
                        "description": "Energy classes to match. F and G are the rental-ban \"passoires thermiques\".",
                        "items": {
                            "type": "string",
                            "enum": [
                                "A",
                                "B",
                                "C",
                                "D",
                                "E",
                                "F",
                                "G"
                            ]
                        },
                        "default": [
                            "F",
                            "G"
                        ]
                    },
                    "typeBatiment": {
                        "title": "Building type",
                        "enum": [
                            "any",
                            "maison",
                            "appartement"
                        ],
                        "type": "string",
                        "description": "Houses give the highest owner-match confidence (the parcel owner owns the dwelling).",
                        "default": "any"
                    },
                    "sinceDays": {
                        "title": "Established within (days)",
                        "minimum": 0,
                        "maximum": 1825,
                        "type": "integer",
                        "description": "Only diagnostics established in the last N days. 0 = no date filter.",
                        "default": 0
                    },
                    "ownerFilter": {
                        "title": "Keep",
                        "enum": [
                            "all",
                            "company-owned",
                            "company-or-syndic"
                        ],
                        "type": "string",
                        "description": "Which records to output. Owner matching always runs; this only filters what you receive and pay for.",
                        "default": "all"
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Hard cap on DPE diagnostics fetched per run (before the owner filter).",
                        "default": 500
                    },
                    "monitorMode": {
                        "title": "Monitor mode (only new diagnostics)",
                        "type": "boolean",
                        "description": "Remember diagnostics from previous runs and return only new ones. Schedule the actor to get a feed of fresh F/G leads.",
                        "default": false
                    },
                    "webhookUrl": {
                        "title": "Webhook / Slack URL",
                        "type": "string",
                        "description": "Monitor mode only: POST a digest of new leads to this URL (Slack incoming webhooks work as-is)."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
