# Building Permit Leads - Solar, Roofing, HVAC & Windows (`dabomb1177/permit-leads-solar-roofing-hvac`) Actor

Trade-filtered building permit leads for contractors and sales teams. Pulls newly-issued permits from Chicago, LA, San Francisco, Austin & Seattle, classifies each by trade (solar, roofing, HVAC, windows), and returns one clean schema per metro.

- **URL**: https://apify.com/dabomb1177/permit-leads-solar-roofing-hvac.md
- **Developed by:** [Mazen Khalil](https://apify.com/dabomb1177) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Building Permit Leads Scraper — Solar, Roofing, HVAC & Windows

Get **fresh, trade-filtered building permit leads** from five major US metros in one run.
This actor pulls newly-issued building permits from official city open-data portals
(**Chicago, Los Angeles, San Francisco, Austin, and Seattle**), automatically classifies
each permit by trade — **solar, roofing, HVAC, windows, siding, EV charger** — and returns
one clean, consistent spreadsheet-ready feed. No more downloading five different city CSVs
and filtering permit descriptions by hand.

Built for **home-improvement contractors, solar installers, roofing companies, HVAC sales
teams, building-material suppliers, and market analysts** who want a recurring stream of
permit-based leads instead of a raw, unfiltered data dump.

### Why this permit scraper is different

Most building-permit actors hand you every permit a city issued and leave you to guess which
rows are solar jobs, which are re-roofs, and which are HVAC replacements. This one does the
sorting for you:

- **Trade classification built in.** A transparent keyword table tags each permit as solar,
  roofing, HVAC, windows, siding, or EV-charger work. Filter to just the trades you sell.
- **Same schema across every city.** Chicago, LA, San Francisco, Austin and Seattle each
  publish permits with different column names — this actor normalizes them into one flat
  schema so `issueDate`, `address`, `valuationUsd` and `primaryTrade` mean the same thing
  everywhere.
- **Fresh by default.** Returns the last 30 days of issued permits out of the box; set a
  `sinceDate` to your last run and get only the new ones.
- **Public data only.** Every source is an official municipal Socrata open-data API — no
  logins, no CAPTCHAs, no scraping behind a paywall.

### Input

Runs with **zero configuration** — the defaults return the last 30 days of solar, roofing,
HVAC and window permits across all five metros.

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `metros` | array | all 5 | Cities to pull from: `chicago`, `los_angeles`, `san_francisco`, `austin`, `seattle`. |
| `trades` | array | `solar, roofing, hvac, windows` | Trades to keep. Also supports `siding`, `ev_charger`. Clear it to get every permit. |
| `dateBasis` | string | `issued` | Filter/sort by `issued` or `applied` date. |
| `lookbackDays` | integer | `30` | How many days back to pull when no `sinceDate` is set. |
| `sinceDate` | string | — | `YYYY-MM-DD`; overrides lookback. Set to your last run for deltas. |
| `untilDate` | string | — | `YYYY-MM-DD`; upper bound. |
| `minValuationUsd` | integer | `0` | Drop permits below this declared job value (0 = off). |
| `maxItems` | integer | `500` | Total leads returned, newest first. |
| `maxItemsPerMetro` | integer | `200` | Per-city cap so one big city can't crowd out the rest. |
| `socrataAppToken` | string | — | Optional free Socrata token for higher rate limits. |

### Sample output

Each dataset item is one permit:

```json
{
  "metro": "chicago",
  "metroLabel": "Chicago, IL",
  "primaryTrade": "solar",
  "trades": ["solar", "roofing"],
  "permitId": "chicago:B200478850",
  "permitNumber": "B200478850",
  "permitType": "PERMIT - EXPRESS PERMIT PROGRAM",
  "description": "INSTALL SOLAR PANELS ON ROOF OF PRINCIPAL BUILDING. ARRAY OUTPUT: 9.43 KW. INCLUDES 15 KWH ENERGY STORAGE SYSTEM.",
  "status": null,
  "issueDate": "2026-07-24",
  "valuationUsd": null,
  "contractorName": "SUNRUN INSTALLATION SERVICES",
  "address": "1234 N Example Ave",
  "city": "Chicago",
  "stateCode": "IL",
  "zip": null,
  "latitude": 41.8226,
  "longitude": -87.6960,
  "url": "https://data.cityofchicago.org/Buildings/Building-Permits/ydr8-5enu",
  "fetchedAt": "2026-07-26T13:00:00.000Z"
}
````

### Use cases

#### Solar & roofing lead generation

Pull every solar and re-roof permit issued in your service area this week, then work the list
by address and ZIP. Because solar permits are frequently roof-adjacent, each item lists **all**
detected trades so a roofer can spot solar cross-sell opportunities and vice-versa.

#### HVAC replacement outreach

Filter to `hvac` and a `minValuationUsd` threshold to focus on larger mechanical jobs, then
route by city and neighborhood to your reps.

#### Supplier & market intelligence

Track permit volume by trade and metro over time to size a market, plan inventory, or scout a
new territory before opening a branch.

### FAQ

#### Where does the data come from?

Official municipal open-data portals running on the Socrata platform: Chicago
(`data.cityofchicago.org`), Los Angeles (`data.lacity.org`), San Francisco (`data.sfgov.org`),
Austin (`data.austintexas.gov`) and Seattle (`data.seattle.gov`). All are public government
datasets published for civic and commercial reuse.

#### Is scraping building permits legal?

Yes. These are public records that each city publishes deliberately through a documented open-data
API. This actor only reads public endpoints — no logins, no terms-of-service circumvention, and no
personal data beyond what the city already publishes on the permit.

#### How fresh is the data?

As fresh as each city publishes. Portals typically refresh daily to a few times per week. Sort is
newest-first by issued date. Run the actor on an [Apify schedule](https://docs.apify.com/platform/schedules)
and pass `sinceDate` to collect only new permits each run.

#### How do I get owner or contact details?

Owner/contact enrichment is intentionally out of scope to keep the data clean and the source
strictly public. Each permit includes the property address, coordinates, and (where the city
publishes it) the contractor of record.

#### Can you add my city?

More Socrata metros can be added on request — open an issue on the actor. Denver, NYC, Seattle-area
suburbs and other portals are candidates.

### Related actors & docs

- [Apify Store — Lead Generation actors](https://apify.com/store/categories/lead-generation)
- [Apify scheduling docs](https://docs.apify.com/platform/schedules) — automate recurring pulls
- [Apify API & client docs](https://docs.apify.com/api/v2) — run this actor from your own code

### Changelog

#### 0.1

- Initial release: Chicago, LA, San Francisco, Austin & Seattle; solar / roofing / HVAC /
  windows / siding / EV-charger classification; normalized schema; date-window and valuation
  filters; per-metro caps.

# Actor input Schema

## `metros` (type: `array`):

Which city open-data portals to pull permits from. All are public Socrata datasets.

## `trades` (type: `array`):

Only return permits classified into these trades. Clear the list to return every permit (each still tagged with its detected trade, or 'other').

## `dateBasis` (type: `string`):

Filter and sort by the date the permit was ISSUED (work about to start) or APPLIED (earlier signal).

## `lookbackDays` (type: `integer`):

If no 'Since date' is set, return permits from this many days back. 30 gives you the last month of fresh leads.

## `sinceDate` (type: `string`):

Only permits on or after this date (YYYY-MM-DD). Set this to your last run date to get just the new permits.

## `untilDate` (type: `string`):

Only permits on or before this date (YYYY-MM-DD). Leave empty for 'up to today'.

## `minValuationUsd` (type: `integer`):

Skip permits whose declared job value is below this amount. 0 disables the filter. Permits with no stated value are always kept.

## `maxItems` (type: `integer`):

Maximum number of leads to return across all metros, newest first.

## `maxItemsPerMetro` (type: `integer`):

Cap per city so one large city doesn't crowd out the others.

## `maxScanPerMetro` (type: `integer`):

Safety cap on how many recent permits are scanned per city before trade filtering. Raise for rare trades over long windows.

## `socrataAppToken` (type: `string`):

Optional free Socrata app token for higher rate limits (https://data.cityofchicago.org/profile/edit/developer\_settings). Not required for typical runs.

## `includeRawRecord` (type: `boolean`):

Attach each city's original unmodified permit row under a 'raw' field.

## Actor input object example

```json
{
  "metros": [
    "chicago",
    "los_angeles",
    "san_francisco",
    "austin",
    "seattle"
  ],
  "trades": [
    "solar",
    "roofing",
    "hvac",
    "windows"
  ],
  "dateBasis": "issued",
  "lookbackDays": 30,
  "minValuationUsd": 0,
  "maxItems": 500,
  "maxItemsPerMetro": 200,
  "maxScanPerMetro": 5000,
  "includeRawRecord": false
}
```

# 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 = {
    "metros": [
        "chicago",
        "los_angeles",
        "san_francisco",
        "austin",
        "seattle"
    ],
    "trades": [
        "solar",
        "roofing",
        "hvac",
        "windows"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dabomb1177/permit-leads-solar-roofing-hvac").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 = {
    "metros": [
        "chicago",
        "los_angeles",
        "san_francisco",
        "austin",
        "seattle",
    ],
    "trades": [
        "solar",
        "roofing",
        "hvac",
        "windows",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("dabomb1177/permit-leads-solar-roofing-hvac").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 '{
  "metros": [
    "chicago",
    "los_angeles",
    "san_francisco",
    "austin",
    "seattle"
  ],
  "trades": [
    "solar",
    "roofing",
    "hvac",
    "windows"
  ]
}' |
apify call dabomb1177/permit-leads-solar-roofing-hvac --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=dabomb1177/permit-leads-solar-roofing-hvac",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Building Permit Leads - Solar, Roofing, HVAC & Windows",
        "description": "Trade-filtered building permit leads for contractors and sales teams. Pulls newly-issued permits from Chicago, LA, San Francisco, Austin & Seattle, classifies each by trade (solar, roofing, HVAC, windows), and returns one clean schema per metro.",
        "version": "0.1",
        "x-build-id": "R4d6KaumhH4Q5bCPv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/dabomb1177~permit-leads-solar-roofing-hvac/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-dabomb1177-permit-leads-solar-roofing-hvac",
                "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/dabomb1177~permit-leads-solar-roofing-hvac/runs": {
            "post": {
                "operationId": "runs-sync-dabomb1177-permit-leads-solar-roofing-hvac",
                "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/dabomb1177~permit-leads-solar-roofing-hvac/run-sync": {
            "post": {
                "operationId": "run-sync-dabomb1177-permit-leads-solar-roofing-hvac",
                "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",
                "properties": {
                    "metros": {
                        "title": "Metros (cities)",
                        "type": "array",
                        "description": "Which city open-data portals to pull permits from. All are public Socrata datasets.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "chicago",
                                "los_angeles",
                                "san_francisco",
                                "austin",
                                "seattle"
                            ],
                            "enumTitles": [
                                "Chicago, IL",
                                "Los Angeles, CA",
                                "San Francisco, CA",
                                "Austin, TX",
                                "Seattle, WA"
                            ]
                        },
                        "default": [
                            "chicago",
                            "los_angeles",
                            "san_francisco",
                            "austin",
                            "seattle"
                        ]
                    },
                    "trades": {
                        "title": "Trades to include",
                        "type": "array",
                        "description": "Only return permits classified into these trades. Clear the list to return every permit (each still tagged with its detected trade, or 'other').",
                        "items": {
                            "type": "string",
                            "enum": [
                                "solar",
                                "roofing",
                                "hvac",
                                "windows",
                                "siding",
                                "ev_charger"
                            ],
                            "enumTitles": [
                                "Solar / Photovoltaic",
                                "Roofing / Re-roof",
                                "HVAC / Mechanical",
                                "Windows / Doors",
                                "Siding / Exterior",
                                "EV Charger"
                            ]
                        },
                        "default": [
                            "solar",
                            "roofing",
                            "hvac",
                            "windows"
                        ]
                    },
                    "dateBasis": {
                        "title": "Date basis",
                        "enum": [
                            "issued",
                            "applied"
                        ],
                        "type": "string",
                        "description": "Filter and sort by the date the permit was ISSUED (work about to start) or APPLIED (earlier signal).",
                        "default": "issued"
                    },
                    "lookbackDays": {
                        "title": "Lookback days",
                        "minimum": 1,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "If no 'Since date' is set, return permits from this many days back. 30 gives you the last month of fresh leads.",
                        "default": 30
                    },
                    "sinceDate": {
                        "title": "Since date (overrides lookback)",
                        "type": "string",
                        "description": "Only permits on or after this date (YYYY-MM-DD). Set this to your last run date to get just the new permits."
                    },
                    "untilDate": {
                        "title": "Until date",
                        "type": "string",
                        "description": "Only permits on or before this date (YYYY-MM-DD). Leave empty for 'up to today'."
                    },
                    "minValuationUsd": {
                        "title": "Minimum job valuation (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip permits whose declared job value is below this amount. 0 disables the filter. Permits with no stated value are always kept.",
                        "default": 0
                    },
                    "maxItems": {
                        "title": "Max results (total)",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of leads to return across all metros, newest first.",
                        "default": 500
                    },
                    "maxItemsPerMetro": {
                        "title": "Max results per metro",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Cap per city so one large city doesn't crowd out the others.",
                        "default": 200
                    },
                    "maxScanPerMetro": {
                        "title": "Max permits scanned per metro",
                        "minimum": 100,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Safety cap on how many recent permits are scanned per city before trade filtering. Raise for rare trades over long windows.",
                        "default": 5000
                    },
                    "socrataAppToken": {
                        "title": "Socrata app token (optional)",
                        "type": "string",
                        "description": "Optional free Socrata app token for higher rate limits (https://data.cityofchicago.org/profile/edit/developer_settings). Not required for typical runs."
                    },
                    "includeRawRecord": {
                        "title": "Include raw permit record",
                        "type": "boolean",
                        "description": "Attach each city's original unmodified permit row under a 'raw' field.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```