# Trustpilot Reviews Scraper + Insights Report (`berkaydev/trustpilot-insights-scraper`) Actor

Scrape Trustpilot reviews by domain and get raw review data PLUS a built-in insights report — rating trends, complaint/praise keywords, response rate, suspicious spike detection, and multi-company comparison. No API key needed. Pay per review scraped.

- **URL**: https://apify.com/berkaydev/trustpilot-insights-scraper.md
- **Developed by:** [Berkay](https://apify.com/berkaydev) (community)
- **Categories:** Lead generation, E-commerce, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 1,000 review scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.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

Most Trustpilot scrapers pull the page over plain HTTP. Trustpilot blocks that a lot of the time, which is why so many of them fail part way through a run or only bring back half the reviews. This one runs a real browser, gets past the bot check, and reads the reviews straight from the page data. You get the whole set, not a random slice.

You also get more than rows. Every run turns the reviews into a short report: how the rating moved over time, what people complain about most, what they praise, how often the company replies, and a side by side table when you scrape more than one company.

To try it, drop in a domain like `pipedrive.com` and hit Start. First results come back in a few minutes.

### Trustpilot review insights report: complaint analysis, trends, and competitor comparison

The built-in insights report turns raw reviews into answers: a complaint and praise keyword analysis (the terms that show up most in low- and high-star reviews), rating trends by month, the company response rate, fake-spike detection, and a side-by-side competitor review comparison when you scrape more than one brand.

### What you get

Two outputs per run.

A dataset with one row per review. Download it as JSON, CSV, Excel, or XML, or pull it through the API into your own tools.

A report in the key value store:

- `REPORT` is an HTML page. Open it in any browser.
- `INSIGHTS` is the same numbers as JSON, in case you want to process them yourself.

The report covers:

- Average rating, the full star breakdown with percentages, and how many reviews are verified.
- How often the company replies to its reviews.
- Rating by month, so trends are easy to see.
- Months where review volume jumps to three times the usual. These can point to fake or paid-for review bursts, so they are worth a look before you trust a score.
- The 15 words and phrases that show up most in 1 and 2 star reviews. The complaints.
- The 15 that show up most in 4 and 5 star reviews. The praise.
- A comparison table across companies when you scrape more than one.

### How it compares

The two things that set it apart are reliability and the report.

| | This actor | Typical scraper |
|---|---|---|
| Gets past Trustpilot's bot protection | yes, real browser | often not, plain HTTP |
| Brings back the full review set | yes | not always |
| Insights report | yes | no |
| Complaint and praise keywords | yes | no |
| Fake spike detection | yes | no |
| Compare several companies in one run | yes | no |
| Runs on the free plan | yes | usually |

Common uses:

- Tracking your own brand's reputation over time.
- Benchmarking against competitors.
- Pulling product problems out of the low star reviews.
- Checking a vendor's score for manipulation before you buy.
- Client reporting at agencies.

### How to use it

1. Open the Input tab.
2. Put one or more domains or Trustpilot URLs in Company URLs, for example `pipedrive.com` or `airbnb.com`.
3. Set Max reviews per company. Leave it at 0 for all of them, or set 40 to 200 for a quick test.
4. Filter by language, star rating, or date if you want.
5. Hit Start. Reviews land in the Dataset tab. The report lands in the Key value store tab under `REPORT`.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `companyUrls` | array (required) | `["pipedrive.com"]` | Trustpilot URLs or bare domains, one per line |
| `maxReviewsPerCompany` | integer | 0 (all) | Cap per company |
| `stars` | array | all | Keep only these star ratings |
| `languages` | array | `["en"]` | ISO language codes like `en`, `de`, `fr`. Leave empty for all |
| `sort` | string | `recency` | `recency` or `relevance` |
| `date` | string | all time | `last30days`, `last3months`, `last6months`, `last12months` |
| `verified` | boolean | false | Only verified reviews |
| `withReplies` | boolean | false | Only reviews that got a company reply |
| `includeCompanyInfo` | boolean | true | Add trust score and category to each row |
| `generateInsights` | boolean | true | Build the report after scraping |
| `maxConcurrency` | integer | 5 | Parallel page fetches per company |
| `requestDelayMs` | integer | 300 | Wait between fetches. Raise it for politer crawling |
| `proxyConfiguration` | object | Apify datacenter proxy | Proxy settings |

#### Example input

```json
{
  "companyUrls": ["pipedrive.com", "hubspot.com"],
  "maxReviewsPerCompany": 200,
  "languages": ["en"],
  "generateInsights": true
}
````

### Output

One row per review:

```json
{
  "reviewId": "abc123",
  "companyName": "Pipedrive",
  "companyDomain": "pipedrive.com",
  "companyTrustScore": 4.4,
  "companyTotalReviews": 1872,
  "rating": 5,
  "title": "Great CRM for small teams",
  "text": "Easy to set up and the pipeline view is excellent...",
  "language": "en",
  "country": "US",
  "publishedDate": "2024-11-03T08:22:00Z",
  "isVerified": true,
  "replyMessage": null,
  "authorName": "John D.",
  "reviewUrl": "https://www.trustpilot.com/reviews/abc123"
}
```

Download the dataset as JSON, CSV, Excel, or XML from the Dataset tab.

Key value store:

| Key | Type | What it is |
|---|---|---|
| `INSIGHTS` | application/json | The full analytics object, per company plus the comparison |
| `REPORT` | text/html | The report. Open it in a browser |

#### Fields

| Field | Type | Description |
|---|---|---|
| `reviewId` | string | Trustpilot review ID |
| `companyName` | string | Company display name |
| `companyDomain` | string | Trustpilot identifying domain |
| `companyTrustScore` | float | Trust score (0 to 5) |
| `companyTotalReviews` | integer | Total reviews on Trustpilot |
| `rating` | integer | Star rating (1 to 5) |
| `title` | string | Review title |
| `text` | string | Full review text |
| `language` | string | ISO 639-1 language code |
| `country` | string | Reviewer country code |
| `publishedDate` | ISO 8601 | Review published date |
| `experienceDate` | ISO 8601 | Date of experience |
| `isVerified` | boolean | Whether the review is verified |
| `verificationLevel` | string | Verification label |
| `authorName` | string | Reviewer display name |
| `authorReviewCount` | integer | Total reviews by this author |
| `replyMessage` | string | Company reply text, null if none |
| `replyPublishedDate` | ISO 8601 | Company reply date |
| `reviewUrl` | string | Direct link to the review |

### Pricing

$0.0015 per review. No start fee.

| Reviews | Cost |
|---|---|
| 100 | $0.15 |
| 1,000 | $1.50 |
| 10,000 | $15.00 |
| 100,000 | $150.00 |

The report is always part of the run. You pay for reviews, not for the analysis. Apify's free plan gives you $5 a month in credits, which is around 3,300 reviews, and you don't need a card to start.

### Tips

- To benchmark, put in 3 to 5 competitor domains, set `maxReviewsPerCompany` to 300, keep `languages` at `["en"]`. The comparison table in the report gives you the side by side in a couple of minutes.
- For trends, set `date` to `last12months` and `maxReviewsPerCompany` to 0 to pull a full year.
- For complaint mining, look at `topComplaintTerms` in the INSIGHTS output to spot recurring problems fast.
- For fake review checks, `suspiciousSpikeMonths` in INSIGHTS flags months with three times the normal volume.
- To track reputation over time, schedule the run monthly with Apify's scheduler.

### FAQ

**Is scraping Trustpilot legal?**
Trustpilot is a public website. Scraping public, non-login data for research, competitive analysis, or your own use is generally fine in most places. Don't use this to collect personal data without a legal basis or to break Trustpilot's terms.

**Why are some fields empty?**
Trustpilot's page layout changes by company, region, and A/B test. The actor returns null for anything it can't find instead of crashing.

**I got fewer reviews than expected.**
Trustpilot may rate limit you. Raise `requestDelayMs` to 500 or 1000 and run again. The default datacenter proxy is usually enough. If you keep hitting 429s, switch on residential proxy, which needs a paid plan.

**Does it work in languages other than English?**
Yes. Drop the `languages` filter to get every language. The keyword extraction has stopword lists for English and German. Other languages still work, but the keyword lists may include more filler words.

**Issues or feature requests?**
Use the Issues tab on the actor page. Custom or white label setups are available on request.

# Actor input Schema

## `companyUrls` (type: `array`):

Trustpilot review page URLs or bare domains to scrape. Examples: 'pipedrive.com', 'https://www.trustpilot.com/review/airbnb.com'. One per line.

## `maxReviewsPerCompany` (type: `integer`):

Maximum number of reviews to scrape per company. Set to 0 for unlimited.

## `stars` (type: `array`):

Only return reviews with these star ratings. Leave empty for all ratings.

## `languages` (type: `array`):

Only return reviews in these languages (ISO 639-1 codes, e.g. 'en', 'de', 'fr'). Leave empty for all languages.

## `sort` (type: `string`):

Sort reviews by recency or relevance.

## `date` (type: `string`):

Only return reviews published within this time period.

## `verified` (type: `boolean`):

When true, only return verified reviews.

## `withReplies` (type: `boolean`):

When true, only return reviews that have a company reply.

## `includeCompanyInfo` (type: `boolean`):

Embed company trust score, total reviews, categories etc. in every output record.

## `generateInsights` (type: `boolean`):

Compute an analytics/insights report after scraping: rating trends, top complaint/praise keywords, response rate, suspicious spikes, and multi-company comparison. Written to key-value store as JSON (INSIGHTS) and HTML (REPORT).

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

Apify proxy settings. Datacenter proxy (default) works on the free plan.

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

Number of parallel page fetches per company.

## `requestDelayMs` (type: `integer`):

Milliseconds to wait between page fetches. Increase for polite crawling.

## `maxRunTimeSecs` (type: `integer`):

Internal run deadline. The actor will flush collected data and exit cleanly before this limit.

## Actor input object example

```json
{
  "companyUrls": [
    "pipedrive.com"
  ],
  "maxReviewsPerCompany": 40,
  "stars": [],
  "languages": [
    "en"
  ],
  "sort": "recency",
  "date": "",
  "verified": false,
  "withReplies": false,
  "includeCompanyInfo": true,
  "generateInsights": true,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "maxConcurrency": 5,
  "requestDelayMs": 300,
  "maxRunTimeSecs": 3000
}
```

# Actor output Schema

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

One row per Trustpilot review: rating, title, text, author, dates, verification, and company reply.

## `report` (type: `string`):

Ready-to-read report: rating trends, complaint and praise keywords, company response rate, suspicious spike detection, and a multi-company comparison.

## `insights` (type: `string`):

The full analytics object behind the report, machine-readable for your own pipelines.

# 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 = {
    "companyUrls": [
        "pipedrive.com"
    ],
    "maxReviewsPerCompany": 40,
    "languages": [
        "en"
    ],
    "generateInsights": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("berkaydev/trustpilot-insights-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 = {
    "companyUrls": ["pipedrive.com"],
    "maxReviewsPerCompany": 40,
    "languages": ["en"],
    "generateInsights": True,
}

# Run the Actor and wait for it to finish
run = client.actor("berkaydev/trustpilot-insights-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 '{
  "companyUrls": [
    "pipedrive.com"
  ],
  "maxReviewsPerCompany": 40,
  "languages": [
    "en"
  ],
  "generateInsights": true
}' |
apify call berkaydev/trustpilot-insights-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Reviews Scraper + Insights Report",
        "description": "Scrape Trustpilot reviews by domain and get raw review data PLUS a built-in insights report — rating trends, complaint/praise keywords, response rate, suspicious spike detection, and multi-company comparison. No API key needed. Pay per review scraped.",
        "version": "0.1",
        "x-build-id": "mmHtRR9mwmMvW6rm3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/berkaydev~trustpilot-insights-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-berkaydev-trustpilot-insights-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/berkaydev~trustpilot-insights-scraper/runs": {
            "post": {
                "operationId": "runs-sync-berkaydev-trustpilot-insights-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/berkaydev~trustpilot-insights-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-berkaydev-trustpilot-insights-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "companyUrls"
                ],
                "properties": {
                    "companyUrls": {
                        "title": "Company URLs / Domains",
                        "type": "array",
                        "description": "Trustpilot review page URLs or bare domains to scrape. Examples: 'pipedrive.com', 'https://www.trustpilot.com/review/airbnb.com'. One per line.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerCompany": {
                        "title": "Max reviews per company",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per company. Set to 0 for unlimited.",
                        "default": 0
                    },
                    "stars": {
                        "title": "Filter by star rating",
                        "type": "array",
                        "description": "Only return reviews with these star ratings. Leave empty for all ratings.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "1 star",
                                "2 stars",
                                "3 stars",
                                "4 stars",
                                "5 stars"
                            ]
                        },
                        "default": []
                    },
                    "languages": {
                        "title": "Filter by language (ISO codes)",
                        "type": "array",
                        "description": "Only return reviews in these languages (ISO 639-1 codes, e.g. 'en', 'de', 'fr'). Leave empty for all languages.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "recency",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Sort reviews by recency or relevance.",
                        "default": "recency"
                    },
                    "date": {
                        "title": "Date filter",
                        "enum": [
                            "",
                            "last30days",
                            "last3months",
                            "last6months",
                            "last12months"
                        ],
                        "type": "string",
                        "description": "Only return reviews published within this time period.",
                        "default": ""
                    },
                    "verified": {
                        "title": "Verified reviews only",
                        "type": "boolean",
                        "description": "When true, only return verified reviews.",
                        "default": false
                    },
                    "withReplies": {
                        "title": "Only reviews with company replies",
                        "type": "boolean",
                        "description": "When true, only return reviews that have a company reply.",
                        "default": false
                    },
                    "includeCompanyInfo": {
                        "title": "Include company info in each record",
                        "type": "boolean",
                        "description": "Embed company trust score, total reviews, categories etc. in every output record.",
                        "default": true
                    },
                    "generateInsights": {
                        "title": "Generate insights report",
                        "type": "boolean",
                        "description": "Compute an analytics/insights report after scraping: rating trends, top complaint/praise keywords, response rate, suspicious spikes, and multi-company comparison. Written to key-value store as JSON (INSIGHTS) and HTML (REPORT).",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy settings. Datacenter proxy (default) works on the free plan.",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max concurrent requests",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Number of parallel page fetches per company.",
                        "default": 5
                    },
                    "requestDelayMs": {
                        "title": "Delay between requests (ms)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Milliseconds to wait between page fetches. Increase for polite crawling.",
                        "default": 300
                    },
                    "maxRunTimeSecs": {
                        "title": "Max run time (seconds)",
                        "minimum": 60,
                        "maximum": 3500,
                        "type": "integer",
                        "description": "Internal run deadline. The actor will flush collected data and exit cleanly before this limit.",
                        "default": 3000
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```