# Trustpilot Reviews Reputation & Competitor Monitor (`feeng/trustpilot-reputation-intelligence`) Actor

⭐ Monitor public Trustpilot reviews, compare competitors, detect reputation changes, surface urgent issues, and export evidence-based response priorities.

- **URL**: https://apify.com/feeng/trustpilot-reputation-intelligence.md
- **Developed by:** [Daniel S.](https://apify.com/feeng) (community)
- **Categories:** Automation, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 analyzed review or business summaries

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Reputation & Competitor Monitor

Monitor public Trustpilot reviews, compare competitors, detect reputation changes, and turn customer feedback into an actionable response queue.

This standalone Apify Actor reads **public Trustpilot review pages** with a cost-efficient hybrid fetcher: lightweight HTTP first, then a managed Playwright browser only when Trustpilot presents a JavaScript challenge. It does not use a paid API or another Apify Actor.

### 🚀 What you get

- ⭐ Business TrustScore, public review count, and rating distribution
- 💬 Structured review-level records without reviewer profile data
- 📈 Observed 30-day review velocity
- 📣 Public business response rate
- 🚨 Negative-review rate and urgent issue detection
- 🧠 Deterministic sentiment and topic classification
- 🏆 Competitor reputation leaderboard
- 🔄 Changes versus the previous run
- 🔎 Evidence links and response priorities
- 📊 Apify Dataset views for leaderboard, urgent issues, reviews, and all data
- 📄 Professional HTML and JSON reputation reports
- 🗄️ Historical state stored in a named key-value store
- 🌐 Retry, exponential backoff, and optional Apify/custom proxy support
- 🛡️ Automatic browser fallback for Trustpilot WAF challenges

### Who should use it?

- Reputation management agencies
- Customer-experience and support leaders
- Competitive intelligence teams
- SaaS, e-commerce, travel, fintech, and marketplace operators
- Consultants preparing account reviews
- Automation teams sending reputation alerts to Slack, email, Make, Zapier, or n8n

### Quick start

Use a business domain:

```json
{
  "businesses": ["www.airbnb.com"],
  "maxReviewsPerBusiness": 100,
  "ratings": ["1", "2", "3", "4", "5"],
  "competitorComparison": false,
  "includeReviewText": true,
  "topicKeywords": ["refund", "cancellation", "customer support"],
  "historyKey": "airbnb-reputation-watch",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

Or compare several public Trustpilot profiles:

```json
{
  "businesses": [
    "https://www.trustpilot.com/review/www.airbnb.com",
    "www.booking.com",
    "www.vrbo.com"
  ],
  "maxReviewsPerBusiness": 100,
  "competitorComparison": true,
  "includeReviewText": true,
  "historyKey": "travel-platform-reputation"
}
```

The first business is treated as the primary brand in the input, while all businesses are evaluated by the same deterministic method.

### Input

| Field | Type | Default | Description |
|---|---:|---:|---|
| `businesses` | string\[] | required | 1–20 domains or full Trustpilot `/review/` URLs |
| `maxReviewsPerBusiness` | integer | `100` | Maximum matching review records per business, up to 1,000 |
| `dateFrom` | `YYYY-MM-DD` | empty | Inclusive lower publication-date filter |
| `dateTo` | `YYYY-MM-DD` | empty | Inclusive upper publication-date filter |
| `ratings` | string\[] | `["1","2","3","4","5"]` | Star ratings to export; numeric API values are also normalized at runtime |
| `competitorComparison` | boolean | `true` | Build a cross-business leaderboard |
| `includeReviewText` | boolean | `true` | Include public review titles, bodies, and business response text |
| `topicKeywords` | string\[] | empty | Additional business-specific phrases to detect |
| `historyKey` | string | `trustpilot-reputation-monitor` | Named KVS identifier reused across scheduled runs |
| `proxyConfiguration` | object | Residential proxy | Apify Proxy or custom proxy settings; direct mode remains available |
| `requestTimeoutSecs` | integer | `30` | Per-request timeout |
| `maxConcurrency` | integer | `2` | Concurrent business profiles, maximum 5 |

#### Filtering behavior

Pages are requested newest first. Rating and date filters control the review rows exported to the Dataset. Business summary metrics use the recent reviews sampled while the Actor scans for matching results. The report clearly labels these values as sampled metrics.

When `dateFrom` is supplied, scanning stops after the crawler reaches reviews older than that date. A page safety limit prevents unexpectedly large runs.

### Output design

The default Dataset contains two record types:

#### `summary`

One business-level row per successfully processed profile:

```json
{
  "recordType": "summary",
  "businessDomain": "example.com",
  "businessName": "Example Co",
  "businessRating": 3.8,
  "businessReviewCount": 1234,
  "reviewsCollected": 100,
  "reviewVelocity30d": 42,
  "responseRate": 68,
  "negativeReviewRate": 21,
  "reputationScore": 72,
  "competitorRank": 2,
  "urgentIssueCount": 4,
  "topTopics": [
    {
      "topic": "customer support",
      "count": 18,
      "negativeCount": 11
    }
  ],
  "changes": {
    "hasPreviousRun": true,
    "ratingDelta": -0.1,
    "reviewCountDelta": 42,
    "negativeRateDelta": 3.2,
    "newReviewCount": 42
  }
}
```

#### `review`

One evidence-level row per filtered public review:

```json
{
  "recordType": "review",
  "businessDomain": "example.com",
  "rating": 1,
  "reviewTitle": "Refund never arrived",
  "reviewText": "Customer support ignored my request...",
  "publishedAt": "2026-07-20T10:00:00.000Z",
  "hasBusinessResponse": false,
  "sentiment": "negative",
  "sentimentScore": -100,
  "topics": ["customer support", "refund"],
  "isUrgent": true,
  "urgencyReasons": [
    "Recent 1–2 star review has no public business response"
  ],
  "reviewUrl": "https://www.trustpilot.com/reviews/..."
}
```

Reviewer names, avatars, countries, profile URLs, and reviewer activity are deliberately not collected.

### Dataset views

- **🏆 Competitor leaderboard**: scores, ranks, changes, and priorities
- **🚨 Urgent issues**: low-star evidence needing action
- **💬 Review intelligence**: filtered, analyzed review rows
- **All structured data**: complete API-friendly output

The default key-value store also contains:

- `REPUTATION_REPORT.json`
- `REPUTATION_REPORT.html`

### Reputation score

`reputationScore` is deterministic and bounded from 0 to 100:

- 55%: public business rating, or sampled average when unavailable
- 20%: inverse sampled negative-review rate
- 15%: sampled public response rate
- 10%: urgent-issue penalty

It is a prioritization metric, not a statement of fact about a company and not a prediction of future performance.

### Sentiment, topics, and urgency

No external AI API is required. Sentiment starts from the star rating and is adjusted by a small documented positive/negative vocabulary.

Built-in topics cover:

- customer support
- delivery and shipping
- refunds
- billing and payments
- cancellations
- product/service quality
- security and fraud
- account access
- bookings
- communication
- website and app
- staff
- pricing

Custom `topicKeywords` are matched case-insensitively and added to the same output.

A review can become urgent when it is a recent unanswered 1–2 star review, a very recent one-star review, or contains critical language such as fraud, safety, identity theft, or data breach. Every flag includes evidence and an explicit reason.

### Historical monitoring

Use the same `historyKey` every time:

```json
{
  "businesses": ["example.com", "competitor.com"],
  "historyKey": "weekly-category-monitor"
}
```

The Actor opens a named key-value store and saves a compact `REPUTATION_STATE_V1` snapshot. The next run calculates:

- rating change
- total review-count change
- negative-rate change in percentage points
- response-rate change in percentage points
- observed 30-day velocity change
- new review IDs in the current sample
- newly added urgent-issue count

For reliable comparisons, keep the same businesses, filters, review cap, and history key.

### Scheduling and alerts

1. Save the Actor input as an Apify Task.
2. Schedule it daily or weekly.
3. Keep `historyKey` unchanged.
4. Connect the Dataset or JSON report to Make, Zapier, n8n, a webhook, email, or a CRM.
5. Trigger an alert when `isUrgent` is `true`, `ratingDelta` is negative, or `negativeRateDelta` exceeds your threshold.

### Run locally

Requirements: Node.js 20 or newer.

```bash
npm install
export APIFY_LOCAL_STORAGE_DIR=./storage
npx --yes apify-cli run --purge --input-file examples/input-smoke.json
```

Alternatively, place the input in `storage/key_value_stores/default/INPUT.json` and run:

```bash
npm start
```

Run offline tests:

```bash
npm test
```

Run a real one-page smoke check:

```bash
npm run smoke -- https://www.trustpilot.com/review/www.airbnb.com
```

Trustpilot commonly rejects datacenter IPs. To execute the same live smoke test through your Apify account:

```bash
APIFY_TOKEN=your_token \
SMOKE_USE_APIFY_PROXY=true \
SMOKE_PROXY_GROUPS=RESIDENTIAL \
npm run smoke -- https://www.trustpilot.com/review/www.airbnb.com
```

You can instead set `SMOKE_PROXY_URL` to a full custom proxy URL.

### API example

```bash
curl "https://api.apify.com/v2/acts/YOUR_USERNAME~trustpilot-reputation-intelligence/runs?token=$APIFY_TOKEN" \
  -X POST \
  -H "Content-Type: application/json" \
  -d '{
    "businesses": ["www.airbnb.com", "www.booking.com"],
    "maxReviewsPerBusiness": 100,
    "competitorComparison": true,
    "historyKey": "travel-weekly"
  }'
```

### Pricing

The launch price uses predictable pay-per-event billing:

- `apify-actor-start`: **$0.00005** once per run
- `apify-default-dataset-item`: **$0.0025** per exported summary or review row

That equals **$2.50 per 1,000 exported Dataset records**, plus the negligible run-start event. A business with 20 matching reviews normally produces 21 records and costs about **$0.05255**. Failed requests and reviews removed by filters do not create paid Dataset items.

See [`PRICING.md`](PRICING.md) for examples, margin guardrails, and the exact Apify configuration.

### Reliability and responsible use

- Only pages and review data intentionally exposed on public Trustpilot profiles are requested.
- The Actor first uses lightweight HTTP. If Trustpilot serves its normal JavaScript challenge instead of the public page, it retries that same public URL in its own managed Playwright browser.
- It does not log in, call private or paid APIs, depend on another Actor, solve CAPTCHAs, or attempt to circumvent access controls.
- Requests use conservative concurrency, retries, and exponential backoff.
- Apify Proxy is supported but optional. Direct and datacenter IPs may be rejected; a suitable proxy can improve reliability but cannot guarantee access.
- Public website markup can change. Parser fixtures cover the supported HTML contract, and the live smoke script detects major markup changes.
- Review velocity and rates are based on the sampled reviews available within the configured cap.
- Use the Actor in accordance with applicable laws, Trustpilot's terms, and your legitimate business purpose.
- This Actor is independent and is not affiliated with, endorsed by, or sponsored by Trustpilot.

### Project structure

```text
.actor/                  Actor definition, input/output/dataset schemas, Dockerfile
src/input.js             Input validation and URL normalization
src/fetch.js             Hybrid HTTP/Playwright fetcher, retry, backoff, proxy support
src/parser.js            Cheerio parser for server-rendered review pages
src/analysis.js          Topics, sentiment, urgency, score, leaderboard, historical diff
src/history.js           Named KVS state
src/output.js            Dataset-friendly records
src/report.js            JSON and HTML reports
src/main.js              Apify orchestration
test/                    Sanitized fixtures and offline tests
scripts/smoke.mjs        Live one-page parser smoke test
examples/                Example inputs and outputs
```

### License and trademarks

Private commercial project. Trustpilot and associated marks belong to their respective owners and are used descriptively to identify the public source being monitored.

# Actor input Schema

## `businesses` (type: `array`):

Required. Add 1–20 domains or full URLs from trustpilot.com/review/. The first item is treated as the primary business in competitor views.

## `maxReviewsPerBusiness` (type: `integer`):

Maximum matching reviews exported for each business. Trustpilot pages are requested newest first; filters may require scanning additional pages.

## `dateFrom` (type: `string`):

Optional inclusive UTC date in YYYY-MM-DD format. Leave empty for no lower date limit.

## `dateTo` (type: `string`):

Optional inclusive UTC date in YYYY-MM-DD format. Leave empty for today and older.

## `ratings` (type: `array`):

Export only selected star ratings. Business-level metrics still describe the public profile and the reviews sampled during this run.

## `competitorComparison` (type: `boolean`):

Rank businesses using rating, negative-review rate, response rate, and recent review momentum.

## `includeReviewText` (type: `boolean`):

Include publicly displayed review titles and bodies. Disable for a compact metrics-only export. Reviewer names and profiles are never collected.

## `topicKeywords` (type: `array`):

Optional business-specific topics such as refund, delivery, support, billing, cancellation, quality, or fraud. Matching is deterministic and case-insensitive.

## `historyKey` (type: `string`):

Stable identifier used for the named historical key-value store. Reuse it in scheduled runs to calculate changes. Letters, numbers, hyphens, and underscores only.

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

Optional Apify Proxy or custom proxy settings. Use a proxy when direct public requests are rate-limited in your region.

## `requestTimeoutSecs` (type: `integer`):

Maximum time for one public page request before it is retried.

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

Number of business profiles processed concurrently. Keep this low to reduce rate-limit risk.

## Actor input object example

```json
{
  "businesses": [
    "www.airbnb.com",
    "www.booking.com"
  ],
  "maxReviewsPerBusiness": 100,
  "dateFrom": "",
  "dateTo": "",
  "ratings": [
    "1",
    "2",
    "3",
    "4",
    "5"
  ],
  "competitorComparison": true,
  "includeReviewText": true,
  "topicKeywords": [],
  "historyKey": "trustpilot-reputation-monitor",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "requestTimeoutSecs": 30,
  "maxConcurrency": 2
}
```

# Actor output Schema

## `leaderboard` (type: `string`):

Business-level reputation metrics, rank, changes, and response priorities.

## `urgentIssues` (type: `string`):

Recent low-star reviews and issue evidence that should be triaged first.

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

Structured review-level records without reviewer profile data.

## `allData` (type: `string`):

No description

## `jsonReport` (type: `string`):

No description

## `htmlReport` (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 = {
    "businesses": [
        "www.airbnb.com",
        "www.booking.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("feeng/trustpilot-reputation-intelligence").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 = { "businesses": [
        "www.airbnb.com",
        "www.booking.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("feeng/trustpilot-reputation-intelligence").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 '{
  "businesses": [
    "www.airbnb.com",
    "www.booking.com"
  ]
}' |
apify call feeng/trustpilot-reputation-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Trustpilot Reviews Reputation & Competitor Monitor",
        "description": "⭐ Monitor public Trustpilot reviews, compare competitors, detect reputation changes, surface urgent issues, and export evidence-based response priorities.",
        "version": "0.1",
        "x-build-id": "hqTeGOePxp2nl66ya"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/feeng~trustpilot-reputation-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-feeng-trustpilot-reputation-intelligence",
                "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/feeng~trustpilot-reputation-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-feeng-trustpilot-reputation-intelligence",
                "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/feeng~trustpilot-reputation-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-feeng-trustpilot-reputation-intelligence",
                "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": [
                    "businesses"
                ],
                "properties": {
                    "businesses": {
                        "title": "🏢 Business domains or Trustpilot URLs",
                        "minItems": 1,
                        "maxItems": 20,
                        "type": "array",
                        "description": "Required. Add 1–20 domains or full URLs from trustpilot.com/review/. The first item is treated as the primary business in competitor views.",
                        "items": {
                            "type": "string"
                        },
                        "default": [
                            "www.airbnb.com"
                        ]
                    },
                    "maxReviewsPerBusiness": {
                        "title": "💬 Maximum reviews per business",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum matching reviews exported for each business. Trustpilot pages are requested newest first; filters may require scanning additional pages.",
                        "default": 100
                    },
                    "dateFrom": {
                        "title": "📅 Reviews from date",
                        "type": "string",
                        "description": "Optional inclusive UTC date in YYYY-MM-DD format. Leave empty for no lower date limit.",
                        "default": ""
                    },
                    "dateTo": {
                        "title": "Reviews through date",
                        "type": "string",
                        "description": "Optional inclusive UTC date in YYYY-MM-DD format. Leave empty for today and older.",
                        "default": ""
                    },
                    "ratings": {
                        "title": "⭐ Ratings to include",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Export only selected star ratings. Business-level metrics still describe the public profile and the reviews sampled during this run.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "1 star",
                                "2 stars",
                                "3 stars",
                                "4 stars",
                                "5 stars"
                            ]
                        },
                        "default": [
                            "1",
                            "2",
                            "3",
                            "4",
                            "5"
                        ]
                    },
                    "competitorComparison": {
                        "title": "🏆 Build competitor leaderboard",
                        "type": "boolean",
                        "description": "Rank businesses using rating, negative-review rate, response rate, and recent review momentum.",
                        "default": true
                    },
                    "includeReviewText": {
                        "title": "📝 Include public review text",
                        "type": "boolean",
                        "description": "Include publicly displayed review titles and bodies. Disable for a compact metrics-only export. Reviewer names and profiles are never collected.",
                        "default": true
                    },
                    "topicKeywords": {
                        "title": "🔎 Custom topic keywords",
                        "maxItems": 50,
                        "type": "array",
                        "description": "Optional business-specific topics such as refund, delivery, support, billing, cancellation, quality, or fraud. Matching is deterministic and case-insensitive.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "historyKey": {
                        "title": "📈 History key",
                        "type": "string",
                        "description": "Stable identifier used for the named historical key-value store. Reuse it in scheduled runs to calculate changes. Letters, numbers, hyphens, and underscores only.",
                        "default": "trustpilot-reputation-monitor"
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy or custom proxy settings. Use a proxy when direct public requests are rate-limited in your region.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout in seconds",
                        "minimum": 5,
                        "maximum": 90,
                        "type": "integer",
                        "description": "Maximum time for one public page request before it is retried.",
                        "default": 30
                    },
                    "maxConcurrency": {
                        "title": "Concurrent businesses",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Number of business profiles processed concurrently. Keep this low to reduce rate-limit risk.",
                        "default": 2
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
