# TrustRadius Reviews Scraper - B2B Software Reviews (`parseforge/trustradius-reviews-scraper`) Actor

Scrape verified B2B software reviews from TrustRadius. Extract ratings, pros/cons, review text, and dates. Export to CSV, Excel, or JSON.

- **URL**: https://apify.com/parseforge/trustradius-reviews-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** E-commerce, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## ⭐ TrustRadius Reviews Scraper

> 🚀 **Export verified B2B software reviews from TrustRadius in seconds.** Pull ratings, pros/cons, reviewer details, and full review text for any product - no account needed, no API key required.

> 🕒 **Last updated:** 2026-05-13 · **📊 11 fields** per record · Handles hundreds of reviews per product · Covers any software listed on TrustRadius

The TrustRadius Reviews Scraper extracts verified user reviews from [TrustRadius](https://www.trustradius.com), one of the most trusted B2B software review platforms. Each record includes the reviewer name, review title, full review body, pros, cons, star rating, verification status, review date, and product details - all sourced directly from TrustRadius's public pages in real time.

TrustRadius hosts millions of in-depth reviews from verified software buyers. Unlike G2 or Capterra, TrustRadius enforces a rigorous verification process, making its reviews particularly valuable for competitive analysis, market research, and voice-of-customer programs.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| SaaS product marketers | Competitive intelligence on rival products |
| Sales enablement teams | Battle cards built from real customer sentiment |
| Market research analysts | Voice-of-customer datasets for B2B software |
| Venture capital analysts | Due diligence on software product reception |
| Customer success teams | Understanding churn triggers and satisfaction drivers |
| Academic researchers | NLP / sentiment analysis on B2B software reviews |

### 📋 What the TrustRadius Reviews Scraper does

- 🔍 Scrapes all publicly available reviews for any TrustRadius product URL you provide
- 📝 Extracts full review text, pros, cons, title, rating, and reviewer name from each review
- ✅ Captures verification status so you know which reviews are from confirmed buyers
- 📅 Records the original review date published by TrustRadius
- 🔗 Includes both the product URL and the direct review URL for citation and deduplication
- 📦 Respects your `maxItems` limit - free users get 10 reviews, paid users up to 1,000,000
- 🚀 Delivers results as JSON, CSV, Excel, or XML - ready for immediate analysis

> 💡 **Why it matters:** TrustRadius reviews come from verified enterprise buyers who write detailed, structured feedback. This makes them far more signal-rich than anonymous reviews - ideal for training sentiment models, building competitive battlecards, or tracking product perception over time.

### 🎬 Full Demo

_🚧 Coming soon_

### ⚙️ Input

| Field | Type | Required | Description |
|---|---|---|---|
| `startUrl` | String | Yes | TrustRadius product reviews URL (e.g. `https://www.trustradius.com/products/slack/reviews`) |
| `maxItems` | Integer | No | Max reviews to collect. Free: 10. Paid: up to 1,000,000. Default: 10 |

**Example 1 - Basic (single product, 10 reviews):**
```json
{
  "startUrl": "https://www.trustradius.com/products/slack/reviews",
  "maxItems": 10
}
````

**Example 2 - Bulk competitor research (up to 500 reviews):**

```json
{
  "startUrl": "https://www.trustradius.com/products/microsoft-teams/reviews",
  "maxItems": 500
}
```

> ⚠️ **Good to Know:** TrustRadius is a public platform - no login is required. However, some products may have fewer publicly visible reviews than their total count if TrustRadius gates older reviews behind sign-in. The scraper collects everything it can access without authentication.

### 📊 Output

| Field | Type | Description |
|---|---|---|
| 👤 `reviewerName` | String | Name or anonymized label of the reviewer (e.g. "Verified User") |
| 📌 `reviewTitle` | String | Title of the review as written by the reviewer |
| 💬 `reviewText` | String | Full body text of the review |
| ✅ `pros` | Array | List of pros mentioned by the reviewer |
| ❌ `cons` | Array | List of cons mentioned by the reviewer |
| ⭐ `rating` | Integer | Numeric rating out of 10 |
| 🔒 `isVerified` | Boolean | Whether TrustRadius has verified this reviewer |
| 📅 `reviewDate` | String | Date the review was published on TrustRadius |
| 📦 `productName` | String | Name of the software product being reviewed |
| 🔗 `productUrl` | String | URL of the product's review listing page |
| 🌐 `reviewUrl` | String | Direct permalink to the individual review |
| 🕒 `scrapedAt` | String | ISO 8601 timestamp of when the record was collected |
| ❌ `error` | String | Error message if extraction failed for this record |

**Sample records (real output):**

```json
[
  {
    "reviewerName": "Verified User",
    "reviewTitle": "Slack Review",
    "reviewText": "So we use it for daily collaboration, just notifications for different things that happen. We're solely building out automation in Slack. We integrated it from Salesforce so that when something happens in Salesforce, we want to notify the users in Slack and send our automated reminders. That's what we're using it for.",
    "pros": [
      "I think it's the whole collaborative feature, and now with Slack coming into Salesforce and Salesforce being able to be seen from Slack, I think it's going to be amazing."
    ],
    "cons": [
      "I can't think of anything right now"
    ],
    "rating": 10,
    "isVerified": true,
    "reviewDate": "May 12, 2026",
    "productName": "Slack",
    "productUrl": "https://www.trustradius.com/products/slack/reviews",
    "reviewUrl": "https://www.trustradius.com/reviews/slack-2026-05-05-23-51-38",
    "scrapedAt": "2026-05-13T13:42:38.776Z"
  },
  {
    "reviewerName": "Verified User",
    "reviewTitle": "Great app for collaboration",
    "reviewText": "1. Automated workflows and audit trails 2. Convenient way to collaborate and keep a simplified runbook through canvas for the team's access 3. Keeping in touch with teammates located in different timezones. 4. Community channels allows for a more informal way to communicate with everyone in the firm - as a chatline about upcoming internal company events, early bird sales to external events, lost & found, etc.",
    "pros": [
      "Automated workflows",
      "Collaboration",
      "Private and public channels",
      "Application linkage"
    ],
    "cons": [
      "Ctrl + K being allowed to be the \"link\" or URL function would be great and very in line with other softwares/web browsers",
      "Customized ordering of starred conversations"
    ],
    "rating": 10,
    "isVerified": true,
    "reviewDate": "January 11, 2026",
    "productName": "Slack",
    "productUrl": "https://www.trustradius.com/products/slack/reviews",
    "reviewUrl": "https://www.trustradius.com/reviews/slack-2026-01-03-10-45-31",
    "scrapedAt": "2026-05-13T13:42:38.776Z"
  },
  {
    "reviewerName": "Verified User",
    "reviewTitle": "Slack is no slacking",
    "reviewText": "We use it to communicate amongst ourselves and other team members. We also use it to communicate with our customers that also use it! It is easy for everyone to use and effectively gets the job done. I would highly recommend this product to anyone who needs a reliable communication channel.",
    "pros": [
      "Notifies quickly",
      "Easy to have different threads",
      "Easy to use for all people"
    ],
    "cons": [
      "Logs me out occasionally",
      "could be easier to upload pictures",
      "could be easier to upload documents"
    ],
    "rating": 10,
    "isVerified": true,
    "reviewDate": "December 19, 2025",
    "productName": "Slack",
    "productUrl": "https://www.trustradius.com/products/slack/reviews",
    "reviewUrl": "https://www.trustradius.com/reviews/slack-2025-12-08-12-37-31",
    "scrapedAt": "2026-05-13T13:42:38.776Z"
  }
]
```

### ✨ Why choose this Actor

- 🔒 **Verified reviews only** - TrustRadius enforces buyer verification, so the data you get is higher quality than most review platforms
- 📄 **Full review content** - captures complete review body, pros list, and cons list - not just the headline rating
- ⚡ **No authentication needed** - works entirely on public data, no TrustRadius account or API key required
- 🔗 **Direct review permalinks** - every record includes the exact URL to cite the original review for compliance and deduplication
- 🌐 **Any product on TrustRadius** - just paste the reviews URL and get results in seconds
- 📦 **Multiple export formats** - download as JSON, CSV, Excel, or XML directly from the Apify dataset

### 📈 How it compares to alternatives

| Feature | TrustRadius Reviews Scraper | Manual copy-paste | TrustRadius API |
|---|---|---|---|
| Full review text | ✅ | ✅ | Limited |
| Pros and cons lists | ✅ | ✅ | Limited |
| Structured JSON output | ✅ | ❌ | ✅ |
| CSV / Excel export | ✅ | ❌ | ❌ |
| Bulk extraction (100+ reviews) | ✅ | ❌ | Requires partnership |
| No API key / login needed | ✅ | ✅ | ❌ |
| Automation and scheduling | ✅ | ❌ | Partial |
| Webhook / Zapier integration | ✅ | ❌ | ❌ |

### 🚀 How to use

1. **Sign up** - [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) on Apify
2. **Open the Actor** - navigate to the [TrustRadius Reviews Scraper](https://apify.com/parseforge/trustradius-reviews-scraper)
3. **Set the product URL** - paste the TrustRadius reviews page URL for any software product (e.g. `https://www.trustradius.com/products/salesforce-crm/reviews`)
4. **Set maxItems** - enter how many reviews you want (10 for a quick test, up to 1,000,000 for full datasets)
5. **Click Start** - the Actor runs and populates your dataset within seconds to minutes depending on volume
6. **Download your data** - export as JSON, CSV, Excel, or XML from the dataset tab

### 💼 Business use cases

#### 🧭 Competitive Intelligence

| Task | How to use |
|---|---|
| Monitor competitor reviews over time | Schedule the scraper weekly on competitor product URLs |
| Build competitive battlecards | Extract pros/cons and filter by rating to surface recurring themes |
| Track sentiment after product launches | Compare average ratings before and after a release date |
| Identify competitor weaknesses | Sort by lowest rating and analyze cons lists |

#### 📣 Voice of Customer

| Task | How to use |
|---|---|
| Feed your NPS analysis | Combine TrustRadius review text with your internal NPS data |
| Identify churn language | Look for con patterns that correlate with low ratings |
| Surface customer pain points | Aggregate cons across hundreds of reviews for theme analysis |
| Train sentiment classifiers | Use full review text and ratings as labeled training data |

#### 📊 Market Research

| Task | How to use |
|---|---|
| Category benchmarking | Scrape all top products in a category and compare average ratings |
| Buyer persona research | Analyze reviewer job titles and company sizes (if visible) |
| Feature demand mapping | Extract pros that mention specific features repeatedly |
| Pricing perception analysis | Search review text for price-related language |

#### 🏦 Due Diligence

| Task | How to use |
|---|---|
| Pre-acquisition product audits | Collect all reviews for a target company's product |
| Customer satisfaction benchmarks | Compare review volume and ratings against sector averages |
| Risk identification | Flag recurring cons related to security, uptime, or support |
| Longitudinal trend analysis | Compare review sentiment across different time periods |

### 🔌 Automating TrustRadius Reviews Scraper

Connect this Actor to your existing workflows with no code:

- **Make (Integromat)** - trigger the scraper on a schedule and send new reviews to a Google Sheet or Slack channel automatically
- **Zapier** - connect to 5,000+ apps; push new records to Notion, Airtable, HubSpot, or any CRM
- **Slack** - get a Slack message with a summary whenever a new batch of reviews is collected
- **Airbyte** - sync your TrustRadius dataset directly to Snowflake, BigQuery, or Redshift for BI analysis
- **GitHub Actions** - trigger a scrape run as part of your CI/CD or weekly reporting pipeline
- **Google Drive** - export results as CSV and save them automatically to a shared Drive folder
- **Webhooks** - use Apify's built-in webhook support to POST data to any endpoint when a run completes
- **Apify API** - call the Actor programmatically from Python, Node.js, or any HTTP client for full automation

### 🌟 Beyond business use cases

#### 🔬 Academic Research

Studying enterprise software adoption? TrustRadius reviews are rich qualitative data from named, verified buyers. Use this scraper to build corpora for NLP research, technology acceptance studies, or IT procurement behavior analysis - all from a single API call.

#### 🎓 Personal Learning

Building your first data pipeline or practicing sentiment analysis? Pull a few hundred Slack or Zoom reviews, load them into a Jupyter notebook, and experiment with text classification, topic modeling, or rating prediction - real data, zero scraping overhead.

#### 🤝 Non-Profit Technology Selection

Non-profits evaluating donated software need unbiased perspectives. Use this scraper to quickly aggregate hundreds of reviews for tools like Salesforce Nonprofit, Microsoft Teams, or Zoom before committing to a platform - no sales calls required.

#### 🧪 Experimentation

Want to test whether a new LLM can summarize enterprise software reviews? Or build a review comparison dashboard? This scraper gives you a clean, structured dataset to prototype against in minutes.

### 🤖 Ask an AI assistant about this scraper

- 💬 [ChatGPT](https://chat.openai.com/?q=How+do+I+use+the+TrustRadius+Reviews+Scraper+by+ParseForge+on+Apify%3F)
- 🧠 [Claude](https://claude.ai/new?q=How+do+I+use+the+TrustRadius+Reviews+Scraper+by+ParseForge+on+Apify%3F)
- 🔍 [Perplexity](https://perplexity.ai/search?q=How+do+I+use+the+TrustRadius+Reviews+Scraper+by+ParseForge+on+Apify%3F)

### ❓ Frequently Asked Questions

#### 🔑 Do I need a TrustRadius account or API key?

No. The scraper collects publicly available reviews without any authentication. Just paste the product URL and run.

#### 📦 How many reviews can I collect?

Free users are automatically limited to 10 reviews per run. Paid users can collect up to 1,000,000 reviews per run.

#### ⚡ How fast is the scraper?

Most product pages return results within seconds to a few minutes depending on review volume and server response times.

#### 📄 What export formats are available?

Results are available as JSON, CSV, Excel (XLSX), and XML directly from the Apify dataset page.

#### 🔄 Can I schedule recurring scrapes?

Yes. Use Apify's built-in scheduler to run this Actor daily, weekly, or monthly and track how reviews change over time.

#### 🔒 Are the reviews verified?

The `isVerified` field reflects TrustRadius's own verification badge. Verified reviews are from confirmed software buyers.

#### 🌐 Can I scrape multiple products at once?

The current version processes one product URL per run. To scrape multiple products, run the Actor separately for each URL or use Apify's API to trigger parallel runs.

#### 📅 Does the scraper capture the original review date?

Yes. The `reviewDate` field contains the date as published by TrustRadius (e.g. "January 11, 2026").

#### 🔗 Can I link back to the original review?

Yes. Each record includes `reviewUrl` - a direct permalink to the individual review on TrustRadius.

#### 🛑 What happens if a product has no public reviews?

The scraper will complete with zero records. No error is thrown. You can adjust the URL or try a different product.

#### 💬 Are pros and cons captured separately?

Yes. The `pros` and `cons` fields are arrays containing each point as a separate string, exactly as the reviewer wrote them.

#### 🔍 Can I filter reviews by rating or date?

Filtering is not currently available at the input level. Export the full dataset and apply your own filters in Excel, Python, or your BI tool.

### 🔌 Integrate with any app

| Platform | How |
|---|---|
| **Make (Integromat)** | Use the Apify module to trigger runs and map output fields |
| **Zapier** | Connect via the Apify Zapier app - no code needed |
| **Slack** | Post dataset summaries to any channel via webhook |
| **Airbyte** | Sync to Snowflake, BigQuery, Postgres, or Redshift |
| **GitHub Actions** | Call the Apify API from your workflow YAML |
| **Google Drive** | Save CSV exports automatically via Make or Zapier |
| **Webhooks** | Configure Apify webhooks to POST to any HTTP endpoint on run completion |
| **Apify API** | Full programmatic control via REST API or official SDKs (Python, JS) |
| **Google Sheets** | Connect via Make or Zapier to append new rows on each run |
| **Airtable** | Push structured records directly into any Airtable base |
| **Notion** | Send review summaries to a Notion database via Zapier |
| **HubSpot** | Enrich contact or deal records with product review sentiment |

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [G2 Reviews Scraper](https://apify.com/parseforge/g2-reviews-scraper) | Extract verified reviews from G2 - the largest B2B software review site |
| [Capterra Reviews Scraper](https://apify.com/parseforge/capterra-reviews-scraper) | Scrape user reviews from Capterra for any software category |
| [Trustpilot Reviews Scraper](https://apify.com/parseforge/trustpilot-reviews-scraper) | Pull consumer and business reviews from Trustpilot at scale |
| [Gartner Reviews Scraper](https://apify.com/parseforge/gartner-reviews-scraper) | Collect peer reviews from Gartner Peer Insights for enterprise software |
| [Feefo Reviews Scraper](https://apify.com/parseforge/feefo-reviews-scraper) | Extract verified merchant and product reviews from Feefo |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more scrapers covering reviews, listings, directories, and market data.

***

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA) to request a new scraper or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by TrustRadius or any of its affiliates. All trademarks are property of their respective owners. Only publicly available data is collected.

# Actor input Schema

## `productUrl` (type: `string`):

URL of the TrustRadius product reviews page. Example: https://www.trustradius.com/products/slack/reviews

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "productUrl": "https://www.trustradius.com/products/slack/reviews",
  "maxItems": 10
}
```

# 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 = {
    "productUrl": "https://www.trustradius.com/products/slack/reviews",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = {
    "productUrl": "https://www.trustradius.com/products/slack/reviews",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/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 '{
  "productUrl": "https://www.trustradius.com/products/slack/reviews",
  "maxItems": 10
}' |
apify call parseforge/trustradius-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TrustRadius Reviews Scraper - B2B Software Reviews",
        "description": "Scrape verified B2B software reviews from TrustRadius. Extract ratings, pros/cons, review text, and dates. Export to CSV, Excel, or JSON.",
        "version": "0.1",
        "x-build-id": "RoahBQABpoykPGZ33"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~trustradius-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-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/parseforge~trustradius-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-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/parseforge~trustradius-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-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",
                "required": [
                    "productUrl"
                ],
                "properties": {
                    "productUrl": {
                        "title": "Product URL",
                        "type": "string",
                        "description": "URL of the TrustRadius product reviews page. Example: https://www.trustradius.com/products/slack/reviews"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
