# Trustpilot Reviews Scraper (`fetch_cat/trustpilot-reviews-scraper`) Actor

Extract public Trustpilot reviews, star ratings, reviewer metadata, and business replies for reputation monitoring and competitor analysis.

- **URL**: https://apify.com/fetch\_cat/trustpilot-reviews-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.11 / 1,000 review extracteds

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 Reviews Scraper

Extract public Trustpilot company reviews, star ratings, reviewer metadata, and visible business replies for reputation monitoring, CX analysis, and competitor benchmarking.

Use this actor when you need a repeatable export of public Trustpilot review pages without manually clicking through filters and pagination.

---

### What does Trustpilot Reviews Scraper do?

Trustpilot Reviews Scraper collects public review rows from Trustpilot company review pages.

It accepts Trustpilot review URLs such as `https://www.trustpilot.com/review/www.amazon.com` and plain company domains such as `example.com`.

For each saved review, the dataset includes company context, review text, rating, reviewer metadata, filter context, and the timestamp of the scrape.

### Who is it for?

- Reputation managers tracking new complaints and praise.
- Customer experience teams measuring public sentiment over time.
- Agencies monitoring multiple client brands.
- Market researchers comparing competitors in one category.
- Support leaders auditing whether public business replies are being posted.
- BI teams feeding Trustpilot reviews into dashboards or warehouses.

### Why use this Trustpilot review extractor?

Manual review exports are slow and inconsistent.

This actor gives you structured rows that are ready for CSV, JSON, Excel, Google Sheets, BigQuery, Snowflake, or your own API workflow.

You can run small tests with a few reviews or schedule recurring runs to keep a public review history.

### What Trustpilot data can you extract?

| Field | Description |
| --- | --- |
| `companyUrl` | Trustpilot company review page URL |
| `companyDomain` | Domain from the Trustpilot review page |
| `companyName` | Company name shown on Trustpilot |
| `trustScore` | Trustpilot score visible on the page |
| `companyRatingText` | Rating text shown near the company profile |
| `totalReviewCount` | Public review count shown by Trustpilot |
| `reviewId` | Stable review identifier from the review URL |
| `reviewUrl` | Direct public Trustpilot review URL |
| `reviewTitle` | Review headline |
| `reviewText` | Review body text |
| `rating` | Star rating from 1 to 5 |
| `publishedDate` | Published date when visible |
| `experienceDate` | Date of experience when visible |
| `reviewerName` | Public reviewer display name |
| `reviewerCountry` | Public country code when visible |
| `reviewerReviewCount` | Public review count for the reviewer when visible |
| `isVerified` | Verification marker when visible |
| `replyText` | Visible business reply text |
| `replyDate` | Visible business reply date |
| `replyAuthor` | Visible reply author/company text |
| `language` | Page language context when available |
| `starsFilter` | Star filter used for this row |
| `page` | Trustpilot listing page number |
| `scrapedAt` | ISO timestamp when the row was saved |

### How much does it cost to scrape Trustpilot reviews?

This actor uses pay-per-event pricing.

You pay a `$0.025` run-start event and then a per-review event for every saved Trustpilot review.

| Apify plan tier | Price per review | Approx. price per 1,000 reviews |
| --- | ---: | ---: |
| Free | `$0.0040395` | `$4.04` |
| Bronze | `$0.0035126` | `$3.51` |
| Silver | `$0.0027398` | `$2.74` |
| Gold | `$0.0021075` | `$2.11` |
| Platinum | `$0.001405` | `$1.41` |
| Diamond | `$0.00098352` | `$0.98` |

For cost-efficient tests, start with `maxReviewsPerCompany` set to 5 or 20.

### How to scrape Trustpilot reviews

1. Open the actor input.
2. Add one or more Trustpilot review URLs or company domains.
3. Set `maxReviewsPerCompany`.
4. Optionally choose star filters such as `1` or `5`.
5. Choose sorting, usually `recency`.
6. Keep proxy enabled for reliable public page access.
7. Run the actor.
8. Download results from the Dataset tab.

### Input example

```json
{
  "startUrls": [
    { "url": "https://www.trustpilot.com/review/www.amazon.com" }
  ],
  "maxReviewsPerCompany": 20,
  "stars": [1, 2],
  "sort": "recency",
  "languages": ["all"],
  "includeReplies": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

### Input fields

#### `startUrls`

Trustpilot company review URLs or plain domains.

Examples:

- `https://www.trustpilot.com/review/www.amazon.com`
- `https://www.trustpilot.com/review/example.com`
- `example.com`

#### `maxReviewsPerCompany`

Maximum reviews to save for each company.

Use a low number for tests and increase it for production exports.

#### `stars`

Optional list of star ratings from 1 to 5.

Leave empty to use the default Trustpilot listing.

#### `sort`

Choose `recency` for newest reviews first or `relevance` for Trustpilot's default ordering.

#### `languages`

Optional language filters such as `en`, `de`, `fr`, or `all`.

Leave empty for the default page view.

#### `includeReplies`

Set to `true` to capture business reply fields when Trustpilot shows them.

#### `proxyConfiguration`

Trustpilot can show browser verification pages.

Apify residential proxy is recommended for reliable runs.

### Output example

```json
{
  "companyUrl": "https://www.trustpilot.com/review/www.amazon.com",
  "companyDomain": "www.amazon.com",
  "companyName": "Amazon",
  "trustScore": 1.7,
  "companyRatingText": "1.7",
  "totalReviewCount": 46811,
  "reviewId": "6a397b742e352367592b4d66",
  "reviewUrl": "https://www.trustpilot.com/reviews/6a397b742e352367592b4d66",
  "reviewTitle": "Amazon's customer service is the absolute worst.",
  "reviewText": "Amazon's customer service is the absolute worst...",
  "rating": 1,
  "publishedDate": null,
  "experienceDate": null,
  "reviewerName": "frank kadar",
  "reviewerCountry": null,
  "reviewerReviewCount": 1,
  "isVerified": null,
  "replyText": null,
  "replyDate": null,
  "replyAuthor": null,
  "language": null,
  "starsFilter": 1,
  "page": 1,
  "scrapedAt": "2026-06-22T23:55:01.203Z"
}
```

### Tips for better Trustpilot scraping

- Test one company first.
- Use `recency` when monitoring fresh complaints.
- Use `stars: [1, 2]` for complaint triage.
- Use `stars: [4, 5]` for positive testimonial discovery.
- Keep `maxReviewsPerCompany` low for scheduled daily monitoring.
- Increase volume only after confirming the output format fits your workflow.

### Common workflows

#### Reputation monitoring

Run the actor every day for your own brand and save the dataset to a warehouse.

Compare `scrapedAt`, `rating`, and `reviewText` to find new issues.

#### Complaint triage

Use `stars: [1, 2]` and `sort: "recency"`.

Send new low-rated reviews to a support queue.

#### Competitor benchmarking

Add multiple competitor company pages.

Group output by `companyDomain`, `rating`, and `publishedDate`.

#### Reply coverage audit

Keep `includeReplies` enabled.

Measure which public reviews have `replyText` and how quickly replies appear.

### Integrations

You can connect the dataset to:

- Google Sheets for quick review tracking.
- Slack alerts through Apify integrations.
- Make or Zapier automations.
- BigQuery or Snowflake via dataset export.
- A CRM or support platform through webhooks.
- A BI dashboard that monitors public review sentiment.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('fetch_cat/trustpilot-reviews-scraper').call({
  startUrls: [{ url: 'https://www.trustpilot.com/review/www.amazon.com' }],
  maxReviewsPerCompany: 20,
  sort: 'recency',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])

run = client.actor('fetch_cat/trustpilot-reviews-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.trustpilot.com/review/www.amazon.com'}],
    'maxReviewsPerCompany': 20,
    'sort': 'recency',
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~trustpilot-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{
    "startUrls": [{"url": "https://www.trustpilot.com/review/www.amazon.com"}],
    "maxReviewsPerCompany": 20,
    "sort": "recency"
  }'
```

### MCP and AI agent usage

Use the Apify MCP server to let Claude Desktop, Claude Code, or another agent run this actor as part of an analysis workflow.

MCP URL pattern:

```text
https://mcp.apify.com/?tools=fetch_cat/trustpilot-reviews-scraper
```

Claude Code setup command:

```bash
claude mcp add apify-trustpilot "https://mcp.apify.com/?tools=fetch_cat/trustpilot-reviews-scraper"
```

Claude Desktop JSON config example:

```json
{
  "mcpServers": {
    "apify-trustpilot": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/trustpilot-reviews-scraper"
    }
  }
}
```

Example prompts:

- "Run Trustpilot Reviews Scraper for this company and summarize the top complaint themes."
- "Export the newest 1-star Trustpilot reviews for these competitors."
- "Compare review ratings across these three Trustpilot company pages."

### Scheduling

For monitoring workflows, schedule a small recurring run.

Daily runs with `sort: "recency"` and a low `maxReviewsPerCompany` are usually enough to catch new public reviews.

### Limits and reliability

Trustpilot may show browser verification pages or change page markup.

The actor is designed to wait through visible verification and continue when public review cards are available.

If a company has fewer reviews than requested, the actor saves the reviews it can see and stops when no new reviews are found.

### Troubleshooting

#### The run returned fewer reviews than requested

The company may have fewer public reviews for the selected filters, or Trustpilot may stop exposing additional pages for that filter branch.

Try reducing filters or running without a star filter.

#### I see missing optional fields

Some Trustpilot reviews do not show every field.

For example, business replies, experience dates, countries, and verification markers are optional public-page elements.

#### The run is slow

Browser verification and residential proxy routing can add latency.

Use smaller test runs first, then scale up once the output looks correct.

### Legality and responsible use

This actor extracts publicly visible Trustpilot review pages.

Do not use it to collect private data, bypass authentication, spam reviewers, or violate applicable laws.

Always review Trustpilot's terms, your local regulations, and your organization's data policies before using scraped data.

### Related actors

Explore other public-data scrapers from the same Apify account:

- Google Maps Reviews Scraper: `https://apify.com/fetch_cat/google-maps-reviews-scraper`
- Google Play Reviews Scraper: `https://apify.com/fetch_cat/google-play-reviews-scraper`
- Apple App Store Reviews Scraper: `https://apify.com/fetch_cat/apple-app-store-reviews-scraper`

### FAQ

#### Can I scrape multiple Trustpilot companies in one run?

Yes. Add multiple URLs or domains to `startUrls`.

#### Can I scrape only 1-star reviews?

Yes. Set `stars` to `[1]`.

#### Can I capture business replies?

Yes. Keep `includeReplies` set to `true`. Reply fields are filled when a visible reply exists on the public page.

#### Can I use domains instead of Trustpilot URLs?

Yes. The actor converts a plain domain such as `example.com` into the matching Trustpilot review URL.

#### Can I export to CSV?

Yes. Use the Apify Dataset export options after the run finishes.

#### Is this actor for private Trustpilot accounts?

No. It is for public Trustpilot company review pages only.

# Actor input Schema

## `startUrls` (type: `array`):

Trustpilot review pages (https://www.trustpilot.com/review/example.com) or plain company domains (example.com).

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

Optional plain company domains such as example.com. Use this when you do not have the Trustpilot URL yet.

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

Maximum number of reviews to save for each company. Use a low number for test runs.

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

Optional star ratings to scrape. Leave empty to scrape the default Trustpilot listing.

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

Sort reviews by recency or Trustpilot's default relevance order.

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

Optional Trustpilot language filters such as en, de, fr, or all. Leave empty for default page language.

## `includeReplies` (type: `boolean`):

Capture visible company reply text, date, and author when Trustpilot shows a reply.

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

Optional proxy settings. The default run starts without proxy to avoid unnecessary residential bandwidth; enable Residential proxy if Trustpilot blocks your run.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.trustpilot.com/review/www.amazon.com"
    }
  ],
  "companyUrls": [],
  "maxReviewsPerCompany": 20,
  "stars": [],
  "sort": "recency",
  "languages": [],
  "includeReplies": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "startUrls": [
        {
            "url": "https://www.trustpilot.com/review/www.amazon.com"
        }
    ],
    "companyUrls": [],
    "stars": [],
    "languages": [],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/trustpilot-reviews-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 = {
    "startUrls": [{ "url": "https://www.trustpilot.com/review/www.amazon.com" }],
    "companyUrls": [],
    "stars": [],
    "languages": [],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/trustpilot-reviews-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 '{
  "startUrls": [
    {
      "url": "https://www.trustpilot.com/review/www.amazon.com"
    }
  ],
  "companyUrls": [],
  "stars": [],
  "languages": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fetch_cat/trustpilot-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Reviews Scraper",
        "description": "Extract public Trustpilot reviews, star ratings, reviewer metadata, and business replies for reputation monitoring and competitor analysis.",
        "version": "0.1",
        "x-build-id": "iPiIEjWoRwn3m9KZY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~trustpilot-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-trustpilot-reviews-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/fetch_cat~trustpilot-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-trustpilot-reviews-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/fetch_cat~trustpilot-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-trustpilot-reviews-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": {
                    "startUrls": {
                        "title": "Trustpilot company URLs or domains",
                        "type": "array",
                        "description": "Trustpilot review pages (https://www.trustpilot.com/review/example.com) or plain company domains (example.com).",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "companyUrls": {
                        "title": "Company domains",
                        "type": "array",
                        "description": "Optional plain company domains such as example.com. Use this when you do not have the Trustpilot URL yet.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerCompany": {
                        "title": "Maximum reviews per company",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of reviews to save for each company. Use a low number for test runs.",
                        "default": 20
                    },
                    "stars": {
                        "title": "Star ratings",
                        "type": "array",
                        "description": "Optional star ratings to scrape. Leave empty to scrape the default Trustpilot listing.",
                        "items": {
                            "type": "integer",
                            "minimum": 1,
                            "maximum": 5
                        }
                    },
                    "sort": {
                        "title": "Sort order",
                        "enum": [
                            "recency",
                            "relevance"
                        ],
                        "type": "string",
                        "description": "Sort reviews by recency or Trustpilot's default relevance order.",
                        "default": "recency"
                    },
                    "languages": {
                        "title": "Languages",
                        "type": "array",
                        "description": "Optional Trustpilot language filters such as en, de, fr, or all. Leave empty for default page language.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeReplies": {
                        "title": "Include business replies",
                        "type": "boolean",
                        "description": "Capture visible company reply text, date, and author when Trustpilot shows a reply.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. The default run starts without proxy to avoid unnecessary residential bandwidth; enable Residential proxy if Trustpilot blocks your run.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
