# TrustRadius Reviews Scraper (`automation-lab/trustradius-reviews-scraper`) Actor

Export public TrustRadius reviews with ratings, reviewer context, vetted badges, use cases, pros, cons, and recommendation text for analysis.

- **URL**: https://apify.com/automation-lab/trustradius-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/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

## TrustRadius Reviews Scraper

Export public TrustRadius software reviews into clean, analysis-ready records.

TrustRadius Reviews Scraper collects ratings, review dates, reviewer context, vetted and incentivized indicators, experience duration, use cases, pros, cons, and likelihood-to-recommend text from TrustRadius product pages.

Use product URLs or simple product slugs, scrape one product or a competitive set, and download the results as JSON, CSV, Excel, XML, RSS, or HTML through the Apify dataset.

### What does TrustRadius Reviews Scraper do?

The Actor turns public TrustRadius review pages into structured rows.

Each row represents one review and includes its product context, stable permalink, rating, reviewer details, disclosure badges, and detailed answer sections.

It supports:

- 🔗 canonical TrustRadius product URLs;
- 🏷️ direct product slugs;
- 📚 multiple products in one run;
- 📄 server-rendered pagination;
- 🎯 a separate review limit for every product;
- 🧹 duplicate removal by review permalink;
- 🛡️ retries, pacing, and fail-closed validation;
- 🔄 scheduled exports and API integrations.

No TrustRadius login, browser automation, or private API key is required for the public review data covered by this Actor.

### Who is it for?

#### Product marketing teams

Build a current voice-of-customer library from your own product reviews and compare recurring use cases, strengths, objections, and recommendation language.

#### Competitive intelligence teams

Track several competing products on a schedule and compare rating movement, reviewer segments, pros, cons, and buying signals.

#### Reputation and customer-success teams

Monitor new public reviews, identify common friction points, and route useful feedback into internal reporting workflows.

#### Research and data teams

Create reproducible B2B software-review datasets without maintaining selectors, pagination, retries, exports, or storage infrastructure.

#### Agencies and consultants

Prepare evidence-backed market, positioning, and customer-language reports for multiple software clients.

### Why use this TrustRadius review extractor?

Manual copying is slow and makes review analysis inconsistent.

This Actor provides:

- ⚡ repeatable extraction from multiple products;
- 🧾 normalized fields across every review;
- 🔍 reviewer role, department, and company-size context when published;
- ✅ explicit vetted and verified-user indicators;
- 🎁 an explicit incentivized-review indicator;
- 🕒 ISO timestamps for review dates and scrape freshness;
- 📦 managed Apify datasets and standard export formats;
- 🔌 API, webhook, Make, Zapier, Google Sheets, and MCP workflows.

The implementation uses a lightweight HTTP route and 256 MB memory instead of launching a browser for every page.

### What TrustRadius review data can I extract?

| Field | Description |
|---|---|
| `productName` | TrustRadius software product name |
| `productSlug` | Stable product slug used in TrustRadius URLs |
| `productUrl` | Canonical public product reviews URL |
| `productDescription` | Public structured product description |
| `productLogoUrl` | Public product logo URL when available |
| `aggregateRating` | Product aggregate rating, normally on a 10-point scale |
| `aggregateRatingCount` | Rating count reported in structured product data |
| `reviewTitle` | Published review heading |
| `reviewUrl` | Stable public review permalink |
| `rating` | Review rating as a number |
| `reviewDate` | Published review date in ISO format |
| `reviewerName` | Reviewer name or `Verified User` marker |
| `reviewerJobTitle` | Complete published reviewer job context |
| `reviewerRole` | Parsed role when available |
| `reviewerDepartment` | Parsed department when available |
| `reviewerCompanySize` | Published employee range when available |
| `isVerifiedUser` | Whether the identity is shown as Verified User |
| `isVetted` | Whether TrustRadius marks it as a Vetted Review |
| `isIncentivized` | Whether the review is marked Incentivized |
| `experienceDuration` | Published product-experience duration |
| `useCase` | Use Cases and Deployment Scope answer |
| `pros` | Published Pros answer text |
| `cons` | Published Cons answer text |
| `likelihoodToRecommend` | Likelihood to Recommend answer |
| `scrapedAt` | Time the record was extracted |

Optional fields are omitted when TrustRadius does not publish them for a review.

### How to scrape TrustRadius reviews

1. Open the Actor input page.
2. Add one or more TrustRadius product URLs, or enter product slugs.
3. Set the maximum reviews to collect for each product.
4. Keep the default request delay unless you need more conservative pacing.
5. Click **Start**.
6. Open the **Dataset** tab when the run succeeds.
7. Preview the rows or download JSON, CSV, Excel, XML, RSS, or HTML.

For a fast first run, use the prefilled Salesforce CRM Analytics URL and a limit of 10 reviews.

### Input parameters

#### TrustRadius product URLs

`startUrls` accepts product pages on `www.trustradius.com`, `trustradius.com`, or the public TrustRadius application host.

Valid examples include:

```text
https://www.trustradius.com/products/salesforce-crm-analytics
https://www.trustradius.com/products/salesforce-crm-analytics/reviews/all
````

URLs outside `/products/<slug>` and URLs on other hosts are rejected.

#### Product slugs

`productSlugs` accepts values such as:

```text
salesforce-crm-analytics
microsoft-power-bi
hubspot-crm
```

You can combine slugs and URLs. Duplicate products are processed once.

#### Maximum reviews per product

`maxReviewsPerProduct` accepts 1–500 and defaults to 20.

The limit applies independently to every supplied product.

#### Request delay

`requestDelayMs` accepts 0–5000 milliseconds and defaults to 250.

It is applied only between paginated requests, not after every saved review.

### Example input

```json
{
  "productSlugs": [
    "salesforce-crm-analytics",
    "microsoft-power-bi"
  ],
  "maxReviewsPerProduct": 20,
  "requestDelayMs": 250
}
```

URL-based example:

```json
{
  "startUrls": [
    {
      "url": "https://www.trustradius.com/products/salesforce-crm-analytics/reviews/all"
    }
  ],
  "maxReviewsPerProduct": 10
}
```

### Example output

```json
{
  "productName": "Salesforce CRM Analytics",
  "productSlug": "salesforce-crm-analytics",
  "productUrl": "https://www.trustradius.com/products/salesforce-crm-analytics/reviews/all",
  "aggregateRating": 8.5,
  "aggregateRatingCount": 974,
  "reviewTitle": "Salesforce CRM Analytics Review",
  "reviewUrl": "https://www.trustradius.com/reviews/salesforce-crm-analytics-2025-11-05-19-56-21",
  "rating": 8,
  "reviewDate": "2025-11-17T17:13:44.986Z",
  "reviewerName": "Verified User",
  "reviewerJobTitle": "Director (10,001+ employees)",
  "reviewerRole": "Director",
  "reviewerCompanySize": "10,001+ employees",
  "isVerifiedUser": true,
  "isVetted": true,
  "isIncentivized": true,
  "experienceDuration": "1 year of experience",
  "useCase": "The CRM analytics for us is really that insight...",
  "pros": "So for us, it's really getting insights...",
  "cons": "I think it's really tying it more cleanly...",
  "likelihoodToRecommend": "For us it really comes down to...",
  "scrapedAt": "2026-07-21T04:00:00.000Z"
}
```

This example is shortened for readability. Actual output retains the complete public answer text.

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

The Actor uses pay-per-event pricing:

- **Run start:** $0.005 once per run.
- **TrustRadius review:** tiered per saved review; the BRONZE reference price is $0.00012156 before volume-tier discounts.

| Apify tier | Price per saved review |
|---|---:|
| Free | $0.00013979 |
| Bronze | $0.00012156 |
| Silver | $0.000094816 |
| Gold | $0.000072935 |
| Platinum | $0.000048624 |
| Diamond | $0.000034036 |

At the BRONZE reference tier, a 100-review run is approximately $0.0172, including the run-start event.

You are charged for reviews actually saved, not the requested maximum.

Current live prices are always displayed on the Actor page before you start a run.

### Tips for reliable review exports

- 🎯 Start with one product and 10 reviews when testing a workflow.
- 🏷️ Use slugs for compact scheduled-run inputs.
- 🔗 Keep `reviewUrl` as the stable key in your database.
- 🕒 Use `reviewDate` for source chronology and `scrapedAt` for ingestion freshness.
- 🧹 Upsert records by `reviewUrl` when monitoring products repeatedly.
- 🛡️ Increase `requestDelayMs` if the source starts limiting requests.
- 📊 Compare incentivized and non-incentivized records separately when your methodology requires it.
- 👥 Segment by reviewer department and company size only when those optional fields are present.

### Scheduling a TrustRadius review monitor

Use an Apify schedule to run the same product set daily, weekly, or monthly.

A common monitor pattern is:

1. Run with a fixed list of product slugs.
2. Export or retrieve the latest dataset.
3. Upsert by `reviewUrl` in your destination.
4. Alert only when a previously unseen permalink appears.
5. Keep historical ratings for trend analysis.

For larger portfolios, split products into several scheduled tasks so each dataset maps to one business unit or competitor set.

### Integrations and automation workflows

#### Google Sheets

Send dataset rows to Google Sheets for review tracking, tagging, and stakeholder summaries.

#### Make

Trigger the Actor from Make, iterate over dataset items, and route new reviews into Notion, Airtable, Slack, or a CRM.

#### Zapier

Run a saved Actor task and add unseen review permalinks to your existing automation.

#### Webhooks

Attach an `ACTOR.RUN.SUCCEEDED` webhook to notify a data pipeline as soon as the dataset is ready.

#### Python or BI pipelines

Pull dataset items through the Apify API, normalize optional fields, and load them into a warehouse or sentiment-analysis process.

### Use the Actor with the Apify API

Replace `APIFY_TOKEN` with your token.

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/trustradius-reviews-scraper').call({
    productSlugs: ['salesforce-crm-analytics'],
    maxReviewsPerProduct: 20,
    requestDelayMs: 250,
});

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

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/trustradius-reviews-scraper').call(run_input={
    'productSlugs': ['salesforce-crm-analytics'],
    'maxReviewsPerProduct': 20,
    'requestDelayMs': 250,
})

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

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~trustradius-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "productSlugs": ["salesforce-crm-analytics"],
    "maxReviewsPerProduct": 20,
    "requestDelayMs": 250
  }'
```

Retrieve dataset items with the `defaultDatasetId` returned by the run API.

### Use TrustRadius Reviews Scraper through MCP

Apify MCP lets AI clients run the Actor as a tool.

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/trustradius-reviews-scraper"
```

#### Claude Desktop, Cursor, and VS Code

Add this server to the client's MCP JSON configuration:

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

Example prompts:

- “Export the latest 20 TrustRadius reviews for Salesforce CRM Analytics.”
- “Collect reviews for these three CRM product slugs and compare common cons.”
- “Return vetted reviews from large-company users and summarize their use cases.”
- “Create a CSV-ready dataset of review ratings, dates, and recommendation text.”

### Data quality and limitations

The Actor extracts public data currently rendered by TrustRadius.

Keep these limitations in mind:

- TrustRadius can change its public hostname, HTML, labels, or pagination.
- Some reviewers publish only a subset of role, department, and company-size context.
- Some reviews omit one or more detailed answer sections.
- Aggregate rating counts can represent the product's rating corpus, not only rows returned in your run.
- The Actor does not bypass login walls or collect private profile information.
- The Actor accepts product targets, not category search pages or individual review URLs.
- Source updates can occur after a run; use scheduling when freshness matters.

A run fails instead of silently succeeding when no valid reviews can be extracted from any supplied product.

### Is it legal to scrape TrustRadius reviews?

This Actor accesses publicly available pages and does not require a user account.

Web-scraping legality depends on your jurisdiction, purpose, contractual obligations, and how you store or use the data.

You are responsible for:

- following applicable laws and regulations;
- reviewing TrustRadius terms and policies;
- respecting intellectual-property and database rights;
- limiting collection to data needed for a legitimate purpose;
- handling reviewer-related data responsibly;
- applying retention, access, and deletion controls where required.

This information is not legal advice. Consult qualified counsel for sensitive or large-scale use cases.

### Frequently asked questions

#### Do I need a TrustRadius account?

No. The Actor covers public software review records available without login.

#### Can I scrape several products in one run?

Yes. Add several URLs, several slugs, or a combination of both. The per-product limit applies independently.

#### Can I use a normal TrustRadius URL?

Yes. The Actor validates and normalizes canonical `www.trustradius.com/products/<slug>` URLs to its working HTTP route.

#### Does it collect complete review text?

It captures the public answer sections rendered on review-list pages, including use case, pros, cons, and likelihood-to-recommend text when present.

#### Why is a field missing from one record?

Optional fields are omitted when a reviewer did not publish that context or TrustRadius did not render that answer section.

#### Why did my run fail with no records?

Check that each target is a TrustRadius product URL under `/products/<slug>` or a valid product slug. Confirm the product exists and has public reviews. Then retry with the default request delay.

#### Why did I receive fewer reviews than requested?

The product may have fewer public pages than your requested limit, or duplicate permalinks may have been removed. Review the run log for the page and product counts.

#### How do I avoid duplicate records across scheduled runs?

Use `reviewUrl` as an upsert key in your destination. It is also the Actor's internal deduplication key within one run.

#### Can I scrape category pages or reviewer profiles?

No. This version is intentionally scoped to public product review exports.

### Related B2B review scrapers

Build a broader review-intelligence workflow with:

- [G2 Reviews Scraper](https://apify.com/automation-lab/g2-reviews-scraper) for B2B software reviews from G2;
- [Trustpilot Scraper](https://apify.com/automation-lab/trustpilot-scraper) for company and consumer review workflows;
- [Capterra Reviews Scraper](https://apify.com/automation-lab/capterra-reviews-scraper) for software review comparison datasets.

Choose one source-specific Actor per platform, then join records in your warehouse using product, vendor, date, and rating fields.

### Support

If a valid public TrustRadius product unexpectedly returns no reviews, open an issue from the Actor page.

Include:

- the product URL or slug;
- the run URL;
- the approximate time of the run;
- the expected review count or missing field;
- whether the problem affects one product or every product.

Do not include credentials or private information. The Actor does not need either.

# Actor input Schema

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

Add TrustRadius product or review-list URLs, for example https://www.trustradius.com/products/salesforce-crm-analytics/reviews/all.

## `productSlugs` (type: `array`):

Optionally add product slugs such as salesforce-crm-analytics. You can combine these with product URLs.

## `maxReviewsPerProduct` (type: `integer`):

Stop after this many reviews for each product. TrustRadius currently serves about 10 reviews per page.

## `requestDelayMs` (type: `integer`):

Wait between paginated requests. Increase this only when the source is rate limiting requests.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.trustradius.com/products/salesforce-crm-analytics/reviews/all"
    }
  ],
  "maxReviewsPerProduct": 10,
  "requestDelayMs": 250
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.trustradius.com/products/salesforce-crm-analytics/reviews/all"
        }
    ],
    "maxReviewsPerProduct": 10,
    "requestDelayMs": 250
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/trustradius-reviews-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.trustradius.com/products/salesforce-crm-analytics/reviews/all" }],
    "maxReviewsPerProduct": 10,
    "requestDelayMs": 250,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/trustradius-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.trustradius.com/products/salesforce-crm-analytics/reviews/all"
    }
  ],
  "maxReviewsPerProduct": 10,
  "requestDelayMs": 250
}' |
apify call automation-lab/trustradius-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TrustRadius Reviews Scraper",
        "description": "Export public TrustRadius reviews with ratings, reviewer context, vetted badges, use cases, pros, cons, and recommendation text for analysis.",
        "version": "0.1",
        "x-build-id": "eNjQMtakdvv1Z2505"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~trustradius-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-trustradius-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/automation-lab~trustradius-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-trustradius-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/automation-lab~trustradius-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-trustradius-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "🔗 TrustRadius product URLs",
                        "type": "array",
                        "description": "Add TrustRadius product or review-list URLs, for example https://www.trustradius.com/products/salesforce-crm-analytics/reviews/all.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "productSlugs": {
                        "title": "🏷️ Product slugs",
                        "type": "array",
                        "description": "Optionally add product slugs such as salesforce-crm-analytics. You can combine these with product URLs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerProduct": {
                        "title": "📦 Maximum reviews per product",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Stop after this many reviews for each product. TrustRadius currently serves about 10 reviews per page.",
                        "default": 20
                    },
                    "requestDelayMs": {
                        "title": "⏱️ Delay between pages (milliseconds)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Wait between paginated requests. Increase this only when the source is rate limiting requests.",
                        "default": 250
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```