# US Building Permits Scraper - 10 Cities, One Schema (`maydit/us-building-permits-scraper`) Actor

Scrape US building permits from 10 city open-data portals into one clean schema. Contractor and applicant leads with address, valuation, and dates. Filter and export to CSV.

- **URL**: https://apify.com/maydit/us-building-permits-scraper.md
- **Developed by:** [Brandt May](https://apify.com/maydit) (community)
- **Categories:** Lead generation, Real estate
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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 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

## US Building Permits Scraper - 10 Cities in One Schema

> Pull building permits from 10 US city open-data portals into a single normalized dataset - built for construction lead generation and sales-territory monitoring.

### What it does

This **building permits scraper** aggregates permit records from 10 official US city open-data portals and normalizes them into **one clean schema**, so you never have to reconcile a different field layout for every city. It pulls high-intent construction data - permit type, status, address, valuation, dates, and (where the city publishes it) contractor and applicant names - and lets you filter by city, project value, keyword, contractor, and date range. Use it as a lightweight **US building permits API** for construction lead generation, then export straight to CSV, JSON, or Excel from the Apify dataset.

The moat is the per-city field mapping: each source portal labels its columns differently, and this actor maps all of them into the same output fields so your CRM, spreadsheet, or pipeline sees consistent **building permit data by city**.

### Who it's for

- **Construction lead-gen teams** sourcing new-project and renovation leads
- **Contractors and subcontractors** watching their service area for fresh permits
- **Building-material suppliers and distributors** timing outreach to project starts
- **Roofers, solar installers, and HVAC sales teams** chasing permit-triggered demand
- **Real-estate and proptech** teams enriching properties with permit activity
- **Market researchers and analysts** tracking construction volume by city

### What you get / Output

Every record is normalized to the same fields across all 10 cities:

| Field | Description |
|---|---|
| `permitNumber` | Official permit identifier from the source city |
| `permitType` | Type/category of permit (new build, alteration, etc.) |
| `status` | Current permit status |
| `description` | Work description / scope text |
| `address` | Street address of the permitted work |
| `city` | City the address is in |
| `state` | US state |
| `zip` | ZIP / postal code |
| `valuation` / `estimatedCost` | Declared project value or estimated cost |
| `contractorName` | Contractor on the permit (where the city publishes it) |
| `applicant` | Applicant / filer on the permit |
| `issuedDate` | Date the permit was issued |
| `filedDate` | Date the permit was filed / applied |
| `latitude` | Latitude of the site |
| `longitude` | Longitude of the site |
| `sourceCity` | Which of the 10 source portals the record came from |
| `permitUrl` | Link back to the record on the source portal |

> Note: not every city publishes every field. `contractorName`, `applicant`, and `valuation`/`estimatedCost` availability varies by source portal - the actor fills what the city exposes and leaves the rest empty rather than inventing data.

### Input / How to query

Configure a run with these filters and modes:

- **Cities** - choose one, several, or all 10 supported portals
- **Valuation min / max** - keep only projects above or below a dollar threshold
- **Keyword** - match against the permit description (e.g. `roof`, `solar`, `remodel`)
- **Contractor name** - filter to permits tied to a specific contractor
- **Date range** - restrict by filed or issued date
- **Multi-city pull** - fetch several cities in a single run; each city's raw fields are normalized into the shared schema automatically

Results land in the run's dataset, exportable as **CSV**, JSON, Excel, or via the Apify API.

### Example use cases

- **Roofing / solar / HVAC lead gen** - keyword-filter for `roof`, `solar`, `HVAC`, or `re-roof` across your target cities and pull fresh permits with addresses to build a call list.
- **Contractor competitive tracking** - filter by a competitor's `contractorName` to see where and what they're building.
- **Material supplier timing** - filter by valuation to surface large new-construction projects the moment they're filed, then reach out before the concrete order is placed.
- **Real-estate / proptech enrichment** - use `latitude`/`longitude` and `address` to join permit activity onto your property database.
- **Market research** - pull all cities over a date range to measure construction volume and mix by `permitType` and `valuation`.

### Recurring use / scheduling

Set up an **Apify Schedule** (for example, a daily or weekly cron) so the actor re-runs on its own and captures newly filed and newly issued permits without manual effort - ideal for **monitoring new building permits in a sales territory**.

For clean, no-duplicate feeds:

- Use the **date-range filter** to only pull records since your last run.
- Point runs at the **same named dataset** and dedupe downstream on `permitNumber` + `sourceCity` (unique per city).
- Wire an **integration** (webhook, Google Sheets, Slack, or your CRM) to push each new batch straight into your workflow.

### FAQ

#### How do I get building permit data for construction leads?

Run this actor against the cities you sell into, optionally filter by keyword, valuation, or date, and export the dataset to CSV or push it to your CRM. Each row includes the address, permit type, dates, and - where the city publishes it - the contractor and applicant, which is exactly the contact-and-context data lead-gen teams need.

#### Which US cities publish building permits as open data?

This actor covers 10 official portals: Chicago, San Francisco, New York City (DOB NOW), Austin, Seattle, Los Angeles, Baton Rouge, Cincinnati, Mesa, and Marin County. All are public Socrata open-data sources.

#### How can I scrape building permits from multiple cities into one format?

That is the core feature. Select multiple cities in one run and the actor maps each portal's differently-named columns into the same normalized schema, so every record shares the same fields regardless of source city.

#### How do I find new construction and renovation permits daily?

Schedule the actor to run daily and filter by filed or issued date so each run only returns recent records. Combine with a keyword like `new` or `addition` to focus on new construction and renovations.

#### Can I get building permit data with contractor and applicant names?

Where the source city publishes them, yes - the output includes `contractorName` and `applicant`. Coverage of these fields varies by city; portals that expose them are mapped through, and those that don't are left blank rather than guessed.

#### What is the best building permits API for contractors?

For contractors who want a wide, normalized feed across many cities without managing a different integration per portal, this actor works as a pay-per-result building permits API: one input schema, one output schema, 10 cities, filterable by valuation, keyword, contractor, and date.

#### How do I export building permit data to CSV or Excel?

Results go to the run's Apify dataset, which exports to CSV, Excel, JSON, or XML with one click, or via the Apify API for automated pipelines.

#### How do I monitor new building permits in my sales territory?

Pick the cities in your territory, set a schedule, filter by date range so each run is incremental, and route the output to Google Sheets, a webhook, or your CRM. Dedupe on `permitNumber` + `sourceCity` to keep the feed clean.

#### Is building permit data free and legal to scrape?

The underlying records come from official municipal open-data portals published for public use. This actor reads those public datasets; you are responsible for complying with each portal's terms and any applicable usage rules.

#### How do roofers, solar, and HVAC companies find permit leads?

They keyword-filter permit descriptions for terms like `roof`, `solar`, `PV`, or `HVAC`, restrict to their service-area cities and a recent date range, and pull the resulting addresses as a fresh lead list - then schedule it to repeat.

#### How do I filter building permits by valuation or project cost?

Use the valuation min and max inputs. Set a minimum to focus on large projects, a maximum to focus on small jobs, or both to target a specific project-size band.

#### What is a cheaper alternative to Shovels, PermitGrab, or Construction Monitor?

Instead of a fixed monthly SaaS subscription, this actor runs on Apify's pay-per-result model - you pay for the permits you actually pull across the 10 covered cities, with the same core lead fields (address, contractor where available, valuation, dates) and full control over filtering and scheduling.

### Data source & notes

- **Source:** 10 official US city Socrata open-data portals - Chicago, San Francisco, New York City (DOB NOW), Austin, Seattle, Los Angeles, Baton Rouge, Cincinnati, Mesa, and Marin County.
- **Public data:** all records originate from public municipal open-data datasets. Respect each portal's terms of use.
- **Field coverage varies by city.** `contractorName`, `applicant`, and `valuation`/`estimatedCost` are only populated where the source city publishes them; the actor never fabricates values.
- **Coverage:** the 10 listed cities only - this actor does not cover every US municipality, and permit freshness depends on how often each city updates its open-data portal.
- **Slug:** `us-building-permits-scraper` &middot; **Actor ID:** `EvCD8QyPV2uMbPG6U`

# Actor input Schema

## `cities` (type: `array`):

Which cities to scrape. Leave empty to scrape all supported cities.
## `issuedSince` (type: `string`):

Only permits issued on or after this date (YYYY-MM-DD). Use this for recurring/monitoring runs, e.g. last 7 days.
## `issuedUntil` (type: `string`):

Only permits issued on or before this date (YYYY-MM-DD).
## `permitTypeKeywords` (type: `array`):

Only keep permits whose type/description/class contains one of these keywords (case-insensitive). E.g. 'solar', 'roof', 'pool', 'demolition'. Leave empty for all.
## `minValuation` (type: `integer`):

Only keep permits with a reported job valuation at or above this amount. Applied server-side for cities that publish valuation (Chicago, San Francisco, Austin, Seattle). New York does not publish job cost.
## `onlyWithContractor` (type: `boolean`):

Keep only records that include a contractor/company name (best for lead generation). Note: San Francisco does not publish contractor names.
## `maxResultsPerCity` (type: `integer`):

Upper bound on permits returned per city per run.
## `includeRaw` (type: `boolean`):

Attach the full original source record to each result under 'raw'. Increases output size.
## `socrataAppToken` (type: `string`):

Optional Socrata app token to raise API rate limits on large runs. Free to obtain from any Socrata portal. Not required for normal use.

## Actor input object example

```json
{
  "cities": [
    "chicago",
    "san_francisco",
    "new_york",
    "austin",
    "seattle",
    "los_angeles",
    "baton_rouge",
    "cincinnati",
    "mesa",
    "marin_county"
  ],
  "issuedSince": "2026-06-01",
  "permitTypeKeywords": [],
  "onlyWithContractor": false,
  "maxResultsPerCity": 1000,
  "includeRaw": 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("maydit/us-building-permits-scraper").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("maydit/us-building-permits-scraper").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 '{}' |
apify call maydit/us-building-permits-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maydit/us-building-permits-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "US Building Permits Scraper - 10 Cities, One Schema",
        "description": "Scrape US building permits from 10 city open-data portals into one clean schema. Contractor and applicant leads with address, valuation, and dates. Filter and export to CSV.",
        "version": "1.0",
        "x-build-id": "TfbefBdtPqGAk1cbN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maydit~us-building-permits-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maydit-us-building-permits-scraper",
                "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/maydit~us-building-permits-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maydit-us-building-permits-scraper",
                "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/maydit~us-building-permits-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maydit-us-building-permits-scraper",
                "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": {
                    "cities": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Which cities to scrape. Leave empty to scrape all supported cities.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "chicago",
                                "san_francisco",
                                "new_york",
                                "austin",
                                "seattle",
                                "los_angeles",
                                "baton_rouge",
                                "cincinnati",
                                "mesa",
                                "marin_county"
                            ],
                            "enumTitles": [
                                "Chicago, IL",
                                "San Francisco, CA",
                                "New York, NY",
                                "Austin, TX",
                                "Seattle, WA",
                                "Los Angeles, CA",
                                "Baton Rouge, LA",
                                "Cincinnati, OH",
                                "Mesa, AZ",
                                "Marin County, CA"
                            ]
                        },
                        "default": [
                            "chicago",
                            "san_francisco",
                            "new_york",
                            "austin",
                            "seattle",
                            "los_angeles",
                            "baton_rouge",
                            "cincinnati",
                            "mesa",
                            "marin_county"
                        ]
                    },
                    "issuedSince": {
                        "title": "Issued since",
                        "type": "string",
                        "description": "Only permits issued on or after this date (YYYY-MM-DD). Use this for recurring/monitoring runs, e.g. last 7 days."
                    },
                    "issuedUntil": {
                        "title": "Issued until",
                        "type": "string",
                        "description": "Only permits issued on or before this date (YYYY-MM-DD)."
                    },
                    "permitTypeKeywords": {
                        "title": "Permit type keywords",
                        "type": "array",
                        "description": "Only keep permits whose type/description/class contains one of these keywords (case-insensitive). E.g. 'solar', 'roof', 'pool', 'demolition'. Leave empty for all.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "minValuation": {
                        "title": "Minimum job valuation (USD)",
                        "type": "integer",
                        "description": "Only keep permits with a reported job valuation at or above this amount. Applied server-side for cities that publish valuation (Chicago, San Francisco, Austin, Seattle). New York does not publish job cost."
                    },
                    "onlyWithContractor": {
                        "title": "Only permits with a contractor name",
                        "type": "boolean",
                        "description": "Keep only records that include a contractor/company name (best for lead generation). Note: San Francisco does not publish contractor names.",
                        "default": false
                    },
                    "maxResultsPerCity": {
                        "title": "Max results per city",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Upper bound on permits returned per city per run.",
                        "default": 1000
                    },
                    "includeRaw": {
                        "title": "Include raw source record",
                        "type": "boolean",
                        "description": "Attach the full original source record to each result under 'raw'. Increases output size.",
                        "default": false
                    },
                    "socrataAppToken": {
                        "title": "Socrata app token (optional)",
                        "type": "string",
                        "description": "Optional Socrata app token to raise API rate limits on large runs. Free to obtain from any Socrata portal. Not required for normal use."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
