# Nextdoor Business Scraper (`asvuep/nextdoor-business-scraper`) Actor

Scrape public Nextdoor business pages: Nextdoor's AI-written summary of what neighbors say, plus name, categories, and phone. No login required.

- **URL**: https://apify.com/asvuep/nextdoor-business-scraper.md
- **Developed by:** [Avery](https://apify.com/asvuep) (community)
- **Categories:** Agents, Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.00 / 1,000 business scrapeds

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/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

## Nextdoor Business Scraper

**Extract public business data from [Nextdoor](https://nextdoor.com) at scale, with no login and no cookies.** Point this scraper at Nextdoor business pages or business slugs and get back clean, structured records: **business name, categories, phone number, and Nextdoor's AI-written summary of what neighbors say about the business**. Try it with the prefilled example, then paste in your own list of business pages.

That recommendation summary is the part you cannot get anywhere else: a few hundred words, written by Nextdoor, describing what neighbors actually ask this business for.

Built for lead generation, local-market research, and competitive analysis on the neighborhood-commerce data that only Nextdoor has.

### Why use Nextdoor Business Scraper?

Nextdoor is where neighbors ask for and recommend local service providers, so its business pages are a uniquely clean source of small-business data. This Actor turns those public pages into a spreadsheet or API feed:

- **No Nextdoor account, no cookies, no session tokens.** It reads public pages over plain HTTP, so there is nothing to log in, nothing to keep fresh, and nothing to break when a login expires. Point it at a URL and go.
- **Built to keep working.** Pure HTTP with automatic retries on Nextdoor's rate-limited pages, and a daily health check against live pages so drift gets caught fast rather than silently returning junk.
- **Lead lists for agencies and B2B sellers** targeting home services, contractors, and local trades, complete with a public phone number and category.
- **Local SEO and reputation research** across a category or a set of competitors, using the summary as a read on what each business is actually known for.
- **Market mapping** of which businesses have a presence in a category and how neighbors describe them.
- **CRM enrichment** by attaching phone and categories to businesses you already track.

Running on the Apify platform, you get scheduled runs, an API and integrations (Make, Zapier, Google Sheets, and more), automatic proxy rotation, and monitoring, none of which you get from a one-off script.

### How to use Nextdoor Business Scraper

1. Open the **Input** tab.
2. Add the Nextdoor business pages you want to scrape, either as full URLs under **Business page URLs** (for example `https://nextdoor.com/pages/all-home-services/`) or as bare slugs under **Business slugs** (for example `all-home-services`).
3. Optionally set **Max businesses to scrape** to cap the run.
4. Leave **Proxy configuration** on Residential (recommended) and click **Start**.
5. When the run finishes, open the **Output** tab and export as JSON, CSV, Excel, or HTML, or pull it from the API.

### Input

| Field | Description |
| --- | --- |
| **Business page URLs** (`startUrls`) | Nextdoor `/pages/<slug>/` URLs to scrape. |
| **Business slugs** (`businessSlugs`) | Business slugs (the part after `/pages/`); each is expanded to a full URL. |
| **Max businesses to scrape** (`maxItems`) | Hard cap on businesses scraped. `0` means no cap. |
| **Max concurrency** (`maxConcurrency`) | Parallel requests. Lower is gentler; `5` is a safe default. |
| **Proxy configuration** (`proxyConfiguration`) | Residential proxies are recommended for reliable results. |

You can also paste a category directory URL such as `https://nextdoor.com/directories/plumber/`. Note that Nextdoor renders most category listings with client-side JavaScript that a fast HTTP scraper cannot read, so directory crawling is best-effort and often returns nothing; feeding business page URLs or slugs directly is the reliable path.

### Output

Each business becomes one dataset item. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

```json
{
  "url": "https://nextdoor.com/pages/example-home-services/",
  "slug": "example-home-services",
  "businessId": "10000000",
  "name": "Example Home Services",
  "phone": "+15550100",
  "email": null,
  "website": null,
  "categories": ["Handyman", "General contractor"],
  "recommendationsSummary": "Residents frequently look to this business when they need reliable handyman and general contractor support. Neighbors seek help with practical projects such as installing a pantry door, as well as exterior work like metal wrapping for windows. Requests emphasize finding someone affordable…",
  "connectionsCount": 0,
  "address": null,
  "avatarUrl": "https://us1-photo.nextdoor.com/pages_avatar_photos/…jpg",
  "ownerId": "20000000",
  "ownerContactable": false,
  "topicIds": ["17748", "17758"],
  "dataQuality": "standard",
  "scrapedAt": "2026-07-20T04:04:58.709Z"
}
````

#### Data fields

| Field | Description |
| --- | --- |
| `recommendationsSummary` | **The headline field.** Nextdoor's AI-written summary of neighbor recommendations (prose, not individual reviews). Typically a few hundred words. `null` for businesses that have no recommendations yet. |
| `name` | Business name. |
| `phone` | Public phone number, when listed. Usually E.164, occasionally as the business typed it. |
| `categories` | Business categories / topics. |
| `slug`, `businessId` | Nextdoor page slug and numeric business id. Use `businessId` to deduplicate. |
| `avatarUrl` | Business logo / avatar image URL. |
| `ownerId`, `ownerContactable` | Page owner's id and whether they are marked contactable. |
| `email`, `website` | Contact email and website. Nextdoor renders these client-side, so a fast HTTP scraper usually cannot read them and they are typically `null`. Present only on the occasional page that exposes them server-side. |
| `address`, `latitude`, `longitude`, `hours` | Populated only for businesses that publish them (often null for service-area businesses). |
| `connectionsCount` | Neighbor connection count as Nextdoor reports it publicly. **In practice this is `0` on most public business pages**, so treat it as a minor signal rather than a reason to run this Actor. |
| `dataQuality` | `standard` (the normal result: name, phone, categories, recommendation summary), or `partial` (a reduced page returned under heavy load; core fields only, never billed). |

### How much does it cost to scrape Nextdoor?

This Actor uses **pay per event** pricing:

| Event | When it fires | Price |
| --- | --- | --- |
| Business scraped | Per business returned with usable data | **$0.009** |
| Partial result | Reduced-page business | **Free (never billed)** |
| Actor start | Once per GB of run memory, at Apify's platform minimum | **$0.00001** |

So scraping 1,000 businesses costs about **$9**, plus Apify platform compute and proxy usage. The start fee is Apify's standard synthetic start event charged at the platform minimum, so it rounds to nothing on any real run (a 1 GB run adds $0.00001).

Reduced pages that Nextdoor occasionally serves under load are returned **free and never billed** — you only pay for businesses that come back with usable data.

### Tips and advanced options

- **Use residential proxies** for the most reliable results. Nextdoor rate-limits by IP and serves a reduced page after a burst of requests from one address; the Actor automatically retries reduced pages on a fresh IP.
- **Lower `maxConcurrency`** (to 3–4) for very large runs to reduce reduced-page responses further.
- **Deduplicate by `businessId`** if you feed overlapping lists.
- **Schedule** the Actor to refresh a lead list on a cadence and pipe new rows into your CRM via an integration.

### FAQ, disclaimers, and support

**Does this need a Nextdoor account or cookies?** No. It reads only public, logged-out business pages.

**Does it return individual reviews or star ratings?** No. Individual recommendations are behind Nextdoor's login and are not scraped, and public pages carry no star ratings. What you get instead is the public AI `recommendationsSummary`, which distills those recommendations into prose.

**Why is `connectionsCount` always 0?** Nextdoor reports `0` publicly for most business pages. The field is included for completeness, but the value in this data is the recommendation summary and the structured contact/category fields, not the counts. Do not build a workflow that depends on `connectionsCount` being populated.

**Why are email and website usually empty?** Nextdoor renders those with client-side JavaScript, which this fast HTTP scraper does not execute, so they are typically `null`. Phone, name, categories, and the recommendation summary are read directly from the page and are reliable.

**Is scraping Nextdoor legal, and can I use the data for outreach?** This Actor collects only publicly available business information. **You are responsible for confirming your own legal basis before running it** and for using the data in compliance with Nextdoor's Terms of Service and applicable law, including data-protection laws (such as GDPR) and anti-spam laws (such as CAN-SPAM and TCPA) if you contact these businesses. Note that Nextdoor's `robots.txt` disallows automated access to `/pages/`; review Nextdoor's terms and `robots.txt` and decide your posture before running at scale.

**Something looks wrong or a field stopped populating.** Websites change their markup. Report it on the **Issues** tab and it will be fixed promptly.

# Actor input Schema

## `startUrls` (type: `array`):

Nextdoor business page URLs to scrape, e.g. https://nextdoor.com/pages/your-business-slug/. Also accepts category directory URLs like https://nextdoor.com/directories/plumber/ to enqueue the business pages linked from them.

## `businessSlugs` (type: `array`):

Business page slugs (the part after /pages/), e.g. "all-home-services". Each becomes https://nextdoor.com/pages/<slug>/. Convenient when you already have a list of businesses.

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

Hard cap on the number of business pages scraped (0 = no cap). Protects you from unexpectedly large runs.

## `maxConcurrency` (type: `integer`):

How many pages to fetch in parallel. Lower values are gentler and reduce partial (reduced-page) responses; higher values are faster. 5 is a safe default.

## `proxyConfiguration` (type: `object`):

Nextdoor rate-limits by IP and degrades to a reduced page after a handful of rapid requests from one address, so residential proxies are strongly recommended for reliable full results. Datacenter proxies work for small runs.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://nextdoor.com/pages/all-home-services/"
    }
  ],
  "businessSlugs": [],
  "maxItems": 0,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://nextdoor.com/pages/all-home-services/"
        }
    ],
    "businessSlugs": [],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("asvuep/nextdoor-business-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 = {
    "startUrls": [{ "url": "https://nextdoor.com/pages/all-home-services/" }],
    "businessSlugs": [],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("asvuep/nextdoor-business-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 '{
  "startUrls": [
    {
      "url": "https://nextdoor.com/pages/all-home-services/"
    }
  ],
  "businessSlugs": [],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call asvuep/nextdoor-business-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Nextdoor Business Scraper",
        "description": "Scrape public Nextdoor business pages: Nextdoor's AI-written summary of what neighbors say, plus name, categories, and phone. No login required.",
        "version": "0.1",
        "x-build-id": "6hvSuefpsDXfqXbr0"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/asvuep~nextdoor-business-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-asvuep-nextdoor-business-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/asvuep~nextdoor-business-scraper/runs": {
            "post": {
                "operationId": "runs-sync-asvuep-nextdoor-business-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/asvuep~nextdoor-business-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-asvuep-nextdoor-business-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": {
                    "startUrls": {
                        "title": "Business page URLs",
                        "type": "array",
                        "description": "Nextdoor business page URLs to scrape, e.g. https://nextdoor.com/pages/your-business-slug/. Also accepts category directory URLs like https://nextdoor.com/directories/plumber/ to enqueue the business pages linked from them.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "businessSlugs": {
                        "title": "Business slugs",
                        "type": "array",
                        "description": "Business page slugs (the part after /pages/), e.g. \"all-home-services\". Each becomes https://nextdoor.com/pages/<slug>/. Convenient when you already have a list of businesses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max businesses to scrape",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on the number of business pages scraped (0 = no cap). Protects you from unexpectedly large runs.",
                        "default": 0
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "How many pages to fetch in parallel. Lower values are gentler and reduce partial (reduced-page) responses; higher values are faster. 5 is a safe default.",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Nextdoor rate-limits by IP and degrades to a reduced page after a handful of rapid requests from one address, so residential proxies are strongly recommended for reliable full results. Datacenter proxies work for small runs.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
