# Trustpilot Reviews Scraper — Ratings & Company Data (`scrapepilot/trustpilot-reviews-scraper----ratings-company-data`) Actor

Scrape Trustpilot reviews from any company page. Get review title, text, star rating, date, reviewer name, country, verified status, helpful votes, and company replies. Filter by stars or language. No login. $6.99/month. 2-hour free trial.

- **URL**: https://apify.com/scrapepilot/trustpilot-reviews-scraper----ratings-company-data.md
- **Developed by:** [Scrape Pilot](https://apify.com/scrapepilot) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$6.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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 Reviews, Ratings & Company Data

> **The most reliable Trustpilot Reviews Scraper on Apify.** Extract customer reviews, star ratings, reviewer names, countries, verified status, company replies, and full company metadata from any Trustpilot business page — in bulk. Filter by star rating or language. No login. No API key. Instant structured output.



---

### 📌 Table of Contents

- [What Is This Actor?](#what-is-this-actor)
- [Why Use This Trustpilot Reviews Scraper?](#why-use-this-trustpilot-reviews-scraper)
- [Use Cases](#use-cases)
- [Input Parameters](#input-parameters)
- [Output Fields](#output-fields)
- [Example Input & Output](#example-input--output)
- [Pricing & Free Trial](#pricing--free-trial)
- [Performance & Limits](#performance--limits)
- [FAQ](#faq)
- [Changelog](#changelog)
- [Legal & Terms of Use](#legal--terms-of-use)

---

### 🔍 What Is This Actor?

**Trustpilot Reviews Scraper** is a production-ready Apify actor that extracts complete customer review data and company metadata from any public Trustpilot business page.

Provide a company name, domain, or direct Trustpilot URL and receive back a clean, structured dataset of customer reviews — each with review title, full review text, star rating, reviewer name, reviewer country, verified purchase status, helpful vote count, company reply, and posting date. Every record is also enriched with company-level metadata: overall rating, total review count, company name, logo, and website.

Filter results by star rating (1–5 stars) or language to focus on exactly the Trustpilot reviews you need. Whether you are monitoring brand reputation, analyzing competitor sentiment, or building a customer feedback dataset — this **Trustpilot reviews** actor delivers ready-to-use data instantly.

---

### 🚀 Why Use This Trustpilot Reviews Scraper?

| Feature | This Actor | Manual Export | Other Scrapers | Trustpilot API |
|---|---|---|---|---|
| **Trustpilot reviews — bulk extraction** | ✅ | ❌ Slow | ⚠️ Partial | ❌ Paid |
| **Review title + full text** | ✅ Both | ✅ | ⚠️ | ✅ |
| **Verified status per review** | ✅ | ✅ | ❌ | ✅ |
| **Reviewer name & country** | ✅ | ✅ | ⚠️ | ✅ |
| **Company reply extracted** | ✅ | ✅ | ❌ | ✅ |
| **Helpful vote count** | ✅ | ❌ | ❌ | ⚠️ |
| **Filter by stars (1–5)** | ✅ Built-in | ❌ | ❌ | ⚠️ |
| **Filter by language** | ✅ Built-in | ❌ | ❌ | ⚠️ |
| **Company overall rating + total reviews** | ✅ Every record | ❌ | ⚠️ | ✅ |
| **No login or API key** | ✅ | N/A | ✅ | ❌ Required |

> **Bottom line:** This **Trustpilot reviews** scraper is the only actor that returns verified status, company replies, helpful vote counts, and reviewer country — alongside full review text and company metadata — all in one structured, export-ready record.

---

### 🎯 Use Cases

#### 🏆 Brand Reputation Monitoring
- Scrape **Trustpilot reviews** for your own company to track sentiment trends over time
- Monitor the ratio of 5-star to 1-star reviews and spot emerging complaint patterns early
- Extract company replies to measure how actively your team is responding to customer feedback

#### 🔍 Competitor Research & Benchmarking
- Pull **Trustpilot reviews** from competitor companies to analyze their customer satisfaction levels
- Compare overall ratings, review volumes, and verified purchase ratios across competitors
- Identify recurring complaints or praise themes in competitor reviews to inform your product strategy

#### 🤖 NLP & Sentiment Analysis Datasets
- Build labeled sentiment datasets using Trustpilot star ratings as ground truth for ML models
- Collect large volumes of multilingual customer reviews filtered by language for NLP training
- Extract verified review text for opinion mining, aspect-based sentiment, or topic modeling research

#### 📊 Customer Feedback Intelligence
- Aggregate Trustpilot review data into dashboards for executive reporting on brand health
- Filter 1 and 2-star reviews to identify the most critical customer pain points at scale
- Track helpful vote counts to surface the most influential reviews in your dataset

#### 🛒 E-Commerce & Product Research
- Scrape Trustpilot reviews for e-commerce platforms, SaaS tools, or service providers you are evaluating
- Build structured review datasets for product comparison sites or buyer guides
- Collect verified purchase reviews as social proof content for marketing teams

#### 🎓 Academic & Consumer Research
- Build research datasets of customer reviews across industries for consumer behavior studies
- Analyze review patterns — length, sentiment, response rates — across business categories
- Study the relationship between Trustpilot ratings and business performance metrics

---

### ⚙️ Input Parameters

```json
{
  "company":      "amazon.com",
  "max_results":  50,
  "stars_filter": null,
  "language":     "en",
  "proxyConfiguration": {
    "useApifyProxy":    true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

| Parameter | Type | Default | Description |
|---|---|---|---|
| `company` | string | `"amazon.com"` | Company domain, name, or full Trustpilot URL — e.g. `"apple.com"`, `"netflix.com"`, or `"https://www.trustpilot.com/review/amazon.com"` |
| `max_results` | integer | `25` | Maximum number of Trustpilot reviews to return |
| `stars_filter` | integer | `null` | Filter by star rating — `1`, `2`, `3`, `4`, or `5`. Leave empty for all ratings |
| `language` | string | `""` | Filter by review language — e.g. `"en"` for English, `"de"` for German, `"fr"` for French. Leave empty for all languages |
| `proxyConfiguration` | object | Optional | Apify proxy config — recommended for high-volume runs |

> **Tip:** You can enter a company in three ways: a domain (`"netflix.com"`), a company name (`"Netflix"`), or a full Trustpilot review URL (`"https://www.trustpilot.com/review/netflix.com"`). All three formats are automatically handled.

***

### 📋 Output Fields

Every record from this **Trustpilot reviews** scraper includes both review-level and company-level data:

#### 📝 Review Fields

| Field | Type | Description | Example |
|---|---|---|---|
| `review_title` | string | Review headline | `"Excellent service, highly recommend"` |
| `review_text` | string | Full review body (max 3000 chars) | `"I ordered on Monday and it arrived..."` |
| `rating` | string | Star rating for this review | `"5"` |
| `date` | string | Review posting date (ISO format) | `"2024-03-15"` |
| `verified` | boolean | Whether this is a verified purchase review | `true` |
| `helpful_count` | integer | Number of helpful votes on this review | `12` |
| `reply` | string | Company reply to this review (if any) | `"Thank you for your feedback..."` |

#### 👤 Reviewer Fields

| Field | Type | Description | Example |
|---|---|---|---|
| `reviewer_name` | string | Reviewer display name | `"John M."` |
| `reviewer_country` | string | Reviewer country code | `"GB"`, `"US"`, `"DE"` |

#### 🏢 Company Fields *(included in every review record)*

| Field | Type | Description | Example |
|---|---|---|---|
| `company_name` | string | Company display name on Trustpilot | `"Amazon"` |
| `company_slug` | string | Trustpilot URL identifier | `"amazon.com"` |
| `overall_rating` | string | Company's overall Trustpilot rating | `"4.2"` |
| `total_reviews` | string | Total number of reviews on Trustpilot | `"145,832"` |
| `company_url` | string | Company's official website | `"https://www.amazon.com"` |
| `company_logo` | string | Company logo image URL | `"https://..."` |

***

### 📦 Example Input & Output

**Input:**

```json
{
  "company":      "apple.com",
  "max_results":  5,
  "stars_filter": 5,
  "language":     "en"
}
```

**Output (one record):**

```json
{
  "review_title":    "Best phone I have ever owned",
  "review_text":     "Switched from Android last year and honestly could not be happier. The build quality is unmatched and customer support was brilliant when I had a small issue.",
  "rating":          "5",
  "date":            "2024-03-12",
  "reviewer_name":   "Sarah T.",
  "reviewer_country":"GB",
  "verified":        true,
  "helpful_count":   8,
  "reply":           null,
  "company_name":    "Apple",
  "company_slug":    "apple.com",
  "overall_rating":  "2.1",
  "total_reviews":   "7842",
  "company_url":     "https://www.apple.com",
  "company_logo":    "https://..."
}
```

***

### 💰 Pricing & Free Trial

| Plan | Price | Includes |
|---|---|---|
| **Free Trial** | $0 | 2 hours full access — no credit card required |
| **Monthly** | $6.99 / month | Unlimited runs, any company, star and language filters |

#### Everything included in every plan:

- ✅ Full Trustpilot review text, title, rating, and date
- ✅ Reviewer name, country, and verified status
- ✅ Company reply per review
- ✅ Helpful vote count per review
- ✅ Company-level metadata in every record
- ✅ Filter by star rating (1–5) and language
- ✅ JSON + CSV + Excel export from Apify dataset
- ✅ Scheduled runs for automated reputation monitoring

> **Start your 2-hour free trial now** — no credit card needed. Click **Try for free** at the top of this page.

***

### ⚡ Performance & Limits

| Mode | Reviews | Estimated Time |
|---|---|---|
| Small run | 25 | ~30–60 seconds |
| Medium run | 100 | ~2–4 minutes |
| Large run | 500 | ~10–18 minutes |
| Filtered (stars or language) | Any count | ~Same speed |

- Results are pushed to the Apify dataset in real time as each page is processed
- Automatic pagination — the actor fetches as many pages as needed to reach `max_results`
- Star and language filters are applied server-side for maximum efficiency
- Per-page error handling — one failed page never stops the rest of the run

***

### ❓ FAQ

**Q: How do I specify which company to scrape?**
A: Enter the company in any of three formats in the `company` field: a domain (`"booking.com"`), a company name (`"Booking"`), or a full Trustpilot URL (`"https://www.trustpilot.com/review/booking.com"`). All three are handled automatically.

**Q: Can I scrape only 1-star or 5-star Trustpilot reviews?**
A: Yes. Set `stars_filter` to any value from `1` to `5` to return only reviews with that star rating. Leave it empty to return reviews across all ratings.

**Q: Can I filter reviews by language?**
A: Yes. Set `language` to any ISO language code — `"en"` for English, `"de"` for German, `"fr"` for French, `"es"` for Spanish, etc. Leave it empty to return reviews in all languages.

**Q: Does every review record include the company's overall rating?**
A: Yes. `company_name`, `overall_rating`, `total_reviews`, `company_slug`, and `company_url` are included in every review record — so you can always trace back which company a review belongs to, even in large multi-company exports.

**Q: What does the `verified` field mean?**
A: `verified: true` means Trustpilot has confirmed the reviewer made a real purchase or used the service. `verified: false` or `null` means the review was submitted without purchase verification.

**Q: Can I monitor a company's reviews on a schedule?**
A: Yes. Set up an Apify scheduled task to run this **Trustpilot reviews** scraper on a daily or weekly basis for any company. New reviews will appear in each run's output automatically.

**Q: Can I scrape Trustpilot reviews for multiple companies in one run?**
A: Each run targets one company. For multi-company monitoring, run the actor as separate Apify tasks — one per company — or use Apify's scheduling to run them sequentially.

**Q: Can I export to Excel or CSV?**
A: Yes. All results are pushed to the Apify dataset, which can be exported to JSON, CSV, Excel, and more directly from the Apify Console after each run.

***

### 📜 Changelog

#### v1.0.0 (Current)

- ✅ Full Trustpilot review extraction: title, text, rating, date, reviewer name, country
- ✅ Verified purchase status per review
- ✅ Company reply extracted per review
- ✅ Helpful vote count per review
- ✅ Company metadata in every record: name, overall rating, total reviews, logo, website
- ✅ Star rating filter (1–5) built-in
- ✅ Language filter built-in
- ✅ Domain, company name, and full Trustpilot URL accepted as input
- ✅ Automatic multi-page pagination up to `max_results`
- ✅ Real-time dataset push as each page is processed

***

### 🏷️ Tags

`trustpilot reviews` `trustpilot scraper` `review scraper` `trustpilot data` `customer reviews` `sentiment analysis data` `brand reputation` `review monitoring` `trustpilot rating` `company reviews` `feedback data` `review dataset`

***

### ⚖️ Legal & Terms of Use

This actor accesses publicly visible customer review data on Trustpilot in the same way a regular user browses the platform.

**Please note:**

- Use extracted **Trustpilot reviews** only for **lawful purposes** — reputation monitoring, market research, sentiment analysis, and academic study are common legitimate uses
- Do not use scraped reviews to misrepresent, defame, or create misleading content about any company or individual
- Trustpilot review content belongs to the original reviewers — do not republish reviews as your own content or without appropriate attribution
- Respect Trustpilot's Terms of Service — do not use this tool at volumes designed to overload platform infrastructure
- The actor developer is not responsible for how extracted review data is used

***

### 🤝 Support & Feedback

- **Bug report?** Contact us via the Apify actor page
- **Feature request?** Post in the Apify Community forum
- **Loving it?** Please leave a ⭐ review — it helps other users find this actor!

***

<p align="center">
  <strong>Built with ❤️ on Apify</strong><br/>
  <em>The most reliable Trustpilot Reviews Scraper — full review data, star filters, company metadata</em><br/><br/>
  <strong>💰 $6.99/month · 🆓 2-hour free trial · No credit card required</strong>
</p>

# Actor input Schema

## `company` (type: `string`):

Company domain (e.g. amazon.com) or full Trustpilot URL

## `max_results` (type: `integer`):

Maximum reviews to return

## `stars_filter` (type: `integer`):

Only return reviews with this star rating. E.g: 1, 2, 3, 4, or 5. Leave empty for all.

## `language` (type: `string`):

Filter by language code. E.g: en, de, fr

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

Use Apify Proxy to avoid rate limits. RESIDENTIAL recommended.

## Actor input object example

```json
{
  "company": "amazon.com",
  "max_results": 25,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "company": "amazon.com",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilot/trustpilot-reviews-scraper----ratings-company-data").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 = {
    "company": "amazon.com",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapepilot/trustpilot-reviews-scraper----ratings-company-data").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 '{
  "company": "amazon.com",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call scrapepilot/trustpilot-reviews-scraper----ratings-company-data --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Reviews Scraper — Ratings & Company Data",
        "description": "Scrape Trustpilot reviews from any company page. Get review title, text, star rating, date, reviewer name, country, verified status, helpful votes, and company replies. Filter by stars or language. No login. $6.99/month. 2-hour free trial.",
        "version": "0.0",
        "x-build-id": "H0947tQrFan9ZiCWy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilot~trustpilot-reviews-scraper----ratings-company-data/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilot-trustpilot-reviews-scraper----ratings-company-data",
                "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/scrapepilot~trustpilot-reviews-scraper----ratings-company-data/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilot-trustpilot-reviews-scraper----ratings-company-data",
                "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/scrapepilot~trustpilot-reviews-scraper----ratings-company-data/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilot-trustpilot-reviews-scraper----ratings-company-data",
                "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": {
                    "company": {
                        "title": "Company Name or URL",
                        "type": "string",
                        "description": "Company domain (e.g. amazon.com) or full Trustpilot URL"
                    },
                    "max_results": {
                        "title": "Max Reviews",
                        "type": "integer",
                        "description": "Maximum reviews to return",
                        "default": 25
                    },
                    "stars_filter": {
                        "title": "Filter by Stars",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only return reviews with this star rating. E.g: 1, 2, 3, 4, or 5. Leave empty for all."
                    },
                    "language": {
                        "title": "Language Filter",
                        "type": "string",
                        "description": "Filter by language code. E.g: en, de, fr"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Use Apify Proxy to avoid rate limits. RESIDENTIAL recommended."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
