# Trustpilot Reviews Scraper Pro (`crawlerbros/trustpilot-reviews-scraper-pro`) Actor

Scrape Trustpilot business reviews, ratings, replies, and rating distributions across any business domain. Multi-business batch with rich filtering: rating range, language, date range, keyword search, verified-only, and reviews-with-company-response.

- **URL**: https://apify.com/crawlerbros/trustpilot-reviews-scraper-pro.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 8 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Trustpilot Reviews Scraper Pro

Scrape **Trustpilot** business reviews, ratings, replies, and rating distributions across any business domain. Multi-business batch with rich filtering: rating bounds, language, date range, verified-only, business-reply-required, and keyword search.

### What this actor does

- Scrapes per-review records from `https://www.trustpilot.com/review/<domain>` for any number of businesses in a single run
- Or returns per-business summary records (TrustScore, total reviews, rating distribution, categories, claimed status)
- Filters: `minRating` / `maxRating`, `verifiedOnly`, `responseRequired`, `language`, `dateRangeFrom` / `dateRangeTo`, `containsKeyword`
- Pagination: handles up to 1,000 reviews per business via `?page=N`
- Bypasses Trustpilot's AWS WAF JS challenge by routing Chromium through Apify residential proxy with a fresh session per business
- All output uses an omit-empty contract — no nulls / empty strings ever appear in records

### Output: per-review (mode = `reviews`)

- `businessDomain`, `businessName`
- `reviewId`, `reviewUrl`
- `rating` (1-5), `title`, `body`
- `reviewerName`, `reviewerCountry`, `reviewerId`, `reviewerReviewCount`
- `reviewedAt` (publish date), `experiencedAt` (when the customer used the service)
- `verified` (bool), `language`
- `helpfulCount`
- `businessReply` — `{text, repliedAt}` when present
- `recordType: "review"`, `scrapedAt`

### Output: per-business (mode = `summary`)

- `businessDomain`, `businessName`, `identifyingName`, `businessUnitId`
- `websiteUrl`, `trustpilotUrl`
- `trustScore` (1.0–5.0), `stars` (rounded), `totalReviews`
- `ratingDistribution` — `{"1": n, "2": n, "3": n, "4": n, "5": n}`
- `categories[]`
- `verified` (bool), `claimedAt`
- `address` — `{city, country, ...}` when available
- `recordType: "businessSummary"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `businessDomains` | array | `["amazon.com"]` | List of business domains (e.g. `amazon.com`, `airbnb.com`). Trustpilot URLs are accepted too. |
| `mode` | string | `reviews` | `reviews` (per-review records) / `summary` (one record per business) |
| `maxReviewsPerBusiness` | int | `100` | Hard cap per business in `reviews` mode (1–1000) |
| `language` | string | `""` | Filter to a single language (`en`, `de`, `fr`, …) |
| `minRating` / `maxRating` | int | – | 1–5 bounds for the `rating` field |
| `verifiedOnly` | bool | `false` | Only emit reviews flagged as verified |
| `responseRequired` | bool | `false` | Only emit reviews that received a business reply |
| `dateRangeFrom` / `dateRangeTo` | string | – | ISO date filters on `reviewedAt` |
| `containsKeyword` | string | – | Case-insensitive substring match on title/body |
| `maxItems` | int | `500` | Global hard cap across all businesses (1–50000) |
| `proxyConfiguration` | object | RESIDENTIAL | Apify residential proxy — required (datacenter IPs are blocked) |

#### Example: latest 1-star reviews of Amazon with replies

```json
{
  "businessDomains": ["amazon.com"],
  "mode": "reviews",
  "maxReviewsPerBusiness": 100,
  "minRating": 1,
  "maxRating": 1,
  "responseRequired": true,
  "language": "en"
}
````

#### Example: bulk summary of competitors

```json
{
  "businessDomains": ["airbnb.com", "vrbo.com", "booking.com"],
  "mode": "summary"
}
```

#### Example: keyword monitor for a brand

```json
{
  "businessDomains": ["mybrand.com"],
  "mode": "reviews",
  "containsKeyword": "shipping",
  "dateRangeFrom": "2025-01-01"
}
```

#### Example: 5-star reviews mentioning "support" — German market

```json
{
  "businessDomains": ["yourcompany.de"],
  "mode": "reviews",
  "minRating": 5,
  "language": "de",
  "containsKeyword": "support"
}
```

### Use cases

- **Reputation management** — daily monitor of new reviews and replies for tracked brands
- **Competitor research** — bulk-summarize TrustScores + rating distributions across competitors
- **Brand sentiment tracking** — keyword filter (e.g. `delivery`, `cancel`) for high-volume brands
- **Compliance / consumer protection** — pull every 1-star review citing specific issues
- **Customer-success ROI** — count replies-to-reviews ratio per business
- **Localization research** — filter by `language` to compare sentiment across markets
- **Investor due diligence** — track multi-month rating-distribution trends for a private brand
- **Journalism** — bulk-export negative reviews for an investigative piece

### FAQ

**Why is residential proxy required?**  Trustpilot's pages are protected by AWS WAF, which blocks datacenter IPs with a JS-challenge interstitial. Residential IPs pass the challenge transparently. The actor fails fast if no residential proxy is configured.

**Does it require login or cookies?**  No. All Trustpilot business pages are public.

**What's the difference between `reviewedAt` and `experiencedAt`?**  `reviewedAt` is when the consumer published the review on Trustpilot. `experiencedAt` is the service date the consumer reported (when they actually used the service). Both are extracted when present.

**Are reviewer profiles included?**  Yes — `reviewerName`, `reviewerCountry`, and `reviewerId` (when public). Some reviewers post anonymously and only the display name is available.

**Can I scrape replies-only?**  Yes — set `responseRequired: true`. Note: many high-volume retailers (Amazon, Walmart, etc.) don't reply to most recent reviews on Trustpilot, so this filter may return 0 results for big brands; smaller businesses with active customer-care typically yield more matches.

**What's the throughput?**  Trustpilot loads 20 reviews per page. The actor fetches sequentially per business with a 0.5–1.5s delay between pages. Expect ~1k reviews per business in ~1 minute (plus initial proxy session warm-up).

**Are old reviews available?**  Yes — Trustpilot keeps reviews dating back years. `dateRangeFrom` lets you filter the window. Heads-up: Trustpilot returns reviews newest-first and caps deep pagination at ~10-12 pages (~200-240 reviews) from many IPs, so a tight `dateRangeFrom`/`dateRangeTo` window targeting reviews older than the actor can reach may return 0 records on high-volume businesses. For the broadest result set, use `dateRangeFrom` alone (no upper bound) or run on a smaller, lower-traffic business.

**What's a "verified" review?**  Trustpilot flags a review as verified if it can confirm the reviewer used the service (e.g. via the company's review-invitation flow).

**Can I scrape Trustpilot consumer profiles?**  Not in v1 — only business pages are supported.

**Why don't I see a `helpfulCount` on every review?**  Trustpilot only surfaces helpful counts on reviews with at least one upvote. Reviews with zero helpful votes have `helpfulCount: 0` (kept) or omit the field if Trustpilot doesn't expose it.

**Is this affiliated with Trustpilot?**  No, this actor is third-party and uses publicly accessible business pages.

# Actor input Schema

## `businessDomains` (type: `array`):

List of business domains as they appear on Trustpilot URLs (e.g. `amazon.com`, `airbnb.com`, `apple.com`). The domain is the part after `/review/` in the Trustpilot URL.

## `mode` (type: `string`):

What to emit. `reviews` returns one record per review (default). `summary` returns one record per business with TrustScore, total reviews, and rating distribution.

## `maxReviewsPerBusiness` (type: `integer`):

Hard cap on reviews fetched per business domain (mode=reviews). Trustpilot shows 20 reviews per page; this paginates.

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

Limit reviews to a specific language code (e.g. `en` for English, `de` for German). Leave empty for all languages.

## `minRating` (type: `integer`):

Drop reviews with a rating below this value.

## `maxRating` (type: `integer`):

Drop reviews with a rating above this value.

## `verifiedOnly` (type: `boolean`):

Only emit reviews flagged as verified.

## `dateRangeFrom` (type: `string`):

Drop reviews older than this date.

## `dateRangeTo` (type: `string`):

Drop reviews newer than this date.

## `containsKeyword` (type: `string`):

Only emit reviews whose title or body contains this substring (case-insensitive).

## `responseRequired` (type: `boolean`):

Only emit reviews that received a reply from the business.

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

Hard cap on total emitted records across all businesses.

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

Apify proxy. Residential proxy is REQUIRED for Trustpilot — datacenter IPs are blocked by AWS WAF.

## Actor input object example

```json
{
  "businessDomains": [
    "amazon.com"
  ],
  "mode": "reviews",
  "maxReviewsPerBusiness": 100,
  "language": "",
  "verifiedOnly": false,
  "responseRequired": false,
  "maxItems": 500,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `reviews` (type: `string`):

Dataset containing all scraped Trustpilot reviews and (when mode=summary) business summaries.

# 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 = {
    "businessDomains": [
        "amazon.com"
    ],
    "mode": "reviews",
    "maxReviewsPerBusiness": 100,
    "verifiedOnly": false,
    "responseRequired": false,
    "maxItems": 500,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/trustpilot-reviews-scraper-pro").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 = {
    "businessDomains": ["amazon.com"],
    "mode": "reviews",
    "maxReviewsPerBusiness": 100,
    "verifiedOnly": False,
    "responseRequired": False,
    "maxItems": 500,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/trustpilot-reviews-scraper-pro").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 '{
  "businessDomains": [
    "amazon.com"
  ],
  "mode": "reviews",
  "maxReviewsPerBusiness": 100,
  "verifiedOnly": false,
  "responseRequired": false,
  "maxItems": 500,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call crawlerbros/trustpilot-reviews-scraper-pro --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Reviews Scraper Pro",
        "description": "Scrape Trustpilot business reviews, ratings, replies, and rating distributions across any business domain. Multi-business batch with rich filtering: rating range, language, date range, keyword search, verified-only, and reviews-with-company-response.",
        "version": "1.0",
        "x-build-id": "C3VniqOp5gal6YKFb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~trustpilot-reviews-scraper-pro/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-trustpilot-reviews-scraper-pro",
                "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/crawlerbros~trustpilot-reviews-scraper-pro/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-trustpilot-reviews-scraper-pro",
                "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/crawlerbros~trustpilot-reviews-scraper-pro/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-trustpilot-reviews-scraper-pro",
                "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": [
                    "businessDomains",
                    "mode",
                    "proxyConfiguration"
                ],
                "properties": {
                    "businessDomains": {
                        "title": "Business domains",
                        "type": "array",
                        "description": "List of business domains as they appear on Trustpilot URLs (e.g. `amazon.com`, `airbnb.com`, `apple.com`). The domain is the part after `/review/` in the Trustpilot URL.",
                        "default": [
                            "amazon.com"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "reviews",
                            "summary"
                        ],
                        "type": "string",
                        "description": "What to emit. `reviews` returns one record per review (default). `summary` returns one record per business with TrustScore, total reviews, and rating distribution.",
                        "default": "reviews"
                    },
                    "maxReviewsPerBusiness": {
                        "title": "Max reviews per business",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on reviews fetched per business domain (mode=reviews). Trustpilot shows 20 reviews per page; this paginates.",
                        "default": 100
                    },
                    "language": {
                        "title": "Language filter",
                        "enum": [
                            "",
                            "en",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "nl",
                            "da",
                            "no",
                            "sv",
                            "fi",
                            "pt",
                            "pl"
                        ],
                        "type": "string",
                        "description": "Limit reviews to a specific language code (e.g. `en` for English, `de` for German). Leave empty for all languages.",
                        "default": ""
                    },
                    "minRating": {
                        "title": "Min rating (1-5)",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Drop reviews with a rating below this value."
                    },
                    "maxRating": {
                        "title": "Max rating (1-5)",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Drop reviews with a rating above this value."
                    },
                    "verifiedOnly": {
                        "title": "Verified only",
                        "type": "boolean",
                        "description": "Only emit reviews flagged as verified.",
                        "default": false
                    },
                    "dateRangeFrom": {
                        "title": "Date range from (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Drop reviews older than this date."
                    },
                    "dateRangeTo": {
                        "title": "Date range to (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Drop reviews newer than this date."
                    },
                    "containsKeyword": {
                        "title": "Contains keyword",
                        "type": "string",
                        "description": "Only emit reviews whose title or body contains this substring (case-insensitive)."
                    },
                    "responseRequired": {
                        "title": "Has business reply",
                        "type": "boolean",
                        "description": "Only emit reviews that received a reply from the business.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Global max items",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Hard cap on total emitted records across all businesses.",
                        "default": 500
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy. Residential proxy is REQUIRED for Trustpilot — datacenter IPs are blocked by AWS WAF.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
