# TrustRadius Reviews Scraper (`solidcode/trustradius-review-scraper`) Actor

\[💰 $2.3 / 1K] Extract every review from TrustRadius product pages — ratings, reviewer firmographics, pros and cons, ROI, alternatives considered, and per-feature scores. Paste product URLs or search terms and get clean structured data.

- **URL**: https://apify.com/solidcode/trustradius-review-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.30 / 1,000 results

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

## TrustRadius Reviews Scraper

Pull B2B software reviews from TrustRadius at scale — overall ratings, per-feature scores, pros, cons, ROI write-ups, alternatives considered, likelihood-to-recommend reasoning, and reviewer firmographics for every product on the platform. Built for competitive intelligence teams, product marketers, and sales analysts who need fresh customer-voice data for objection handling, positioning, and win/loss research without manually copying reviews one by one.

### Why This Scraper?

- **43 fields per review** — captures everything TrustRadius surfaces: overall rating, letter grade, per-feature scores, pros, cons, ROI text, alternatives considered, "other software used", trust badge tier, structured Q&A sections, reviewer firmographics, and per-reviewer verification status (LinkedIn or screenshot proof).
- **Per-feature rating breakdown** — every review's individual feature scores (ease of use, customer support, integrations, reporting, etc.) returned as a `[{feature, score}]` array — gold for feature-gap analysis.
- **Four sort orders** — Most Recent, Most Relevant, Most Positive, Most Critical. Pair "Most Critical" with a max cap to mine pain-point language for sales objection handling.
- **Five-tier star filter and three company-size buckets** — pull only 5-star reviews, only 1-star reviews, only mid-market (51–1,000 employees), or any combination — server-side filtering, no paid rows wasted.
- **Date range filtering with smart short-circuit** — set `reviewsStartDate` with sort = "Most Recent" and the scraper stops paginating as soon as it crosses the cutoff, making nightly incremental runs cheap.
- **Multi-product runs** — queue a portfolio of competitor products in a single job. The competitor's actor only accepts one URL at a time.
- **Search by product name, not just URL** — type "HubSpot" or "Salesforce" and the scraper resolves it to the right product page automatically.
- **Privacy-by-default reviewer block** — reviewer email is never extracted, and a single `includeReviewerInfo` toggle strips all firmographics (name, title, company, industry, LinkedIn, years experience) for GDPR-sensitive workflows.
- **Flat $2.30 per 1,000 reviews** — undercuts every subscription tier of the closest TrustRadius scraper on the platform without requiring an Apify paid plan.

### Use Cases

**Competitive Intelligence**
- Track every new review of a competitor's product as it lands
- Compare your product's pros/cons against the leader in your category
- Flag reviews mentioning specific feature gaps or pricing complaints
- Build a sentiment timeline across product releases

**Sales Enablement & Objection Handling**
- Mine "Most Critical" reviews for the exact language your prospects use when comparing vendors
- Surface reviews that name your product in `alternativesConsidered` to learn why deals were lost
- Pull customer ROI quotes for case-study and battlecard content
- Build talk-tracks from real "what we like / what we don't" patterns

**Product Marketing & Positioning**
- Identify the top 5 features users praise — use those as homepage proof points
- Find feature requests buried in cons sections to feed the roadmap
- Compare per-feature ratings across your product and competitors
- Quantify NPS-style likelihood-to-recommend by company size

**VC & Strategy Research**
- Score sentiment trends over time during pre-investment due diligence
- Compare review volume and quality across companies in a target category
- Aggregate reviewer firmographics to validate ICP claims
- Track how a product's average rating moves quarter over quarter

**Customer Insights & Lead Research**
- Find heavy users of competing tools by industry and company size
- Build outreach lists segmented by reviewer role and department
- Identify products that show up alongside yours in `otherSoftwareUsed`
- Spot upsell signals — power users describing workarounds

### Getting Started

#### Quick Start — One Product

```json
{
    "productUrls": ["https://www.trustradius.com/products/notion/reviews"],
    "maxReviewsPerProduct": 100
}
````

#### Search by Product Name

No URL needed — the scraper resolves names to the right product page:

```json
{
    "searchTerms": ["HubSpot", "Salesforce", "Pipedrive"],
    "maxReviewsPerProduct": 200,
    "sortBy": "recent"
}
```

#### Pain-Point Mining (Sales / PMM)

Pull only critical reviews for objection-handling research:

```json
{
    "productUrls": ["https://www.trustradius.com/products/zoom-workplace/reviews"],
    "maxReviewsPerProduct": 150,
    "sortBy": "critical",
    "starRating": ["1", "2", "3"],
    "includeReviewerInfo": true
}
```

#### Incremental Daily Run

Pair date range with "Most Recent" — collection auto-stops when it crosses the cutoff:

```json
{
    "productUrls": [
        "https://www.trustradius.com/products/asana/reviews",
        "https://www.trustradius.com/products/monday/reviews",
        "https://www.trustradius.com/products/clickup/reviews"
    ],
    "maxReviewsPerProduct": 0,
    "sortBy": "recent",
    "reviewsStartDate": "2026-04-01"
}
```

#### Mid-Market 5-Star Reviews — Lean Output

```json
{
    "searchTerms": ["Tableau", "Looker", "Power BI"],
    "maxReviewsPerProduct": 50,
    "sortBy": "positive",
    "starRating": ["5"],
    "companySize": ["medium"],
    "includeReviewerInfo": false
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `productUrls` | string\[] | `["https://www.trustradius.com/products/zoom-workplace/reviews"]` | TrustRadius product reviews page URLs. Add as many products as you like — they all run in one job. |
| `searchTerms` | string\[] | `[]` | Product names to look up on TrustRadius (e.g. "Salesforce", "HubSpot"). Used when you don't have direct URLs — each name resolves to its top-matching product. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxReviewsPerProduct` | integer | `100` | Maximum reviews to collect per product. You pay per review — keep this low for test runs. Set to `0` to pull every review on the product (an internal upper cap protects against runaway pagination). |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sortBy` | select | `Most Recent` | Order returned reviews: Most Recent, Most Relevant, Most Positive, or Most Critical. Affects which reviews you get when capped. |
| `starRating` | string\[] | `[]` | Only collect reviews with these star ratings (1–5). Multi-select. Empty = all ratings. |
| `companySize` | string\[] | `[]` | Only collect reviews from companies of these sizes: Small (1–50 employees), Medium (51–1,000), Large (1,001+). Multi-select. Empty = all sizes. |
| `reviewsStartDate` | string | `null` | Only collect reviews posted on or after this date (`YYYY-MM-DD`). Pair with `sortBy = Most Recent` for cheap incremental runs. |
| `reviewsEndDate` | string | `null` | Only collect reviews posted on or before this date (`YYYY-MM-DD`). |

#### Output

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeReviewerInfo` | boolean | `true` | Include reviewer firmographics: name, job title, department, industry, company, company size, years of experience, LinkedIn URL, and avatar. Disable for a leaner, GDPR-friendly output that strips reviewer-level identifiers. |

### Output

Each row is one review. Here's a representative result:

```json
{
    "url": "https://www.trustradius.com/reviews/notion-makes-collaboration-effortless-2026-04-15",
    "slug": "notion-makes-collaboration-effortless-2026-04-15",
    "heading": "Notion makes cross-team collaboration effortless",
    "rating": 9,
    "grade": "A",
    "publishedDate": "2026-04-15T00:00:00Z",
    "editedDate": null,
    "productName": "Notion",
    "productSlug": "notion",
    "productUrl": "https://www.trustradius.com/products/notion/reviews/all",
    "productLogo": "https://images.trustradius.com/notion-square180.png",
    "vendorName": "Notion Labs",
    "categories": ["Knowledge Management", "Note-Taking", "Project Management"],
    "primaryCategory": "Knowledge Management",
    "useCases": "We use Notion across product, design, and engineering for specs, runbooks, and OKRs...",
    "pros": ["Flexible page templates", "Real-time collaboration", "Powerful databases"],
    "cons": ["Mobile app slower than desktop", "Search across workspaces is weak"],
    "likelihoodToRecommendScore": 9,
    "likelihoodToRecommend": "Excellent for cross-functional teams that need a single source of truth...",
    "roi": "Replaced Confluence and saved roughly $14k/year in licensing while doubling adoption.",
    "alternativesConsidered": ["Confluence", "Coda", "Almanac"],
    "alternativesFollowup": "Notion's database flexibility tipped the decision...",
    "featureRatings": [
        { "feature": "Ease of use", "score": 9, "notApplicable": false },
        { "feature": "Customer support", "score": 7, "notApplicable": false }
    ],
    "otherSoftwareUsed": ["Slack", "Linear", "Figma"],
    "sections": [
        { "title": "Overall Satisfaction", "questions": [ { "publicTitle": "Likelihood to Recommend", "text": "Excellent for cross-functional teams..." } ] }
    ],
    "trustBadge": "TrustRadius Top Rated 2026",
    "reviewerName": "Jane Doe",
    "reviewerFirstName": "Jane",
    "reviewerLastName": "Doe",
    "reviewerTitle": "Director of Product Operations",
    "reviewerJobType": "Manager",
    "reviewerDepartment": "Product",
    "reviewerCompany": "Acme SaaS Inc.",
    "reviewerCompanySize": "201-500 employees",
    "reviewerCompanySizeGroup": "medium",
    "reviewerIndustry": "Computer Software",
    "reviewerYearsExperience": 11,
    "reviewerRoles": ["Decision-maker", "End-user"],
    "reviewerLinkedInUrl": "https://www.linkedin.com/in/jane-doe-example",
    "reviewerAvatarUrl": "https://images.trustradius.com/avatars/jane-doe.png",
    "reviewerIsVerified": true,
    "reviewerVerifiedBy": "LinkedIn",
    "scrapedAt": "2026-05-08T14:30:00Z"
}
```

#### Review Identity

| Field | Type | Description |
|-------|------|-------------|
| `url` | string | Direct URL to the review on TrustRadius |
| `slug` | string | Review slug used in the URL |
| `heading` | string | Reviewer's headline for the review |
| `publishedDate` | string | When the review was first published (ISO 8601) |
| `editedDate` | string | When the review was last edited (null if never) |
| `scrapedAt` | string | When this row was collected (ISO 8601) |

#### Product Context

| Field | Type | Description |
|-------|------|-------------|
| `productName` | string | Product reviewed |
| `productSlug` | string | Product slug |
| `productUrl` | string | Normalized product reviews URL |
| `productLogo` | string | Product logo image URL |
| `vendorName` | string | Vendor / company that makes the product |
| `categories` | string\[] | All TrustRadius categories the product is listed under |
| `primaryCategory` | string | Primary product category |
| `trustBadge` | string | TrustRadius badge tier (e.g. "Top Rated 2026"), if assigned |

#### Ratings

| Field | Type | Description |
|-------|------|-------------|
| `rating` | number | Overall rating on TrustRadius's 1–10 scale |
| `grade` | string | Letter grade derived from rating (e.g. "A", "B+") |
| `likelihoodToRecommendScore` | number | 0–10 likelihood-to-recommend score |
| `likelihoodToRecommend` | string | Reviewer's free-text reasoning for the score |
| `featureRatings` | object\[] | Per-feature score breakdown — `[{feature, score, notApplicable}]` |

#### Review Content

| Field | Type | Description |
|-------|------|-------------|
| `useCases` | string | Reviewer's described use cases and deployment scope |
| `pros` | string\[] | Reviewer's listed pros |
| `cons` | string\[] | Reviewer's listed cons |
| `roi` | string | Reviewer's described ROI and business outcomes |
| `alternativesConsidered` | string\[] | Other products evaluated before choosing this one |
| `alternativesFollowup` | string | Reasoning for choosing this over the alternatives |
| `otherSoftwareUsed` | string\[] | Other software the reviewer uses alongside this product |
| `sections` | object\[] | Structured Q\&A — full set of section/question/answer entries |

#### Reviewer (when `includeReviewerInfo` is on)

| Field | Type | Description |
|-------|------|-------------|
| `reviewerName` | string | Reviewer's display name |
| `reviewerFirstName` | string | First name |
| `reviewerLastName` | string | Last name |
| `reviewerTitle` | string | Job title |
| `reviewerJobType` | string | Job type / function |
| `reviewerDepartment` | string | Department |
| `reviewerCompany` | string | Company name (often anonymized by TrustRadius) |
| `reviewerCompanySize` | string | Company size band (e.g. "201-500 employees") |
| `reviewerCompanySizeGroup` | string | Mapped bucket: small / medium / large |
| `reviewerIndustry` | string | Reviewer's industry |
| `reviewerYearsExperience` | number | Years of professional experience |
| `reviewerRoles` | string\[] | Reviewer's listed roles (decision-maker, end-user, etc.) |
| `reviewerLinkedInUrl` | string | LinkedIn URL when public |
| `reviewerAvatarUrl` | string | Avatar image URL |
| `reviewerIsVerified` | boolean | Whether TrustRadius has authenticated this reviewer |
| `reviewerVerifiedBy` | string | The verification method (e.g. "LinkedIn", "Screenshot") |

Reviewer email is never returned, regardless of the toggle.

### Tips for Best Results

- **Use `sortBy = Most Critical` for objection handling** — the lowest-rated reviews are where prospects' real concerns surface. Pair with a small `maxReviewsPerProduct` to keep cost down.
- **Run incrementals with `reviewsStartDate` + `Most Recent`** — collection auto-stops at the cutoff, so a nightly job costs only the new reviews.
- **Both rating scales are returned** — `rating` is the native 1–10 score, `grade` is the TrustRadius letter, and `starRating` (input) maps to the 5-star UI buckets. You'll have everything you need for either presentation.
- **Toggle off `includeReviewerInfo` for GDPR workflows** — you'll still get the full review body, ratings, pros, cons, and per-feature scores, just without reviewer-level identifiers.
- **Combine `productUrls` and `searchTerms`** — both inputs run in the same job, so you can mix exact URLs for products you know with name lookups for products you don't.
- **For broad categories, queue 3–5 competing products** — running side by side gives you ready-made comparison data instead of separate exports you have to merge.
- **Reviewer company is often anonymized** — TrustRadius redacts company names for many reviews. Industry, role, department, and company size are still populated.

### Pricing

**$2.30 per 1,000 results** — flat rate, undercuts every subscription tier of the closest TrustRadius scraper on the platform.

**No compute charges — you only pay per result returned.** A result is one review row in your dataset.

| Reviews | Cost      |
|---------|-----------|
| 100     | $0.23     |
| 1,000   | $2.30     |
| 10,000  | $23.00    |
| 100,000 | $230.00   |

Apify platform fees ($0.05 per run + $0.01 per 1,000 dataset items) are billed separately and depend on your plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new reviews
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate competitive research, market analysis, and product marketing. Users are responsible for complying with applicable laws and TrustRadius's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose. Be mindful of personal data — consider disabling reviewer firmographics for use cases where reviewer identity is not needed.

# Actor input Schema

## `productUrls` (type: `array`):

TrustRadius product reviews page URLs (e.g. https://www.trustradius.com/products/zoom-workplace/reviews). Add as many products as you like.

## `searchTerms` (type: `array`):

Product names to look up on TrustRadius (e.g. 'Salesforce', 'HubSpot'). Used when you don't have direct URLs — the scraper resolves each name to its top matching product before collecting reviews.

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

Maximum number of reviews to collect per product. You pay per review — keep this low for test runs. Set to 0 for unlimited (capped at 50,000 reviews per product as a runaway safeguard).

## `sortBy` (type: `string`):

Order TrustRadius returns reviews in. Affects which reviews you get when using a per-product cap.

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

Only collect reviews with these star ratings (1–5). Leave empty for all ratings.

## `companySize` (type: `array`):

Only collect reviews from reviewers at companies of these sizes. Leave empty for all sizes.

## `reviewsStartDate` (type: `string`):

Only collect reviews posted on or after this date. Format: YYYY-MM-DD (e.g. 2025-01-15). Pair with sort = Most Recent for efficient incremental runs — collection stops when older reviews are reached. With other sort orders, the scraper fetches the full result set before applying the date filter.

## `reviewsEndDate` (type: `string`):

Only collect reviews posted on or before this date. Format: YYYY-MM-DD.

## `includeReviewerInfo` (type: `boolean`):

Include reviewer firmographics on each row: job title, department, industry, company size, years of experience, LinkedIn URL, and avatar. Disable for a leaner output that strips reviewer-level identifiers.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.trustradius.com/products/zoom-workplace/reviews"
  ],
  "searchTerms": [],
  "maxReviewsPerProduct": 100,
  "sortBy": "recent",
  "starRating": [],
  "companySize": [],
  "includeReviewerInfo": true
}
```

# Actor output Schema

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

Table of scraped reviews with key fields.

# 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 = {
    "productUrls": [
        "https://www.trustradius.com/products/zoom-workplace/reviews"
    ],
    "searchTerms": [],
    "maxReviewsPerProduct": 100,
    "sortBy": "recent",
    "starRating": [],
    "companySize": [],
    "includeReviewerInfo": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/trustradius-review-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 = {
    "productUrls": ["https://www.trustradius.com/products/zoom-workplace/reviews"],
    "searchTerms": [],
    "maxReviewsPerProduct": 100,
    "sortBy": "recent",
    "starRating": [],
    "companySize": [],
    "includeReviewerInfo": True,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/trustradius-review-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 '{
  "productUrls": [
    "https://www.trustradius.com/products/zoom-workplace/reviews"
  ],
  "searchTerms": [],
  "maxReviewsPerProduct": 100,
  "sortBy": "recent",
  "starRating": [],
  "companySize": [],
  "includeReviewerInfo": true
}' |
apify call solidcode/trustradius-review-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TrustRadius Reviews Scraper",
        "description": "[💰 $2.3 / 1K] Extract every review from TrustRadius product pages — ratings, reviewer firmographics, pros and cons, ROI, alternatives considered, and per-feature scores. Paste product URLs or search terms and get clean structured data.",
        "version": "1.0",
        "x-build-id": "AjTOeXnYBqo4zJf3a"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~trustradius-review-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-trustradius-review-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/solidcode~trustradius-review-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-trustradius-review-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/solidcode~trustradius-review-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-trustradius-review-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": {
                    "productUrls": {
                        "title": "Product Reviews URLs",
                        "type": "array",
                        "description": "TrustRadius product reviews page URLs (e.g. https://www.trustradius.com/products/zoom-workplace/reviews). Add as many products as you like.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchTerms": {
                        "title": "Search Terms",
                        "type": "array",
                        "description": "Product names to look up on TrustRadius (e.g. 'Salesforce', 'HubSpot'). Used when you don't have direct URLs — the scraper resolves each name to its top matching product before collecting reviews.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max Reviews per Product",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect per product. You pay per review — keep this low for test runs. Set to 0 for unlimited (capped at 50,000 reviews per product as a runaway safeguard).",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort Reviews By",
                        "enum": [
                            "recent",
                            "relevant",
                            "positive",
                            "critical"
                        ],
                        "type": "string",
                        "description": "Order TrustRadius returns reviews in. Affects which reviews you get when using a per-product cap.",
                        "default": "recent"
                    },
                    "starRating": {
                        "title": "Star Rating",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only collect reviews with these star ratings (1–5). Leave empty for all ratings.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "5",
                                "4",
                                "3",
                                "2",
                                "1"
                            ],
                            "enumTitles": [
                                "5 stars",
                                "4 stars",
                                "3 stars",
                                "2 stars",
                                "1 star"
                            ]
                        },
                        "default": []
                    },
                    "companySize": {
                        "title": "Reviewer Company Size",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only collect reviews from reviewers at companies of these sizes. Leave empty for all sizes.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "small",
                                "medium",
                                "large"
                            ],
                            "enumTitles": [
                                "Small (1–50 employees)",
                                "Medium (51–1,000 employees)",
                                "Large (1,001+ employees)"
                            ]
                        },
                        "default": []
                    },
                    "reviewsStartDate": {
                        "title": "Reviews Start Date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only collect reviews posted on or after this date. Format: YYYY-MM-DD (e.g. 2025-01-15). Pair with sort = Most Recent for efficient incremental runs — collection stops when older reviews are reached. With other sort orders, the scraper fetches the full result set before applying the date filter."
                    },
                    "reviewsEndDate": {
                        "title": "Reviews End Date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Only collect reviews posted on or before this date. Format: YYYY-MM-DD."
                    },
                    "includeReviewerInfo": {
                        "title": "Include Reviewer Info",
                        "type": "boolean",
                        "description": "Include reviewer firmographics on each row: job title, department, industry, company size, years of experience, LinkedIn URL, and avatar. Disable for a leaner output that strips reviewer-level identifiers.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
