# ProvenExpert Reviews Scraper (`automation-lab/provenexpert-reviews-scraper`) Actor

Scrape public ProvenExpert profiles, ratings, recommendation rates, categories, contact details, and latest customer reviews.

- **URL**: https://apify.com/automation-lab/provenexpert-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

## ProvenExpert Reviews Scraper

### What does ProvenExpert Reviews Scraper do?

ProvenExpert Reviews Scraper extracts public review profile data from ProvenExpert profile pages.

It saves company profile details, aggregate rating signals, recommendation rates, public categories, and the latest visible customer reviews.

Use it to monitor reputation, benchmark service providers, and export review evidence into spreadsheets, BI tools, or CRMs.

### Who is it for?

🏢 Reputation agencies tracking client review profiles.

📈 SEO teams collecting social proof for local landing pages.

🛒 Ecommerce and service teams comparing review quality across providers.

🧑‍💼 Sales teams qualifying companies by public customer satisfaction.

🧪 Analysts building review-platform datasets for market research.

### Why use this ProvenExpert scraper?

It uses the public profile page and does not require a ProvenExpert account.

It runs as an Apify Actor, so you can schedule it, call it from an API, or connect it to integrations.

It exports clean rows instead of forcing you to copy review snippets manually.

### What data can you extract?

The dataset includes profile identity, aggregate metrics, reviewer details, review ratings, review text, and source URLs.

Profile summary rows use `type = profile`.

Review rows use `type = review`.

### Data table

| Field | Description |

| --- | --- |

| `type` | `profile` or `review` row type |

| `profileUrl` | Canonical ProvenExpert profile URL |

| `profileName` | Public company or profile name |

| `averageRating` | Aggregate rating value |

| `reviewCount` | Public review count from structured data |

| `recommendationRate` | Recommendation percentage when available |

| `reviewerName` | Reviewer display name |

| `reviewDate` | Review publication date |

| `reviewRating` | Rating for the individual review |

| `reviewBody` | Review text |

| `categories` | Public tags and competencies |

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

The actor uses pay-per-event pricing.

A small start charge covers the run setup.

Each saved dataset item is charged as one result.

Keep the default prefill small while testing, then scale profiles once you verify the output matches your needs.

### How to use ProvenExpert Reviews Scraper

1. Open the actor on Apify.

2. Paste one or more ProvenExpert profile URLs.

3. Optionally add profile slugs such as `provenexpert-com`.

4. Set the maximum number of reviews per profile.

5. Start the run and download the dataset as JSON, CSV, Excel, or via API.

### Input

The main input is `startUrls`.

You can also use `profileSlugs` with the `locale` field.

Example input:

```json

{

  "startUrls": [{ "url": "https://www.provenexpert.com/en-us/provenexpert-com/" }],

  "maxReviewsPerProfile": 20,

  "includeProfileSummary": true

}

````

### Output

Example output item:

```json

{

  "type": "review",

  "profileName": "ProvenExpert.com",

  "averageRating": 4.43,

  "reviewerName": "Anonymously",

  "reviewRating": 5,

  "reviewBody": "Helpful support and fast response.",

  "profileUrl": "https://www.provenexpert.com/en-us/provenexpert-com/"

}

```

### Tips for best results

✅ Use full public profile URLs when possible.

✅ Keep `includeProfileSummary` enabled if you need aggregate metrics.

✅ Run the actor on a schedule to watch rating changes over time.

✅ Export CSV for quick stakeholder reports.

✅ Use slugs when your upstream system stores only profile identifiers.

### Integrations

Connect the actor to Google Sheets for weekly review monitoring.

Send new review rows to Slack using an Apify integration webhook.

Load results into a CRM to enrich lead records with public reputation data.

Store historical datasets in S3 or BigQuery for long-term trend analysis.

### API usage

#### Node.js

```js

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor("automation-lab/provenexpert-reviews-scraper").call({

  startUrls: [{ url: "https://www.provenexpert.com/en-us/provenexpert-com/" }],

  maxReviewsPerProfile: 20

});

console.log(run.defaultDatasetId);

```

#### Python

```python

from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")

run = client.actor("automation-lab/provenexpert-reviews-scraper").call(run_input={

    "startUrls": [{"url": "https://www.provenexpert.com/en-us/provenexpert-com/"}],

    "maxReviewsPerProfile": 20,

})

print(run["defaultDatasetId"])

```

#### cURL

```bash

curl -X POST "https://api.apify.com/v2/acts/automation-lab~provenexpert-reviews-scraper/runs?token=$APIFY_TOKEN" \

  -H "Content-Type: application/json" \

  -d '{"startUrls":[{"url":"https://www.provenexpert.com/en-us/provenexpert-com/"}],"maxReviewsPerProfile":20,"includeProfileSummary":true}'

```

### MCP usage

Use Apify MCP to call this actor from AI tools such as Claude Code, Claude Desktop, Cursor, and VS Code. The scoped MCP server URL is:

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

#### Claude Code MCP setup

Add the actor as a scoped HTTP MCP tool from your terminal:

```bash
claude mcp add apify-provenexpert-reviews --transport http "https://mcp.apify.com/?tools=automation-lab/provenexpert-reviews-scraper"
```

Then ask Claude Code to run the scraper with a profile URL or slug.

#### Claude Desktop MCP setup

Add this server to your Claude Desktop MCP configuration:

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

#### Cursor MCP setup

Add the same HTTP server to your Cursor MCP settings:

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

#### VS Code MCP setup

Add this server to `.vscode/mcp.json` or your user MCP configuration:

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

Example prompt: "Scrape this ProvenExpert profile and summarize the latest negative review themes."

Example prompt: "Run the ProvenExpert Reviews Scraper weekly and compare aggregate rating changes."

### Scheduling

Apify schedules let you run this scraper daily, weekly, or monthly.

For reputation monitoring, a weekly schedule is usually enough.

For launch campaigns or customer support incidents, run it daily until the review flow stabilizes.

### Quality and limitations

The actor extracts public data visible in the ProvenExpert profile HTML.

It does not access private dashboards, hidden review moderation data, or account-only analytics.

Public profile pages may expose only the latest visible reviews in structured data.

### Troubleshooting

**The run saved only a profile row.** Check that the public profile page currently exposes reviews in JSON-LD and that `maxReviewsPerProfile` is above 0.

**The URL failed.** Confirm the profile is public and reachable in a browser without login.

**I need more history.** Use multiple public profile URLs or run the actor regularly to build a historical archive over time.

### Legality

This actor is designed for public ProvenExpert profile pages.

Review your use case, local laws, and ProvenExpert terms before scraping at scale.

Do not use scraped personal data for spam, harassment, or decisions that require legal compliance review.

### Related scrapers

You may also need related reputation and review actors on Apify:

- https://apify.com/automation-lab/google-maps-reviews-scraper

- https://apify.com/automation-lab/trustpilot-reviews-scraper

- https://apify.com/automation-lab/sitejabber-reviews-scraper

- https://apify.com/automation-lab/reviews-io-scraper

### FAQ

**Can I scrape any ProvenExpert page?** The actor is intended for public profile pages.

**Do I need proxies?** The MVP uses direct HTTP requests and does not require browser automation.

**Can I export Excel?** Yes, Apify datasets support XLSX, CSV, JSON, XML, RSS, and API access.

**Can I monitor many profiles?** Yes, add multiple URLs or slugs to the input.

**Does it include profile summary data?** Yes, enable `includeProfileSummary`.

### Support

If a public profile does not parse correctly, share the profile URL and a run ID.

Include whether you expected profile metrics, review rows, or both.

We can adjust the extractor when ProvenExpert changes public page markup.

### Field notes

- `profileUrl` is the public page that produced the row; `sourceUrl` helps audit redirects or locale changes.
- `profileSlug` is parsed from the final URL path segment and is useful for joining data to internal lists.
- `profileImage` comes from structured data or OpenGraph metadata when the page exposes it.
- `overallGradeText` mirrors ProvenExpert wording when present, while `averageRating` stays numeric for sorting.
- `ratingCount` and `reviewCount` can differ because platforms may count ratings and written reviews separately.
- `recommendationRate` is parsed from public page metadata when available.
- `categories` combines public tags and competency labels and is saved as a list in the raw JSON item.
- `telephone` is included only when public structured data exposes it.
- `language` is parsed from the HTML language attribute.
- `scrapedAt` is generated by the actor at save time so scheduled exports can be compared over time.

# Actor input Schema

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

Public ProvenExpert profile URLs to scrape. Add one or more profile pages such as https://www.provenexpert.com/en-us/provenexpert-com/.

## `profileSlugs` (type: `array`):

Optional ProvenExpert profile slugs. Use this when you know the profile slug but do not want to paste the full URL.

## `locale` (type: `string`):

Locale path used when converting profile slugs to URLs.

## `maxReviewsPerProfile` (type: `integer`):

Maximum review rows to save from each profile page. Public ProvenExpert pages currently expose the latest reviews in page structured data.

## `includeProfileSummary` (type: `boolean`):

Save one profile summary item before the review rows for each profile.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.provenexpert.com/en-us/provenexpert-com/"
    }
  ],
  "profileSlugs": [
    "provenexpert-com"
  ],
  "locale": "en-us",
  "maxReviewsPerProfile": 20,
  "includeProfileSummary": 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://www.provenexpert.com/en-us/provenexpert-com/"
        }
    ],
    "profileSlugs": [
        "provenexpert-com"
    ],
    "locale": "en-us",
    "maxReviewsPerProfile": 20,
    "includeProfileSummary": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/provenexpert-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://www.provenexpert.com/en-us/provenexpert-com/" }],
    "profileSlugs": ["provenexpert-com"],
    "locale": "en-us",
    "maxReviewsPerProfile": 20,
    "includeProfileSummary": True,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/provenexpert-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://www.provenexpert.com/en-us/provenexpert-com/"
    }
  ],
  "profileSlugs": [
    "provenexpert-com"
  ],
  "locale": "en-us",
  "maxReviewsPerProfile": 20,
  "includeProfileSummary": true
}' |
apify call automation-lab/provenexpert-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "ProvenExpert Reviews Scraper",
        "description": "Scrape public ProvenExpert profiles, ratings, recommendation rates, categories, contact details, and latest customer reviews.",
        "version": "0.1",
        "x-build-id": "yARA1ppMxnSAd4ul2"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~provenexpert-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-provenexpert-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~provenexpert-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-provenexpert-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~provenexpert-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-provenexpert-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",
                "properties": {
                    "startUrls": {
                        "title": "ProvenExpert profile URLs",
                        "type": "array",
                        "description": "Public ProvenExpert profile URLs to scrape. Add one or more profile pages such as https://www.provenexpert.com/en-us/provenexpert-com/.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "profileSlugs": {
                        "title": "Profile slugs",
                        "type": "array",
                        "description": "Optional ProvenExpert profile slugs. Use this when you know the profile slug but do not want to paste the full URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locale": {
                        "title": "Locale for slugs",
                        "type": "string",
                        "description": "Locale path used when converting profile slugs to URLs.",
                        "default": "en-us"
                    },
                    "maxReviewsPerProfile": {
                        "title": "Maximum reviews per profile",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum review rows to save from each profile page. Public ProvenExpert pages currently expose the latest reviews in page structured data.",
                        "default": 20
                    },
                    "includeProfileSummary": {
                        "title": "Include profile summary row",
                        "type": "boolean",
                        "description": "Save one profile summary item before the review rows for each profile.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```