# Trustpilot Brand Reputation and Sentiment Monitor (`scrapemint/trustpilot-brand-reputation`) Actor

For e-commerce brand managers and marketing teams. Pulls every Trustpilot review for any business with rating, text, consumer country, verified status, and company replies. Track your brand sentiment and benchmark against competitors without paying for a monitoring subscription.

- **URL**: https://apify.com/scrapemint/trustpilot-brand-reputation.md
- **Developed by:** [Kennedy Mutisya](https://apify.com/scrapemint) (community)
- **Categories:** E-commerce, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Trustpilot Review Data and Brand Reputation Monitoring Tool

Export every Trustpilot review for any business into a clean spreadsheet or JSON file. Get star ratings, review text, consumer country, verified status, review dates, company replies, and overall trust scores for your brand and your competitors.

Built for e-commerce brand managers, DTC marketing teams, and agencies who need Trustpilot review data without paying for a monthly reputation monitoring subscription.

---

### Who uses this and why

```mermaid
flowchart TD
    A[Brand Managers] -->|Catch sentiment dips<br/>before revenue drops| D[Trustpilot<br/>Review Data]
    B[DTC Marketing Teams] -->|Benchmark against<br/>3 competitors at once| D
    C[Agencies] -->|Deliver reputation reports<br/>for every client| D
    D --> E[Weekly sentiment report]
    D --> F[Competitor gap analysis]
    D --> G[Customer support triage]
````

| Role | What this gives you |
|---|---|
| **Brand manager** | Weekly review volume, star trends, verified vs unverified mix |
| **DTC marketer** | Side by side sentiment comparison against direct competitors |
| **Agency or consultant** | Client ready Trustpilot reports with full review datasets |
| **BI analyst** | Clean JSON or CSV ready for dashboards and sentiment models |

***

### How it works

```mermaid
flowchart LR
    A[Trustpilot<br/>business URL] --> B[Load review pages]
    B --> C[Parse embedded<br/>page data]
    C --> D[Paginate through<br/>every review]
    D --> E[Normalize fields]
    E --> F[(JSON, CSV, or Excel)]
```

The actor visits each Trustpilot business page, reads the structured data Trustpilot ships inside every page, and walks through every review 20 at a time. No brittle selectors, no login, no captcha. Same data Trustpilot shows in its own UI, delivered as a clean dataset.

***

### What one review record looks like

```json
{
  "reviewId": "69dbe793de2117596b6629fd",
  "businessName": "Booking.com",
  "businessOverallStars": 2,
  "businessTotalReviews": 108160,
  "businessTrustScore": 1.8,
  "rating": 1,
  "title": "Booked an apartment in Manchester",
  "text": "Booked an apartment in Manchester, got there, no such place...",
  "language": "en",
  "experiencedDate": "2026-04-04T00:00:00.000Z",
  "publishedDate": "2026-04-12T20:42:27.000Z",
  "isVerified": false,
  "consumerName": "Kathryn Burnand",
  "consumerCountry": "GB",
  "consumerReviewCount": 34,
  "hasCompanyReply": false,
  "companyReplyText": null
}
```

Every review comes back with: star rating (1 to 5), title, full text, language, source (organic or invited), likes, experience date, publish date, verification level, consumer name, country, total reviews the consumer has written, and the company reply with its own timestamp.

***

### Quick start

Export 200 recent reviews for a single business:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapemint~trustpilot-brand-reputation/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "businessUrl": "https://www.trustpilot.com/review/yourbrand.com",
    "maxReviews": 200,
    "sortBy": "NEWEST_FIRST"
  }'
```

Compare your brand against 2 competitors in one run, filtering for negative reviews only:

```json
{
  "businessUrls": [
    { "url": "https://www.trustpilot.com/review/yourbrand.com" },
    { "url": "https://www.trustpilot.com/review/competitor-one.com" },
    { "url": "https://www.trustpilot.com/review/competitor-two.com" }
  ],
  "maxReviews": 500,
  "filterByStars": ["1", "2"],
  "sortBy": "NEWEST_FIRST"
}
```

***

### Inputs

| Field | Type | Default | What it does |
|---|---|---|---|
| `businessUrls` | array | `[]` | Trustpilot business URLs. Add several to compare brands in one run. |
| `businessUrl` | string | `null` | Single URL shortcut. Used when `businessUrls` is empty. |
| `maxReviews` | integer | `500` | Hard cap per business. Controls cost. |
| `sortBy` | string | `NEWEST_FIRST` | `NEWEST_FIRST` or `MOST_RELEVANT` |
| `filterByStars` | array | `[]` | Ratings to keep (e.g. `["1","2"]` for complaint analysis). Empty = all. |
| `language` | string | `""` | Filter by language code like `en`, `fr`, `de`, `es`. Empty = all. |

***

### Pricing

Pay per review. Free tier lets you check the data before spending anything.

| Tier | Price | Best for |
|---|---|---|
| Free | First 100 reviews per run | Verifying the output format |
| Standard | $0.005 per review | Ongoing monitoring and competitor benchmarking |

```mermaid
flowchart LR
    A[Run the actor] --> B{First 100<br/>reviews}
    B -->|Free| C[Verify output]
    C --> D{Need more?}
    D -->|Yes| E[$0.005 per review<br/>after the first 100]
    D -->|No| F[Done, $0 spent]
```

***

### How this beats the alternatives

| Method | Cost for 5,000 reviews across 5 brands | Data depth | Time |
|---|---|---|---|
| Read Trustpilot manually | 15 to 25 analyst hours | Spreadsheet notes | Days |
| Reputation monitoring SaaS | $200 to $800 per month per brand | Aggregated dashboards | Subscription locked |
| **This actor** | **$24.50 once** | Full reviews, consumer data, replies, timestamps | Minutes |

***

### Compare brands in one run

```mermaid
flowchart LR
    A[Your brand URL] --> X[Actor]
    B[Competitor 1 URL] --> X
    C[Competitor 2 URL] --> X
    X --> D[(Unified review<br/>dataset)]
    D --> E[Sort by businessName<br/>in spreadsheet]
    E --> F[Head to head<br/>sentiment report]
```

Every record carries the `businessName` and `businessDomain` fields, so you can group results by brand in any spreadsheet or BI tool in seconds.

***

### Use case flows

```mermaid
flowchart TD
    subgraph Inputs
        A[Brand URLs]
    end
    subgraph Actor
        B[Pull reviews]
    end
    subgraph Outputs
        C[JSON / CSV / Excel]
    end
    subgraph Workflows
        D[Weekly sentiment alert]
        E[Competitor gap report]
        F[Support ticket routing]
        G[Marketing copy mining]
    end
    A --> B --> C
    C --> D
    C --> E
    C --> F
    C --> G
```

- **Weekly sentiment alert:** cron this actor, diff the latest run, email yourself when 1 star volume spikes
- **Competitor gap report:** pull your brand plus 3 competitors, sort by stars, show management what guests praise next door
- **Support ticket routing:** feed 1 and 2 star reviews into your helpdesk so CS sees complaints before they escalate
- **Marketing copy mining:** grep 5 star reviews for the exact phrases customers use, reuse them in landing pages

***

### Related tools in the review intelligence suite

```mermaid
flowchart LR
    A[Booking Review<br/>Intelligence] --> C[(Unified review<br/>dataset)]
    B[Trustpilot Brand<br/>Reputation] --> C
    C --> D[Cross platform<br/>reputation report]
```

- [**Booking Review Intelligence**](https://apify.com/scrapemint/booking-review-intelligence): hotel and STR reviews with sentiment, category scores, traveler type, and management replies
- **More review sources on the roadmap:** Google Reviews, G2, Capterra

***

### Frequently asked questions

**How do I download Trustpilot reviews to a CSV file?**
Run this actor with a Trustpilot business URL and your chosen cap. Export the dataset as CSV from the Apify console or pull it via the API. Works for any business with a public Trustpilot page.

**How do I monitor my brand reputation on Trustpilot without paying for a SaaS subscription?**
Schedule this actor weekly against your Trustpilot URL. Export the latest reviews and compare against last week in your own spreadsheet. A few dollars per run replaces a $200+ monthly subscription.

**Can I compare multiple brands on Trustpilot in one run?**
Yes. Pass every URL in the `businessUrls` array. Every review record includes `businessName` and `businessDomain`, so you can group and compare in any tool.

**How do I analyze only negative Trustpilot reviews?**
Set `filterByStars` to `["1", "2"]` to pull just 1 and 2 star reviews. Most complaint analysis workflows use this filter.

**What data does this return for each Trustpilot review?**
Rating (1 to 5), title, full review text, language, country, source (organic or invited), likes, experience date, publish date, verification status, consumer name and review history, and the full company reply with its timestamp.

**Does this work for Trustpilot pages in any country?**
Yes. Works across the US, UK, EU, and other Trustpilot locales. Just paste the business URL.

**How many reviews can I pull from one business?**
Up to the full history. Use `maxReviews` to set a cap. Large brands with 100,000+ reviews take several minutes to finish.

**How fresh is the data?**
Live at query time. Every run pulls straight from Trustpilot. No cached snapshots.

**What format is the output?**
JSON, CSV, or Excel. Download from the Apify dataset or pull via API.

# Actor input Schema

## `businessUrls` (type: `array`):

One or more Trustpilot business review URLs. Example: https://www.trustpilot.com/review/booking.com

## `businessUrl` (type: `string`):

Single Trustpilot business URL. Used only if businessUrls is empty.

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

Hard cap per business. Prevents runaway charges on businesses with tens of thousands of reviews.

## `sortBy` (type: `string`):

Review sort order.

## `filterByStars` (type: `array`):

Only return reviews with these star ratings. Valid values: 1, 2, 3, 4, 5. Leave empty for all ratings.

## `language` (type: `string`):

Only return reviews in this language. Leave empty for all languages. Example: en, fr, de, es

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

Apify proxy settings.

## Actor input object example

```json
{
  "businessUrls": [
    {
      "url": "https://www.trustpilot.com/review/booking.com"
    }
  ],
  "maxReviews": 500,
  "sortBy": "NEWEST_FIRST",
  "filterByStars": [],
  "language": "",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}
```

# 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 = {
    "businessUrls": [
        {
            "url": "https://www.trustpilot.com/review/booking.com"
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "BUYPROXIES94952"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/trustpilot-brand-reputation").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 = {
    "businessUrls": [{ "url": "https://www.trustpilot.com/review/booking.com" }],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["BUYPROXIES94952"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/trustpilot-brand-reputation").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 '{
  "businessUrls": [
    {
      "url": "https://www.trustpilot.com/review/booking.com"
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}' |
apify call scrapemint/trustpilot-brand-reputation --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=scrapemint/trustpilot-brand-reputation",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Brand Reputation and Sentiment Monitor",
        "description": "For e-commerce brand managers and marketing teams. Pulls every Trustpilot review for any business with rating, text, consumer country, verified status, and company replies. Track your brand sentiment and benchmark against competitors without paying for a monitoring subscription.",
        "version": "0.1",
        "x-build-id": "hXGOBNp0BCBrmllbR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~trustpilot-brand-reputation/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-trustpilot-brand-reputation",
                "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/scrapemint~trustpilot-brand-reputation/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-trustpilot-brand-reputation",
                "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/scrapemint~trustpilot-brand-reputation/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-trustpilot-brand-reputation",
                "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": {
                    "businessUrls": {
                        "title": "Trustpilot business review URLs",
                        "type": "array",
                        "description": "One or more Trustpilot business review URLs. Example: https://www.trustpilot.com/review/booking.com",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "businessUrl": {
                        "title": "Single business URL (alternative)",
                        "type": "string",
                        "description": "Single Trustpilot business URL. Used only if businessUrls is empty."
                    },
                    "maxReviews": {
                        "title": "Maximum reviews per business",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Hard cap per business. Prevents runaway charges on businesses with tens of thousands of reviews.",
                        "default": 500
                    },
                    "sortBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "NEWEST_FIRST",
                            "MOST_RELEVANT"
                        ],
                        "type": "string",
                        "description": "Review sort order.",
                        "default": "NEWEST_FIRST"
                    },
                    "filterByStars": {
                        "title": "Filter by star rating",
                        "type": "array",
                        "description": "Only return reviews with these star ratings. Valid values: 1, 2, 3, 4, 5. Leave empty for all ratings.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Language filter",
                        "type": "string",
                        "description": "Only return reviews in this language. Leave empty for all languages. Example: en, fr, de, es",
                        "default": ""
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
