# Trustpilot Reviews Scraper | Batch & Filters (`enosgb/trustpilot-reviews-scraper`) Actor

Extract Trustpilot reviews at scale. Supports multiple companies, star rating filters, date range, language filtering. LLM-ready output.

- **URL**: https://apify.com/enosgb/trustpilot-reviews-scraper.md
- **Developed by:** [Enos Melo](https://apify.com/enosgb) (community)
- **Categories:** Automation, Lead generation, SEO tools
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.49 / 1,000 review extracteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 | Batch & Filters

Extract **Trustpilot business reviews** at scale with advanced filtering capabilities. This Actor supports batch processing of multiple companies, star rating filters, date range filtering, language filtering, and produces **LLM-ready output** with markdown format.

### What does Trustpilot Reviews Scraper do?

Trustpilot Reviews Scraper extracts authentic customer reviews from [Trustpilot.com](https://www.trustpilot.com) at scale. It retrieves detailed review data including ratings, reviewer information, company replies, and full review content. Unlike competitors, this Actor supports **multiple companies per run**, **date range filtering**, **language filtering**, and **verified-only** mode.

**Key Features:**

- Batch scraping: scrape multiple businesses in a single run
- Filter by star rating: 1-5 stars
- Filter by date range: start date, end date, or lookback days
- Filter by language: target specific languages
- Verified reviews only: focus on confirmed purchases
- Company replies: extract business responses
- Sort by: Newest, Oldest, Lowest Rated, Highest Rated
- LLM-ready output with markdown format
- HTTP-based (CheerioCrawler): fast and cost-effective

### Why use Trustpilot Reviews Scraper?

**Business Use Cases:**

- **Brand Monitoring**: Track your company's reputation on Trustpilot
- **Competitor Analysis**: Analyze competitor sentiment and common complaints
- **Customer Insights**: Aggregate customer pain points and praise points
- **Sales Intelligence**: Find companies with negative reviews to offer alternatives
- **Investment Research**: Evaluate company reputation for due diligence

**Advantages over competitors:**

- Cheaper pricing: $1.49 per 1K reviews vs $1.99 for similar actors
- Batch processing: scrape multiple companies in one run
- HTTP-based scraping: 1K reviews in ~2 minutes (no browser needed)
- Rich filtering: star rating, date range, language, verified-only
- Company reply extraction: see how businesses respond to reviews

### How to use Trustpilot Reviews Scraper

#### Step 1: Get Trustpilot Business URLs

Navigate to any business review page on Trustpilot. You can use:

- Full URL: `https://www.trustpilot.com/review/nordvpn.com`
- Just the domain: `nordvpn.com`

#### Step 2: Configure Input

Set your desired parameters in the Actor input:

- **Business URLs**: Add one or more business review URLs or domains
- **Max Results**: Set maximum reviews per business (default: 100)
- **Sort Order**: Choose how reviews are ordered
- **Filters**: Apply star rating, date range, language, or verified-only filters

#### Step 3: Run and Collect Data

Execute the Actor and download results from the Dataset tab.

### Input

| Field            | Type    | Default           | Description                                                  |
| ---------------- | ------- | ----------------- | ------------------------------------------------------------ |
| `businessUrls`   | array   | **required**      | List of Trustpilot business URLs or domains                  |
| `maxResults`     | integer | 100               | Maximum reviews per business (1-100000)                      |
| `sortOrder`      | string  | "created_at:desc" | Sort: created_at:desc, created_at:asc, stars:desc, stars:asc |
| `starRating`     | array   | []                | Filter by star rating: ["1","2","3","4","5"]                 |
| `startDate`      | string  | -                 | Filter reviews from this date (YYYY-MM-DD)                   |
| `endDate`        | string  | -                 | Filter reviews until this date (YYYY-MM-DD)                  |
| `lookbackDays`   | integer | 0                 | Only return reviews from last N days (0 = no limit)          |
| `language`       | array   | []                | Filter by language codes: ["en", "es", "de"]                 |
| `verifiedOnly`   | boolean | false             | Only include reviews from verified purchasers                |
| `repliesOnly`    | boolean | false             | Only include reviews that have a company reply               |
| `maxConcurrency` | integer | 10                | Maximum concurrent requests (1-50)                           |

#### Input JSON Examples

**Example 1: Scrape recent reviews only**

```json
{
    "businessUrls": ["https://www.trustpilot.com/review/nordvpn.com"],
    "maxResults": 50,
    "lookbackDays": 30,
    "sortOrder": "created_at:desc"
}
````

**Example 2: Get negative reviews for analysis**

```json
{
    "businessUrls": ["nordvpn.com"],
    "maxResults": 100,
    "starRating": ["1", "2"],
    "sortOrder": "stars:asc"
}
```

**Example 3: Batch scrape multiple companies**

```json
{
    "businessUrls": ["nordvpn.com", "expressvpn.com", "surfshark.com"],
    "maxResults": 200,
    "verifiedOnly": true,
    "sortOrder": "created_at:desc"
}
```

### Output

Reviews are stored in the default dataset. Each review contains:

| Field              | Type    | Description                           |
| ------------------ | ------- | ------------------------------------- |
| `reviewId`         | string  | Unique Trustpilot review identifier   |
| `businessName`     | string  | Business name                         |
| `businessUrl`      | string  | Trustpilot business review page URL   |
| `starRating`       | number  | Rating (1-5)                          |
| `date`             | string  | Review date (ISO 8601)                |
| `reviewerName`     | string  | Reviewer name                         |
| `reviewerCountry`  | string  | Reviewer country                      |
| `reviewerLink`     | string  | Reviewer Trustpilot profile URL       |
| `title`            | string  | Review title                          |
| `content`          | string  | Full review text                      |
| `companyReply`     | string  | Company reply text (null if no reply) |
| `companyReplyDate` | string  | Company reply date (null if no reply) |
| `verified`         | boolean | Whether reviewer is verified          |
| `numberOfReviews`  | number  | Total reviews by this reviewer        |
| `location`         | string  | Reviewer location                     |
| `markdownContent`  | string  | Full review in markdown format        |
| `scrapedAt`        | string  | Timestamp when review was scraped     |

#### Output JSON Example

```json
{
    "reviewId": "69c3d3eb8ee1019dcabca2d1",
    "businessName": "Nordvpn.Com",
    "businessUrl": "https://www.trustpilot.com/review/nordvpn.com?page=1",
    "starRating": 4,
    "date": "2026-03-25T14:24:12.000Z",
    "reviewerName": "Bru",
    "reviewerCountry": "",
    "reviewerLink": "https://www.trustpilot.com/users/69c3d3eb8ee1019dcabca2d1",
    "title": "No title",
    "content": "Although getting an AI bot as first line of response is annoying, the overall support is good. The time and attention provided was detailed and dedicated.",
    "companyReply": null,
    "companyReplyDate": null,
    "verified": true,
    "numberOfReviews": 1,
    "location": "",
    "markdownContent": "## Nordvpn.Com Review: No title\n\n**Rating:** 4/5 stars | **Date:** 2026-03-25T14:24:12.000Z\n**Reviewer:** Bru\n**Verified:** Yes\n**Total Reviews:** 1\n\n### Review\nAlthough getting an AI bot as first line of response is annoying, the overall support is good. The time and attention provided was detailed and dedicated.\n\n---\n_reviewId: 69c3d3eb8ee1019dcabca2d1 | business: Nordvpn.Com_",
    "scrapedAt": "2026-04-04T16:54:17.064Z"
}
```

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

### Data Table

| Field        | Example Value                               |
| ------------ | ------------------------------------------- |
| reviewId     | 69c3d3eb8ee1019dcabca2d1                    |
| businessName | Nordvpn.Com                                 |
| starRating   | 4                                           |
| date         | 2026-03-25T14:24:12.000Z                    |
| reviewerName | Bru                                         |
| verified     | true                                        |
| content      | Although getting an AI bot as first line... |
| companyReply | null                                        |

### Pricing

This Actor uses Apify's pay-per-result pricing. You only pay for the compute units actually used.

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

- 100 reviews: ~$0.15
- 1,000 reviews: ~$1.49
- 10,000 reviews: ~$14.90
- 100,000 reviews: ~$149.00

*Actor uses HTTP-based scraping (CheerioCrawler), which is significantly cheaper than browser-based alternatives.*

### Tips & Advanced Options

#### Optimize Your Runs

1. **Use lookbackDays**: Set to 30 or 90 days to reduce unnecessary scraping and costs
2. **Apply filters early**: Use starRating and verifiedOnly to get only relevant data
3. **Batch wisely**: Scrape multiple companies in one run to save on actor startup costs
4. **Adjust concurrency**: Raise maxConcurrency (up to 50) for faster scraping

#### Troubleshooting

- **No reviews returned**: Check that URLs are correct Trustpilot review pages
- **Incomplete data**: Some reviews may have limited fields - this is per Trustpilot's display settings
- **Rate limiting**: Lower concurrency if you encounter blocks

#### Accessing Business Info

The Actor saves business information (trust score, total reviews) to the Key-Value Store under key `business-info-{domain}`. Access it via:

```javascript
const info = await Actor.getValue('business-info-nordvpn.com');
```

### FAQ

#### Is this legal?

Web scraping Trustpilot reviews for personal, non-commercial analysis is generally acceptable. Review Trustpilot's Terms of Service before use. Do not resell or republish scraped content without permission.

#### Why don't I need a proxy?

This Actor uses HTTP-based scraping with CheerioCrawler, which is faster and less likely to be blocked than browser-based approaches. Proxies are optional for high-volume runs.

#### Can I scrape reviews from any Trustpilot business?

Yes, as long as the business has a public reviews page on Trustpilot.com.

#### How accurate is the lookbackDays filter?

The filter compares the review date against your cutoff. Reviews are filtered after each page is scraped, so some extra requests may be made before stopping.

#### What's the maximum reviews I can scrape?

The maxResults field supports up to 100,000 reviews per business URL. Larger datasets may require multiple runs.

#### Can I get reviews from multiple companies in one run?

Yes! Add multiple URLs or domains to the `businessUrls` array. Each company will be scraped up to your `maxResults` limit.

#### How do I verify reviewer authenticity?

The `verified` field indicates whether Trustpilot verified the reviewer's purchase.

### API Integration

#### JavaScript / Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const input = {
    businessUrls: ['https://www.trustpilot.com/review/nordvpn.com'],
    maxResults: 100,
    lookbackDays: 30,
};

const run = await client.actor('your-actor-id').call(input);
const dataset = await client.dataset(run.defaultDatasetId).listItems();
console.log(dataset.items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

input = {
    'businessUrls': ['https://www.trustpilot.com/review/nordvpn.com'],
    'maxResults': 100,
    'lookbackDays': 30,
}

call = client.actor('your-actor-id').call(input)
dataset = client.dataset(call['defaultDatasetId']).list_items()
print(dataset['items'])
```

#### cURL

```bash
curl -X POST https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "businessUrls": ["https://www.trustpilot.com/review/nordvpn.com"],
    "maxResults": 100,
    "lookbackDays": 30
  }'
```

### Support

- **Report issues**: Open a GitHub issue
- **Request features**: Open a GitHub issue with your use case
- **Custom development**: Contact for enterprise needs

***

Built with [Apify SDK](https://docs.apify.com/sdk/js) + [Crawlee](https://crawlee.dev) + [Cheerio](https://cheerio.js.org)

# Actor input Schema

## `businessUrls` (type: `array`):

List of Trustpilot business review URLs or domains (e.g., nordvpn.com, https://www.trustpilot.com/review/nordvpn.com)

## `maxResults` (type: `integer`):

Maximum number of reviews to scrape per business

## `sortOrder` (type: `string`):

How to sort reviews

## `starRating` (type: `array`):

Leave empty for all ratings (1-5)

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

Filter reviews from this date (YYYY-MM-DD)

## `endDate` (type: `string`):

Filter reviews until this date (YYYY-MM-DD)

## `lookbackDays` (type: `integer`):

Number of days to look back from today (0 = no limit)

## `language` (type: `array`):

Leave empty for all languages (ISO 639-1 codes)

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

Only include reviews from verified purchasers

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

Only include reviews that have a company reply

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

Maximum concurrent requests

## Actor input object example

```json
{
  "businessUrls": [
    {
      "url": "https://www.trustpilot.com/review/example.com"
    }
  ],
  "maxResults": 100,
  "sortOrder": "created_at:desc",
  "starRating": [],
  "lookbackDays": 0,
  "language": [
    "en",
    "es",
    "de"
  ],
  "verifiedOnly": false,
  "repliesOnly": false,
  "maxConcurrency": 10
}
```

# Actor output Schema

## `results` (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 = {
    "businessUrls": [
        {
            "url": "https://www.trustpilot.com/review/example.com"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("enosgb/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 = { "businessUrls": [{ "url": "https://www.trustpilot.com/review/example.com" }] }

# Run the Actor and wait for it to finish
run = client.actor("enosgb/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 '{
  "businessUrls": [
    {
      "url": "https://www.trustpilot.com/review/example.com"
    }
  ]
}' |
apify call enosgb/trustpilot-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Reviews Scraper | Batch & Filters",
        "description": "Extract Trustpilot reviews at scale. Supports multiple companies, star rating filters, date range, language filtering. LLM-ready output.",
        "version": "1.0",
        "x-build-id": "LtObv2wn0wyW06E7C"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/enosgb~trustpilot-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-enosgb-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/enosgb~trustpilot-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-enosgb-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/enosgb~trustpilot-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-enosgb-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",
                "required": [
                    "businessUrls"
                ],
                "properties": {
                    "businessUrls": {
                        "title": "Business URLs",
                        "type": "array",
                        "description": "List of Trustpilot business review URLs or domains (e.g., nordvpn.com, https://www.trustpilot.com/review/nordvpn.com)",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max reviews per business",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per business",
                        "default": 100
                    },
                    "sortOrder": {
                        "title": "Sort order",
                        "enum": [
                            "created_at:desc",
                            "created_at:asc",
                            "stars:desc",
                            "stars:asc"
                        ],
                        "type": "string",
                        "description": "How to sort reviews",
                        "default": "created_at:desc"
                    },
                    "starRating": {
                        "title": "Filter by star rating",
                        "type": "array",
                        "description": "Leave empty for all ratings (1-5)",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "startDate": {
                        "title": "Start date",
                        "type": "string",
                        "description": "Filter reviews from this date (YYYY-MM-DD)"
                    },
                    "endDate": {
                        "title": "End date",
                        "type": "string",
                        "description": "Filter reviews until this date (YYYY-MM-DD)"
                    },
                    "lookbackDays": {
                        "title": "Lookback days",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Number of days to look back from today (0 = no limit)",
                        "default": 0
                    },
                    "language": {
                        "title": "Filter by language",
                        "type": "array",
                        "description": "Leave empty for all languages (ISO 639-1 codes)",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "verifiedOnly": {
                        "title": "Verified reviews only",
                        "type": "boolean",
                        "description": "Only include reviews from verified purchasers",
                        "default": false
                    },
                    "repliesOnly": {
                        "title": "Reviews with replies only",
                        "type": "boolean",
                        "description": "Only include reviews that have a company reply",
                        "default": false
                    },
                    "maxConcurrency": {
                        "title": "Max concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum concurrent requests",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
