# Trustpilot Scraper - Reviews, Ratings & Company Profiles \[PPR] (`zadexinho/trustpilot-scraper`) Actor

Extract Trustpilot reviews, ratings, company profiles, and reviewer data. Filter by stars, language, date, keyword search. Scrapes thousands of reviews in seconds. API access included.

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

## Pricing

from $0.25 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### Trustpilot Scraper

Trustpilot Scraper extracts reviews, star ratings, reviewer profiles, company trust scores, and business categories from Trustpilot.com. It accepts company domains, full Trustpilot URLs, or category URLs as input and returns structured JSON with review text, rating, language, verification status, experience date, reviewer name, reviewer country, company reply, and company statistics. Filter results by star rating, language, date range, keyword search, or verification status. Fast and lightweight — scrapes thousands of reviews in seconds, not minutes.

### What data can you extract?

| Field | Type | Description |
|-------|------|-------------|
| `reviewId` | string | Unique Trustpilot review ID |
| `title` | string | Review headline |
| `text` | string | Full review text |
| `rating` | integer | Star rating (1-5) |
| `language` | string | Review language code (en, de, fr, etc.) |
| `createdAt` | string | Publication date (ISO 8601) |
| `experienceDate` | string | Date of the experience described |
| `updatedAt` | string | Last edit date (null if never edited) |
| `isVerified` | boolean | Whether Trustpilot verified this review |
| `likes` | integer | Number of "useful" votes |
| `url` | string | Direct link to the review |
| `reviewer.name` | string | Reviewer display name |
| `reviewer.numberOfReviews` | integer | Total reviews by this reviewer |
| `reviewer.country` | string | Reviewer country code |
| `reviewer.profileUrl` | string | Link to reviewer profile |
| `company.name` | string | Company display name |
| `company.domain` | string | Company domain |
| `company.trustScore` | number | Trust Score (0-5) |
| `company.stars` | integer | Overall star rating (1-5) |
| `company.totalReviews` | integer | Total number of reviews |
| `company.categories` | string[] | Business categories |
| `company.profileUrl` | string | Link to company profile |
| `companyReply.text` | string | Company response text |
| `companyReply.createdAt` | string | Response date (ISO 8601) |

### How to scrape Trustpilot reviews

1. Enter one or more company domains in the **Companies** field (e.g., `apify.com`, `shopify.com`). Full Trustpilot URLs also work.
2. Set **Max Reviews Per Company** to control how many reviews to collect. Use `0` for all reviews.
3. Optionally apply filters — star rating, language, date range, or verified-only.
4. Click **Start** and wait for the run to complete.
5. Download results from the **Dataset** tab in JSON, CSV, or Excel format.

To discover companies in a specific industry, enter a Trustpilot category URL (e.g., `https://www.trustpilot.com/categories/electronics`) in the **Category URL** field. The scraper will find companies in that category and collect their reviews.

### How much does it cost?

This actor uses pay-per-event pricing. You are charged per review scraped.

| Tier | Price per review | Price per 1,000 reviews |
|------|-----------------|------------------------|
| FREE | $0.0004 | $0.40 |
| BRONZE | $0.00035 | $0.35 |
| SILVER | $0.0003 | $0.30 |
| GOLD | $0.00025 | $0.25 |

**Example:** Scraping 5,000 reviews on the FREE tier costs approximately $2.00.

Costs scale linearly with the number of reviews scraped. Company metadata and reviewer info are included at no extra charge.

### Use cases

- Monitor customer sentiment for your brand and competitors on Trustpilot.
- Aggregate reviews across an entire product category for market research.
- Feed review text into NLP or sentiment analysis pipelines.
- Track competitor review trends, response rates, and customer complaints.
- Find companies with declining ratings that need reputation management services.
- Collect review datasets for academic research on consumer behavior.
- Build dashboards that combine Trustpilot data with other review sources.
- Identify verified vs unverified review patterns across industries.
- Export review data to spreadsheets for client reporting.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `companies` | string[] | — | Company domains or Trustpilot URLs (required) |
| `categoryUrl` | string | — | Trustpilot category URL to discover companies |
| `maxReviewsPerCompany` | integer | `100` | Max reviews per company (0 = all) |
| `sort` | enum | `recency` | Sort order: `recency` or `relevance` |
| `search` | string | — | Filter reviews containing this keyword (e.g., "refund") |
| `aspects` | string[] | — | Filter reviews by topic aspects |
| `stars` | string[] | all | Filter by star rating: 1, 2, 3, 4, 5 |
| `languages` | string[] | all | Filter by language code (en, fr, de, es, etc.) |
| `dateRange` | enum | all time | Last 30 days, 3 months, 6 months, or 12 months |
| `verifiedOnly` | boolean | `false` | Only return verified reviews |
| `withRepliesOnly` | boolean | `false` | Only return reviews with company replies |
| `includeCompanyInfo` | boolean | `true` | Attach company data to each review |
| `includeReviewerInfo` | boolean | `true` | Attach reviewer data to each review |
| `startPage` | integer | `1` | Page to start from (for incremental scraping) |
| `requestDelay` | integer | `500` | Delay between requests in ms |
| `proxy` | object | off | Apify proxy configuration |

#### Input examples

**Single company:**
```json
{
    "companies": ["amazon.com"],
    "maxReviewsPerCompany": 50
}
````

**Multiple companies with filters:**

```json
{
    "companies": ["shopify.com", "stripe.com", "apify.com"],
    "maxReviewsPerCompany": 200,
    "sort": "recency",
    "stars": ["1", "2"],
    "languages": ["en"],
    "verifiedOnly": true
}
```

**Search within reviews:**

```json
{
    "companies": ["amazon.com"],
    "search": "refund",
    "maxReviewsPerCompany": 100
}
```

**Category discovery:**

```json
{
    "categoryUrl": "https://www.trustpilot.com/categories/electronics",
    "maxReviewsPerCompany": 20
}
```

### Output example

```json
{
    "reviewId": "69931ff615dc7667183d6b6f",
    "title": "Reliable automation backbone for n8n workflows",
    "text": "I'm using Apify as part of an automated newsletter pipeline built with n8n, and it's been consistently reliable...",
    "rating": 5,
    "language": "en",
    "createdAt": "2026-02-16T15:47:34.000Z",
    "experienceDate": "2026-01-27T00:00:00.000Z",
    "isVerified": false,
    "likes": 0,
    "url": "https://www.trustpilot.com/reviews/69931ff615dc7667183d6b6f",
    "reviewer": {
        "name": "Ortal Y",
        "numberOfReviews": 1,
        "country": "US",
        "profileUrl": "https://www.trustpilot.com/users/69931feed6c352e02e554935"
    },
    "company": {
        "name": "Apify",
        "domain": "apify.com",
        "trustScore": 4.8,
        "stars": 5,
        "totalReviews": 381,
        "categories": [
            "Online Marketplace",
            "Software Vendor",
            "Software Company"
        ],
        "profileUrl": "https://www.trustpilot.com/review/apify.com"
    }
}
```

### Tips

- Set `maxReviewsPerCompany` to `0` to scrape all reviews. Companies with 10,000+ reviews are supported — the scraper paginates automatically.
- Use `sort: "recency"` with `dateRange: "last30days"` to monitor recent feedback.
- Use `stars: ["1", "2"]` to focus on negative reviews for reputation tracking.
- Use `verifiedOnly: true` when you need higher-confidence review data.
- Use `search` to filter reviews by keyword (e.g., "shipping", "refund", "customer service").
- Use `startPage` for incremental scraping — skip pages you already have from a previous run.
- Use `categoryUrl` to discover and scrape all companies in a Trustpilot category without knowing their domains in advance.
- Increase `requestDelay` to `1000` or higher if you encounter rate limiting on large runs.
- Enable Apify proxy for large runs (10,000+ reviews) if you experience rate limiting.

### FAQ

#### How many reviews can I scrape?

There is no hard limit. Set `maxReviewsPerCompany` to `0` to collect all reviews. The scraper paginates through all available pages automatically.

#### How fast is it?

Scraping 100 reviews typically takes under 10 seconds. Larger runs (10,000+ reviews) scale linearly. Concurrent pagination keeps batch runs efficient.

#### Do I need a proxy?

For most runs, no. If you are scraping tens of thousands of reviews or experience rate limiting, enable Apify proxy in the Advanced settings.

#### What happens if a company is not on Trustpilot?

The scraper logs a warning and moves to the next company. It does not fail the entire run.

#### Can I search within reviews?

Yes. Use the `search` field to filter reviews by keyword (e.g., "refund", "shipping", "customer service"). Only reviews containing the keyword are returned.

### Changelog

- **v0.1.8** — Search query filter, aspects filter, start page, concurrent pagination, circuit breaker, AIMD rate limiting.
- **v0.1.6** — Input validation, per-company timeouts, 403 handling, dedup, inline filter application.
- **v0.1** — Initial release. Reviews, company data, reviewer profiles, category browsing, star/language/date filters.

# Actor input Schema

## `companies` (type: `array`):

Add company domains (e.g., apify.com, shopify.com) or full Trustpilot URLs. One per entry.

## `categoryUrl` (type: `string`):

Enter a Trustpilot category URL to discover and scrape all companies in that category (e.g., https://www.trustpilot.com/categories/electronics).

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

Set the maximum number of reviews to scrape per company. Use 0 for unlimited.

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

Select how reviews are sorted.

## `search` (type: `string`):

Filter reviews containing this keyword (e.g., 'shipping', 'refund', 'customer service').

## `aspects` (type: `array`):

Filter reviews by topic aspects. Enter Trustpilot aspect identifiers.

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

Select star ratings to include. Leave empty for all ratings.

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

Enter language codes to filter reviews (e.g., en, fr, de, es). Leave empty for all languages.

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

Select a time period to filter reviews.

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

Return only reviews marked as verified by Trustpilot.

## `withRepliesOnly` (type: `boolean`):

Return only reviews that have a reply from the company.

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

Attach company metadata (name, trust score, total reviews, categories) to each review.

## `includeReviewerInfo` (type: `boolean`):

Attach reviewer metadata (display name, country, review count) to each review.

## `startPage` (type: `integer`):

Page number to start scraping from. Use for incremental scraping (e.g., start from page 5 if you already have pages 1-4).

## `requestDelay` (type: `integer`):

Set the delay between HTTP requests in milliseconds. Increase to 1000+ if you experience rate limiting.

## `proxy` (type: `object`):

Configure proxy settings. Not required for most use cases — the scraper works without proxies.

## Actor input object example

```json
{
  "companies": [
    "apify.com"
  ],
  "maxReviewsPerCompany": 100,
  "sort": "recency",
  "dateRange": "",
  "verifiedOnly": false,
  "withRepliesOnly": false,
  "includeCompanyInfo": true,
  "includeReviewerInfo": true,
  "startPage": 1,
  "requestDelay": 500,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "companies": [
        "apify.com"
    ],
    "maxReviewsPerCompany": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("zadexinho/trustpilot-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 = {
    "companies": ["apify.com"],
    "maxReviewsPerCompany": 100,
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Scraper - Reviews, Ratings & Company Profiles [PPR]",
        "description": "Extract Trustpilot reviews, ratings, company profiles, and reviewer data. Filter by stars, language, date, keyword search. Scrapes thousands of reviews in seconds. API access included.",
        "version": "0.1",
        "x-build-id": "AmsdFkegFhVC8FuQt"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/zadexinho~trustpilot-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-zadexinho-trustpilot-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/zadexinho~trustpilot-scraper/runs": {
            "post": {
                "operationId": "runs-sync-zadexinho-trustpilot-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/zadexinho~trustpilot-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-zadexinho-trustpilot-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "companies": {
                        "title": "Company Domains or URLs",
                        "type": "array",
                        "description": "Add company domains (e.g., apify.com, shopify.com) or full Trustpilot URLs. One per entry.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryUrl": {
                        "title": "Category URL",
                        "type": "string",
                        "description": "Enter a Trustpilot category URL to discover and scrape all companies in that category (e.g., https://www.trustpilot.com/categories/electronics)."
                    },
                    "maxReviewsPerCompany": {
                        "title": "Max Reviews Per Company",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Set the maximum number of reviews to scrape per company. Use 0 for unlimited.",
                        "default": 100
                    },
                    "sort": {
                        "title": "Sort Order",
                        "enum": [
                            "recency",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Select how reviews are sorted.",
                        "default": "recency"
                    },
                    "search": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Filter reviews containing this keyword (e.g., 'shipping', 'refund', 'customer service')."
                    },
                    "aspects": {
                        "title": "Aspects / Topics",
                        "type": "array",
                        "description": "Filter reviews by topic aspects. Enter Trustpilot aspect identifiers.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "stars": {
                        "title": "Star Rating Filter",
                        "type": "array",
                        "description": "Select star ratings to include. 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"
                            ]
                        }
                    },
                    "languages": {
                        "title": "Language Filter",
                        "type": "array",
                        "description": "Enter language codes to filter reviews (e.g., en, fr, de, es). Leave empty for all languages.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dateRange": {
                        "title": "Date Range",
                        "enum": [
                            "",
                            "last30days",
                            "last3months",
                            "last6months",
                            "last12months"
                        ],
                        "type": "string",
                        "description": "Select a time period to filter reviews.",
                        "default": ""
                    },
                    "verifiedOnly": {
                        "title": "Verified Reviews Only",
                        "type": "boolean",
                        "description": "Return only reviews marked as verified by Trustpilot.",
                        "default": false
                    },
                    "withRepliesOnly": {
                        "title": "With Company Replies Only",
                        "type": "boolean",
                        "description": "Return only reviews that have a reply from the company.",
                        "default": false
                    },
                    "includeCompanyInfo": {
                        "title": "Include Company Info",
                        "type": "boolean",
                        "description": "Attach company metadata (name, trust score, total reviews, categories) to each review.",
                        "default": true
                    },
                    "includeReviewerInfo": {
                        "title": "Include Reviewer Info",
                        "type": "boolean",
                        "description": "Attach reviewer metadata (display name, country, review count) to each review.",
                        "default": true
                    },
                    "startPage": {
                        "title": "Start Page",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Page number to start scraping from. Use for incremental scraping (e.g., start from page 5 if you already have pages 1-4).",
                        "default": 1
                    },
                    "requestDelay": {
                        "title": "Request Delay (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Set the delay between HTTP requests in milliseconds. Increase to 1000+ if you experience rate limiting.",
                        "default": 500
                    },
                    "proxy": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Configure proxy settings. Not required for most use cases — the scraper works without proxies.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
