# Birdeye Reviews Scraper (`automation-lab/birdeye-reviews-scraper`) Actor

Scrape public Birdeye business profiles, ratings, and reviews for reputation monitoring, local SEO, and competitor research.

- **URL**: https://apify.com/automation-lab/birdeye-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Birdeye Reviews Scraper

Extract public Birdeye business profiles, ratings, and review text from `reviews.birdeye.com` with a simple Apify Actor.

### What does Birdeye Reviews Scraper do?

Birdeye Reviews Scraper turns public Birdeye review pages into structured datasets.
It accepts Birdeye business profile URLs and Birdeye directory/category URLs.
For each public profile, it saves business metadata and review rows.

- ⭐ Overall business rating
- 🧾 Public review count
- 🏢 Business name and profile URL
- 📍 Address fields
- ☎️ Phone and website
- 👤 Reviewer name
- 📅 Review date
- ⭐ Review star rating
- 💬 Review text
- 🔗 Source URL and scrape timestamp

### Who is it for?

Reputation agencies use the scraper to monitor public Birdeye reviews for clients.
Local SEO teams use it to compare review quality across locations.
Market researchers use it to build category-level samples from Birdeye directories.
Sales teams use it to identify businesses with strong or weak public reputation signals.
Data teams use it to enrich internal business records with public review metadata.

### Why use this actor?

Birdeye pages are useful but not convenient as spreadsheets.
This actor extracts the public structured data already present in the HTML.
That means runs are lightweight, fast, and do not require browser automation for the MVP.
You get a clean dataset ready for CSV, JSON, Excel, API, or warehouse export.

### Data you can extract

| Field | Description |
| --- | --- |
| `itemType` | `review` or `business` fallback row |
| `businessName` | Public Birdeye business name |
| `profileUrl` | Birdeye profile URL |
| `businessId` | Numeric ID parsed from the profile URL |
| `rating` | Aggregate profile rating |
| `reviewCount` | Public aggregate review count |
| `reviewerName` | Public reviewer name |
| `reviewDate` | Published review date |
| `reviewRating` | Star rating for the review |
| `reviewText` | Review body text |
| `phone` | Business phone number |
| `website` | Business website |
| `address` | Full formatted address |
| `sourceUrl` | Start URL that led to the item |
| `scrapedAt` | ISO timestamp of extraction |

### How much does it cost to scrape Birdeye reviews?

This actor uses pay-per-event pricing.
There is a small start charge per run and a per-result charge for each saved review or business row.
Exact pricing is shown on the Apify Store page before you run the actor.
Use low limits first, then increase `maxReviews` when the sample output matches your workflow.

### Input options

#### Start URLs

Add one or more URLs from `reviews.birdeye.com`.
You can use profile URLs or directory URLs.
Directory URLs are scanned for public business profile links.

#### Maximum reviews

`maxReviews` controls the total number of rows saved across all profiles.
This is the main budget control.

#### Maximum profiles

`maxProfiles` limits how many profile pages are opened from directory pages.
Use this to sample categories without crawling too broadly.

#### Include businesses with no visible reviews

When enabled, profiles without visible review rows still produce one business summary row.
This helps directory exports keep useful contact and rating data.

### Example input

```json
{
  "startUrls": [
    { "url": "https://reviews.birdeye.com/d/categories/dental/" },
    { "url": "https://reviews.birdeye.com/finger-lakes-dental-care-165597990994171" }
  ],
  "maxReviews": 25,
  "maxProfiles": 5,
  "includeBusinessOnlyItems": true
}
````

### Example output

```json
{
  "itemType": "review",
  "businessName": "Finger Lakes Dental Care",
  "profileUrl": "https://reviews.birdeye.com/finger-lakes-dental-care-165597990994171",
  "rating": 4.9,
  "reviewCount": 43372,
  "reviewerName": "Brookelene B.",
  "reviewDate": "2022-08-29",
  "reviewRating": 5,
  "reviewText": "I had a GREAT experience...",
  "phone": "(585) 394-1930",
  "website": "https://fingerlakesdental.com/...",
  "address": "329 S Main St, Canandaigua, NY, 14424, US"
}
```

### How to scrape Birdeye reviews

1. Open the actor on Apify.
2. Paste one or more Birdeye profile or directory URLs.
3. Set `maxReviews` to a small test value.
4. Run the actor.
5. Preview the dataset.
6. Export results as CSV, JSON, Excel, or via API.
7. Increase limits for your production run.

### Tips for better results

- Use profile URLs when you need a known business.
- Use directory URLs when you want discovery by category.
- Keep `maxProfiles` low for first tests.
- Deduplicate by `businessId`, `profileUrl`, `reviewerName`, and `reviewDate` downstream.
- Treat review counts as public page metadata that can change over time.

### Integrations

Use the output with common reputation and analytics workflows:

- 📊 Google Sheets or Excel dashboards
- 🧠 LLM sentiment classification pipelines
- 🏢 CRM enrichment for local-business leads
- 📈 Local SEO reporting tools
- 🗃️ BigQuery, Snowflake, or PostgreSQL datasets
- 🔔 Alerts when new low-star public reviews appear in a repeated crawl

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/birdeye-reviews-scraper').call({
  startUrls: [{ url: 'https://reviews.birdeye.com/d/categories/dental/' }],
  maxReviews: 25,
  maxProfiles: 5
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/birdeye-reviews-scraper').call(run_input={
    'startUrls': [{'url': 'https://reviews.birdeye.com/d/categories/dental/'}],
    'maxReviews': 25,
    'maxProfiles': 5,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~birdeye-reviews-scraper/runs?token=MY-APIFY-TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://reviews.birdeye.com/d/categories/dental/"}],"maxReviews":25,"maxProfiles":5}'
```

### MCP usage

You can use this actor through Apify MCP tools in Claude Code or Claude Desktop.
Configure Apify MCP with the actor-specific tool URL:

```text
https://mcp.apify.com/?tools=automation-lab/birdeye-reviews-scraper
```

Claude Code quick setup:

```bash
claude mcp add apify-birdeye-reviews https://mcp.apify.com/?tools=automation-lab/birdeye-reviews-scraper
```

Claude Desktop JSON configuration:

```json
{
  "mcpServers": {
    "apify-birdeye-reviews": {
      "url": "https://mcp.apify.com/?tools=automation-lab/birdeye-reviews-scraper"
    }
  }
}
```

Example prompts:

- "Run Birdeye Reviews Scraper for this profile and summarize negative reviews."
- "Extract 25 dental practice reviews from this Birdeye category URL."
- "Compare average ratings for these Birdeye profile URLs."

### Data quality notes

The actor extracts public structured data embedded in Birdeye pages.
Some profiles expose only a subset of all historical reviews in initial HTML.
If Birdeye changes its page structure, fields may temporarily become empty until the actor is updated.
Always verify a small sample before relying on a large recurring run.

### Legality and ethics

This actor collects public information from public web pages.
You are responsible for using the data in a lawful way.
Do not use scraped data for spam, harassment, or prohibited profiling.
Respect applicable privacy, platform, and data protection rules.

### FAQ and troubleshooting

#### Why did I get fewer reviews than the public review count?

The public review count is an aggregate profile metric.
The initial profile HTML may expose only a visible subset of individual reviews.
Increase limits for more profiles, or use profile URLs that expose the reviews you need.

#### Why did a directory URL return businesses from only a few profiles?

`maxProfiles` limits how many profile pages are opened from a directory.
Increase `maxProfiles` if you want to sample more businesses.

#### Why are some optional fields null?

Birdeye does not expose every field on every profile.
The actor leaves unavailable fields as null instead of guessing.

### Related scrapers

Other Automation Lab actors that pair well with this workflow:

- https://apify.com/automation-lab/google-maps-reviews-scraper
- https://apify.com/automation-lab/trustpilot-scraper
- https://apify.com/automation-lab/yelp-scraper
- https://apify.com/automation-lab/google-maps-lead-finder

### Change monitoring workflow

Run the actor on the same set of profile URLs daily or weekly.
Store results in your database.
Compare new rows by reviewer, date, rating, and review text.
Trigger alerts when low-star reviews appear.

### Agency reporting workflow

Use directory URLs to discover public competitors in a category.
Export reviews and aggregate ratings.
Group by city, category, and business.
Create a benchmark report for local clients.

### Local SEO workflow

Combine Birdeye review metrics with Google Business Profile metrics.
Identify businesses with many reviews but low ratings.
Prioritize outreach or content updates based on sentiment themes.

### Limits

The actor is designed for public profile and directory pages.
It does not log in to Birdeye.
It does not access private dashboards.
It does not bypass access controls.

### Support

If a public Birdeye page does not parse correctly, include the run ID and the URL when reporting the issue.
A reproducible public URL helps maintainers update the parser quickly.

### Summary

Birdeye Reviews Scraper is a lightweight way to turn public Birdeye reputation pages into structured data.
It is best for agencies, analysts, and local-business teams that need repeatable exports instead of manual copy-paste.
Start small, validate the fields, and scale the limits when the dataset matches your use case.

# Actor input Schema

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

Birdeye business profile URLs or directory/category URLs from reviews.birdeye.com.

## `maxReviews` (type: `integer`):

Maximum number of review or business rows to save across all profiles.

## `maxProfiles` (type: `integer`):

Maximum number of Birdeye business profiles to open from directory pages.

## `includeBusinessOnlyItems` (type: `boolean`):

If a profile has no reviews in its public structured data, save one business summary row.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://reviews.birdeye.com/d/categories/dental/"
    },
    {
      "url": "https://reviews.birdeye.com/finger-lakes-dental-care-165597990994171"
    }
  ],
  "maxReviews": 10,
  "maxProfiles": 5,
  "includeBusinessOnlyItems": true
}
```

# Actor output Schema

## `overview` (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://reviews.birdeye.com/d/categories/dental/"
        },
        {
            "url": "https://reviews.birdeye.com/finger-lakes-dental-care-165597990994171"
        }
    ],
    "maxReviews": 10,
    "maxProfiles": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/birdeye-reviews-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://reviews.birdeye.com/d/categories/dental/" },
        { "url": "https://reviews.birdeye.com/finger-lakes-dental-care-165597990994171" },
    ],
    "maxReviews": 10,
    "maxProfiles": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/birdeye-reviews-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://reviews.birdeye.com/d/categories/dental/"
    },
    {
      "url": "https://reviews.birdeye.com/finger-lakes-dental-care-165597990994171"
    }
  ],
  "maxReviews": 10,
  "maxProfiles": 5
}' |
apify call automation-lab/birdeye-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Birdeye Reviews Scraper",
        "description": "Scrape public Birdeye business profiles, ratings, and reviews for reputation monitoring, local SEO, and competitor research.",
        "version": "0.1",
        "x-build-id": "e2WXywhsI770zrEcy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~birdeye-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-birdeye-reviews-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/automation-lab~birdeye-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-birdeye-reviews-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/automation-lab~birdeye-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-birdeye-reviews-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",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Birdeye business profile URLs or directory/category URLs from reviews.birdeye.com.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxReviews": {
                        "title": "Maximum reviews",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of review or business rows to save across all profiles.",
                        "default": 50
                    },
                    "maxProfiles": {
                        "title": "Maximum profiles",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of Birdeye business profiles to open from directory pages.",
                        "default": 20
                    },
                    "includeBusinessOnlyItems": {
                        "title": "Include businesses with no visible reviews",
                        "type": "boolean",
                        "description": "If a profile has no reviews in its public structured data, save one business summary row.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```