# Trustpilot Review Scraper (`sourabhbgp/trustpilot-review-scraper`) Actor

Pulls every public Trustpilot review for a company, not just the first 200. Up to 5,000 reviews per brand in about 2 minutes. Every language, every star rating, with business replies and company details on each row. $0.50 per 1,000 reviews.

- **URL**: https://apify.com/sourabhbgp/trustpilot-review-scraper.md
- **Developed by:** [Sourabh Kumar](https://apify.com/sourabhbgp) (community)
- **Categories:** E-commerce, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 reviews

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

### Trustpilot Review Scraper | Bypass 200 limit · $0.50/1k

Pulls every public Trustpilot review for a company, not just the first 200. Up to 5,000 reviews per brand in about 2 minutes. Every language, every star rating, with business replies and company details on each row. Archive goes back to 2007 on long-tenured brands like Amazon and Booking. **$0.50 per 1,000 reviews. $0.007 per run. No proxy, no browser config.**

Works on every Trustpilot company page: `amazon.com`, `booking.com`, `airbnb.com`, multilingual brands and small shops alike.

### Why this scraper

- 💰 **$0.50 per 1,000 reviews.** Flat per-row pricing. No tiers, no add-on flags.
- 🧱 **Up to ~5,000 unique reviews per brand**, not the ~1,000 cap a single Trustpilot query hits. The actor slices by language and star rating to push past that ceiling.
- 🌐 **Every language without config.** German, French, Italian, Dutch, Spanish, Danish, Polish, Portuguese, Swedish, Russian. Auto-discovered per company.
- 📅 **Full archive depth.** Reviews going back to 2007 on long-tenured brands, not just the recent window.
- 💬 **Business replies, company block, and canonical review URL on every row.** No paid add-ons.
- 📦 **Flat output schema.** 27 top-level fields. Ready for Sheets, BigQuery, or pandas with no nested objects to unpack.
- ⚡ **Concurrent by default.** Up to 24 parallel fetches with memory-aware autoscaling.
- 🛒 **Every Trustpilot filter exposed:** stars, languages, date range, sort, keyword search, verified-only, replies-only, topics.

### What you get

Per scraped review:

<table>
  <tr><td>⭐ Star rating</td><td>📝 Title + full review text</td><td>🌐 Language</td><td>📅 Published + experienced dates</td></tr>
  <tr><td>👤 Reviewer name + country</td><td>✅ Verification status</td><td>💬 Business reply + reply date</td><td>👍 Like count</td></tr>
  <tr><td>🔗 Review URL</td><td>🏢 Company name + domain + ID</td><td>🪪 Reviewer ID + review count</td><td>🕐 Scraped-at timestamp</td></tr>
</table>

### How to scrape Trustpilot reviews

1. [Create a free Apify account](https://console.apify.com/sign-up). 30 seconds, no card needed.
2. Open [Trustpilot Review Scraper](https://console.apify.com/actors/I1AVyGxHUKugnsBcI?addFromActorId=I1AVyGxHUKugnsBcI) in the Apify Console.
3. Paste one or more company URLs or bare domains (e.g. `nike.com`) and pick any filters you need.
4. Click **Start**. Single-brand runs typically finish in 30 seconds to 2 minutes.
5. Export as JSON, CSV, or Excel, or pull via the Apify API.

### How much does it cost

Pay-per-result pricing.

- Per 1,000 reviews: **$0.50**
- Free plan ($5/month credit): roughly **10,000 reviews/month**
- Starter plan ($29/month): about **58,000 reviews/month**
- Per-run start fee: **$0.007**

No subscription lock-in.

### Input

```json
{
  "urls": ["amazon.com", "booking.com"],
  "maxReviewsPerCompany": 1000,
  "stars": [],
  "languages": [],
  "dateRange": "all",
  "sort": "recency",
  "verifiedOnly": false,
  "repliesOnly": false,
  "keyword": "",
  "topics": []
}
````

| Field | Default | Notes |
|---|---|---|
| `urls` | required | Trustpilot URLs or bare domains. |
| `maxReviewsPerCompany` | 1000 | Upper bound. Up to 20000 (~$10/company at the cap). |
| `stars` | `[]` (all) | Filter to e.g. `[4, 5]` for positive reviews only. |
| `languages` | `[]` (all) | ISO codes like `["en", "de", "fr"]`. Empty = every language present. |
| `dateRange` | `all` | One of `all`, `last30days`, `last3months`, `last6months`, `last12months`. |
| `sort` | `recency` | Or `relevance` (Trustpilot's "Most relevant" ordering). |
| `verifiedOnly` | `false` | Only verified reviews. |
| `repliesOnly` | `false` | Only reviews where the business has replied. |
| `keyword` | none | Free-text search across title and body. |
| `topics` | `[]` | Restrict to topic tags like `delivery_service`, `customer_service`, `refund`. |
| `startDate` | none | YYYY-MM-DD chronological cutoff. |

### Output

```json
{
  "reviewId": "6a0146e9fd08f1a74a54c371",
  "companyDomain": "www.amazon.com",
  "companyName": "Amazon",
  "companyId": "46ad346800006400050092d0",
  "title": "Puerile experience with amazon.com",
  "text": "Namaskar : I have been buying from amazon.com just around when they started out...",
  "rating": 2,
  "language": "en",
  "publishedDate": "2026-05-11T05:03:05.000Z",
  "experiencedDate": "2026-05-08T00:00:00.000Z",
  "updatedDate": "2026-05-11T07:28:58.000Z",
  "reviewUrl": "https://www.trustpilot.com/reviews/6a0146e9fd08f1a74a54c371",
  "source": "Organic",
  "isVerified": false,
  "verificationLevel": "not-verified",
  "likes": 0,
  "reviewerName": "Deoanand Geer",
  "reviewerId": "6998b80cb2781e2120331443",
  "reviewerCountry": "GY",
  "reviewerReviewCount": 2,
  "reviewerImageUrl": "https://user-images.trustpilot.com/.../73x73.png",
  "replyText": null,
  "replyDate": null,
  "replyUpdatedDate": null,
  "scrapedAt": "2026-05-11T10:02:19.536Z"
}
```

### Use cases

- 📊 **Brand sentiment tracking.** Monitor how a brand is perceived across markets and over time.
- 🔍 **Competitor benchmarking.** Compare review volume, average rating, and reply rate between competitors.
- 🌍 **Multilingual customer feedback.** Pull non-English reviews most scrapers skip: German, French, Italian, Dutch, and more.
- 🎯 **Targeted analysis.** Filter to 1-star or 5-star reviews to study churn drivers or fan reasons separately.
- 🤖 **LLM training data.** Long-form, structured customer-voice content for fine-tuning or RAG.
- 🔄 **Daily/weekly tracking.** Run on a schedule and feed deltas into BI or alerting.

### Limitations

- **~5,000 unique reviews per company is the practical ceiling** on the largest multilingual brands. Trustpilot caps each filter combination at 200 reviews; the actor squeezes the maximum by slicing across stars and languages, but the math eventually plateaus. Monolingual brands (one-language pools) cap around 1,000.
- **No private reviews or reviewer PII.** Public reviews only. No emails, phone numbers, or non-public profile data.
- **Date filters use Trustpilot's coarse buckets.** Server-side filtering is limited to last 30 days, 3, 6, or 12 months. For finer ranges, use the `startDate` field which filters client-side.
- **`repliesOnly` is honored but not always restrictive.** Trustpilot's server-side reply filter has known inconsistencies; expect occasional reviews without replies to slip through.

### FAQ

#### How much does it cost?

Pay-per-result pricing. You pay **$0.50 for 1,000 reviews** plus $0.007 per run. The Apify Free plan gives you $5 in usage credits a month, about 10,000 reviews. If you run regularly, the $29/month Starter plan covers about 58,000 reviews.

No subscription lock-in. Pause whenever.

#### Is it legal to scrape Trustpilot?

Scraping public data is generally allowed in the US and most of the EU, as long as you don't collect personal data covered by GDPR or CCPA without a lawful basis. This actor only touches publicly accessible review pages, but how you use the output is on you.

Apify's full breakdown: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/).

#### Can I integrate with other tools?

Push results into **Make, Zapier, Slack, Airbyte, GitHub, Google Sheets, Google Drive**, and more. Apify treats every actor as a webhook source, so anything that consumes webhooks or pulls from an API works.

Full list: [Apify integrations](https://docs.apify.com/platform/integrations).

#### Can I use the Apify API?

Yes. Every run is available via the Apify REST API:

```bash
curl -X POST "https://api.apify.com/v2/acts/sourabhbgp~trustpilot-review-scraper/runs?token=APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"urls": ["amazon.com"], "maxReviewsPerCompany": 1000}'
```

Docs: [Apify API reference](https://docs.apify.com/api/v2).

#### Can I use it through an MCP Server?

Yes. Apify ships an MCP server that exposes every actor as a tool, so Claude Desktop, Cursor, and any other MCP-capable client can call this scraper. Setup: [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp).

### Your feedback

Bug, missing field, or odd behavior? Drop a note in the [Issues tab](https://console.apify.com/actors/I1AVyGxHUKugnsBcI/issues). Reports go to a human and fixes usually ship the same week.

# Actor input Schema

## `urls` (type: `array`):

Trustpilot company URLs or domain names. Examples: 'amazon.com', 'https://www.trustpilot.com/review/booking.com', 'www.netflix.com'.

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

Upper bound per company. Stops slicing once reached.

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

Filter to specific star ratings. Empty = all 1-5.

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

ISO codes (e.g. \['en', 'de', 'fr', 'es', 'it', 'nl']). Empty = every language present on the company page.

## `dateRange` (type: `string`):

Server-side date filter. Limited to Trustpilot's predefined buckets.

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

How Trustpilot orders the 200-review window for each filter combo.

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

Only return reviews Trustpilot has verified.

## `repliesOnly` (type: `boolean`):

Only return reviews where the business has posted a reply.

## `keyword` (type: `string`):

Free-text search across review title + body (matches Trustpilot's 'Search by keyword' input on the company page).

## `topics` (type: `array`):

Restrict to reviews tagged with one or more Trustpilot topics (e.g. 'delivery\_service', 'customer\_service', 'refund', 'product'). Topic IDs vary per company; check the website filter dropdown.

## `startDate` (type: `string`):

Client-side cutoff. Skip reviews published before this date. Use for chronological filtering beyond Trustpilot's coarse buckets.

## `minConcurrency` (type: `integer`):

Lower bound on parallel requests. Crawlee's autoscaler stays at least this high.

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

Upper bound on parallel requests across all companies + slices. Default 24 = roughly equivalent to 4 companies × 6 slices.

## `minSliceCount` (type: `integer`):

Skip (language, stars) slices estimated to have fewer reviews than this.

## Actor input object example

```json
{
  "urls": [
    "amazon.com",
    "booking.com"
  ],
  "maxReviewsPerCompany": 1000,
  "stars": [],
  "languages": [],
  "dateRange": "all",
  "sort": "recency",
  "verifiedOnly": false,
  "repliesOnly": false,
  "topics": [],
  "minConcurrency": 4,
  "maxConcurrency": 24,
  "minSliceCount": 10
}
```

# Actor output Schema

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

Full Trustpilot review records with star rating, text, reviewer profile, business reply, language, and company block.

# 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 = {
    "urls": [
        "amazon.com",
        "booking.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sourabhbgp/trustpilot-review-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 = { "urls": [
        "amazon.com",
        "booking.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("sourabhbgp/trustpilot-review-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 '{
  "urls": [
    "amazon.com",
    "booking.com"
  ]
}' |
apify call sourabhbgp/trustpilot-review-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Review Scraper",
        "description": "Pulls every public Trustpilot review for a company, not just the first 200. Up to 5,000 reviews per brand in about 2 minutes. Every language, every star rating, with business replies and company details on each row. $0.50 per 1,000 reviews.",
        "version": "0.1",
        "x-build-id": "gmprACvHp3PVsjCP3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sourabhbgp~trustpilot-review-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sourabhbgp-trustpilot-review-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/sourabhbgp~trustpilot-review-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sourabhbgp-trustpilot-review-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/sourabhbgp~trustpilot-review-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sourabhbgp-trustpilot-review-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": [
                    "urls"
                ],
                "properties": {
                    "urls": {
                        "title": "Company URLs or Domains",
                        "minItems": 1,
                        "type": "array",
                        "description": "Trustpilot company URLs or domain names. Examples: 'amazon.com', 'https://www.trustpilot.com/review/booking.com', 'www.netflix.com'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerCompany": {
                        "title": "Max Reviews per Company",
                        "minimum": 1,
                        "maximum": 20000,
                        "type": "integer",
                        "description": "Upper bound per company. Stops slicing once reached.",
                        "default": 1000
                    },
                    "stars": {
                        "title": "Star Ratings",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Filter to specific star ratings. Empty = all 1-5.",
                        "items": {
                            "type": "integer",
                            "minimum": 1,
                            "maximum": 5
                        },
                        "default": []
                    },
                    "languages": {
                        "title": "Languages",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "ISO codes (e.g. ['en', 'de', 'fr', 'es', 'it', 'nl']). Empty = every language present on the company page.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "dateRange": {
                        "title": "Published Within",
                        "enum": [
                            "all",
                            "last30days",
                            "last3months",
                            "last6months",
                            "last12months"
                        ],
                        "type": "string",
                        "description": "Server-side date filter. Limited to Trustpilot's predefined buckets.",
                        "default": "all"
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "recency",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "How Trustpilot orders the 200-review window for each filter combo.",
                        "default": "recency"
                    },
                    "verifiedOnly": {
                        "title": "Verified Reviews Only",
                        "type": "boolean",
                        "description": "Only return reviews Trustpilot has verified.",
                        "default": false
                    },
                    "repliesOnly": {
                        "title": "Reviews with Company Reply Only",
                        "type": "boolean",
                        "description": "Only return reviews where the business has posted a reply.",
                        "default": false
                    },
                    "keyword": {
                        "title": "Search by Keyword",
                        "type": "string",
                        "description": "Free-text search across review title + body (matches Trustpilot's 'Search by keyword' input on the company page)."
                    },
                    "topics": {
                        "title": "Topics",
                        "type": "array",
                        "description": "Restrict to reviews tagged with one or more Trustpilot topics (e.g. 'delivery_service', 'customer_service', 'refund', 'product'). Topic IDs vary per company; check the website filter dropdown.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startDate": {
                        "title": "Start Date Cutoff (YYYY-MM-DD)",
                        "type": "string",
                        "description": "Client-side cutoff. Skip reviews published before this date. Use for chronological filtering beyond Trustpilot's coarse buckets."
                    },
                    "minConcurrency": {
                        "title": "Min Concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Lower bound on parallel requests. Crawlee's autoscaler stays at least this high.",
                        "default": 4
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Upper bound on parallel requests across all companies + slices. Default 24 = roughly equivalent to 4 companies × 6 slices.",
                        "default": 24
                    },
                    "minSliceCount": {
                        "title": "Min Slice Size to Schedule",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Skip (language, stars) slices estimated to have fewer reviews than this.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```