# TrustRadius Reviews API (`johnvc/trustradius-reviews-api`) Actor

TrustRadius B2B software reviews as clean, structured JSON. See which software alternatives each buyer compared and why they chose one, plus per-feature scores, ROI notes, pros and cons, and reviewer role, company size, and industry. Pay per review, MCP-ready for Claude and AI agents.

- **URL**: https://apify.com/johnvc/trustradius-reviews-api.md
- **Developed by:** [John](https://apify.com/johnvc) (community)
- **Categories:** AI, Social media, E-commerce
- **Stats:** 4 total users, 4 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.43 / 1,000 review returneds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 API: Software Alternatives and Buyer Comparisons

Find the software alternatives real buyers considered, in their own words. This API turns [TrustRadius](https://www.trustradius.com/) B2B software reviews into clean, structured JSON, including the field most review data leaves out: what the buyer weighed the product against, and why they picked it.

Reviews carry a written competitive comparison, per-feature numeric scores, return-on-investment notes, and the reviewer's role, company size, and industry, wherever the reviewer provided them. That combination is what turns review data into competitive intelligence rather than sentiment.

### What this B2B software reviews API returns

- **Competitive comparison:** what alternatives the buyer considered, in their own words, plus the differentiators they named and whether the purchase replaced an incumbent tool
- **Per-feature scores:** numeric ratings feature by feature, not just one overall star
- **Scored dimensions:** usability, support, and implementation, gathered into one object
- **Business outcomes:** return on investment, efficiencies gained, processes supported, renewal intent
- **Honest detail:** pros and cons as discrete points, easy and difficult tasks, support strengths and weaknesses, implementation issues
- **Reviewer context:** job title, company size, industry, years of experience, and whether the review was incentivized

Every review row also carries a one-line plain-language `summary`, so an AI agent can read a record without post-processing.

### Use cases: research software alternatives and compare vendors

- **Find out what buyers compare you against.** The alternatives field names real competitors from real evaluations, not from a marketing page.
- **Build a feature-level comparison.** Per-feature scores let you compare two products dimension by dimension instead of star to star.
- **Segment sentiment by buyer.** Company size, industry, and job title let you separate enterprise from SMB opinion.
- **Find switching stories.** Filter for reviews where the purchase replaced another product, and read why.
- **Weight reviews honestly.** The incentivized flag and years-of-experience field let you discount promotional reviews.
- **Fill a software vendor comparison grid.** Run two or three products in one go and put their feature scores side by side in a spreadsheet.

### Two modes, and which one to use

**Product mode** is the one most people want, and it is where you should start. Give it a product page URL from [TrustRadius](https://www.trustradius.com/) or a bare product slug, and it walks that product's review list and returns every review it finds, up to the cap you set. Product mode was re-verified working on 2026-08-08.

**Review mode** collects individual review URLs, one review each. Use it when you already hold a specific list of reviews, for example rows kept from an earlier run. Individual review URLs are awkward to gather by hand, which is why the examples below lead with product URLs.

Both modes return the same fields and are billed the same way. If the source's product pages are ever unreadable, you get a row carrying a plain-language message that says so rather than a silent empty result, and nothing is charged for it.

### Input parameters

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `mode` | string | **Required** | `review` | `product` discovers all reviews for a product. `review` collects specific review URLs. |
| `productUrls` | array of strings | Required in product mode | (none) | Product pages or bare product slugs, for example `https://www.trustradius.com/products/zoominfo-sales` or just `zoominfo-sales`. Up to 50 per run. |
| `reviewUrls` | array of strings | Required in review mode | (none) | Individual review URLs, for example `https://www.trustradius.com/reviews/zoominfo-sales-2025-04-15-13-25-48`. Up to 500 per run. |
| `maxReviewsPerProduct` | integer | Optional | `50` | Reviews per product in product mode, from 1 to 2000. You pay per review returned, so this is your cost control. |
| `pages` | integer | Optional | (source default) | How many pages of a product's review list to walk, from 1 to 25. Higher values reach older reviews. |

```json
{
  "mode": "product",
  "productUrls": ["zoominfo-sales"],
  "maxReviewsPerProduct": 50
}
```

Review mode takes the same shape with review URLs instead:

```json
{
  "mode": "review",
  "reviewUrls": [
    "https://www.trustradius.com/reviews/zoominfo-sales-2025-04-15-13-25-48"
  ]
}
```

### Example output

One dataset row per review. Every row carries a `result_type` of `review` or `error`, so a downstream job can split the two without guessing.

```json
{
  "result_type": "review",
  "productName": "GTM Workspace Powered by ZoomInfo",
  "reviewTitle": "ZoomInfo Sales - Data Prospecting",
  "reviewRating": 10,
  "pros": ["Prospect Data", "Account mapping", "Lists"],
  "cons": ["Adding an option to flag bad data information", "Finding LinkedIn"],
  "alternativesConsidered": "ZoomInfo Sales has more data, which in the long run is better. Other competitors rely heavily on LinkedIn.",
  "keyDifferentiators": ["Scalability", "Integration with Other Systems", "Ease of Use"],
  "productsReplaced": false,
  "featureRatings": [
    { "feature": "Advanced search", "rating": 9 },
    { "feature": "Identification of new leads", "rating": 9 }
  ],
  "ratings": { "usability": 9, "support": 10, "implementation": 10 },
  "returnOnInvestment": "Improved efficiency with prospect data.",
  "authorPosition": "Enterprise Development Representative",
  "authorCompanySize": "1001-5000 employees",
  "authorCompanyIndustry": "Security & Investigations",
  "summary": "10-out-of-10 review of GTM Workspace Powered by ZoomInfo from Enterprise Development Representative."
}
```

Beyond the fields above, each row can carry `reviewUrl`, `productUrl`, `reviewDate`, `likelihoodToRecommend`, `likelihoodToRenew`, `efficienciesGained`, `businessProcessesSupported`, `otherSoftwareUsed`, `usabilityPros` and `usabilityCons`, `easyTasks` and `difficultTasks`, `supportPros` and `supportCons`, `implementationIssues`, `authorExperienceYears`, and `authorIncentivized`, wherever the reviewer filled them in.

Two dataset views ship with the Actor: **Reviews overview** for a plain table of product, rating, title, and reviewer context, and **Competitive comparisons** for the alternatives, differentiators, replacement flag, and feature scores side by side.

An input that returns nothing produces a row with `result_type: "error"` and a plain-language `error_message`.

### Pricing

Pay per result. One event, `review-scraped`, is charged once for every review pushed to the dataset. Nothing is charged for an input that returns no reviews, including a product page the source cannot serve.

`maxReviewsPerProduct` caps what a run can cost, and the cap is applied at the source. Current rates are shown on the Store card.

### How to get started

1. [View on Apify Store](https://apify.com/johnvc/trustradius-reviews-api?fpr=9n7kx3) and click Try for free.
2. Set **Mode** to `product` and paste a product page URL or a bare slug such as `zoominfo-sales`.
3. Set **Max reviews per product** to the number you actually need. That is your cost ceiling.
4. Run it. Results appear on the Output tab and export as JSON, CSV, or Excel. The **Competitive comparisons** view puts the alternatives and differentiators side by side.

Prefer to start from code? The [example repo](https://github.com/johnisanerd/Apify-TrustRadius-Reviews-API) has a Python quick-start plus walkthroughs for adding this Actor as an MCP tool in Claude, Cursor, and ChatGPT.

### 🔌 Use this API from Claude (MCP)

Add this Actor as a tool in [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial), [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial), Cursor, or any other MCP client through the hosted Apify MCP server:

```
https://mcp.apify.com/?tools=actors,docs,johnvc/trustradius-reviews-api
```

With [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial):

```
claude mcp add --transport http trustradius "https://mcp.apify.com/?tools=actors,docs,johnvc/trustradius-reviews-api"
```

Then ask your agent something like "what did these buyers compare the product against, and what made them choose it".

https://www.youtube.com/watch?v=jREWahDGhJM

Apify MCP integration docs: https://docs.apify.com/platform/integrations/mcp

### 💸 Pay per run with crypto (x402)

The TrustRadius Reviews API supports agentic payments via the [x402 protocol](https://docs.apify.com/platform/integrations/x402).
AI agents and MCP clients can pay for runs in USDC (on Base) with no Apify account or API token needed:
point your agent at the [Apify MCP server](https://mcp.apify.com/?tools=actors,docs,johnvc/trustradius-reviews-api) and it can
discover, pay for, and run this Actor autonomously. Read the
[Apify x402 announcement](https://apify.com/change-log/pay-for-apify-actors-with-x402?fpr=9n7kx3) for details.

### 🔌 Integrations: Automate Competitive Review Monitoring

One run tells you what buyers said about a product yesterday. What you usually want to know is what changed over the last six months: which competitor started showing up in the alternatives field, which feature score slid. None of that is visible unless you run this on a schedule and keep the history somewhere. Apify connects the Actor to the rest of your stack through [platform integrations](https://docs.apify.com/platform/integrations).

#### Tasks and schedules, the part that matters

Save one [task](https://docs.apify.com/platform/actors/running/tasks) per product you care about, your own and each rival, then attach a single [schedule](https://docs.apify.com/platform/schedules) that fires all of them. In the Console, open the Actor, set your input, click **Save as task**, then use **Actions**, then **Schedule**.

Review sites move slowly, so weekly is usually the right cadence:

- `0 7 * * 1` every Monday at 7 AM, a weekly competitive read
- `0 */6 * * *` every six hours, for a launch week when you expect a burst
- `0 6 1 * *` the first of each month, if you only need a monthly rollup

One schedule can trigger many tasks, so a five-product watchlist is one schedule and five saved tasks. The Applications section below lists ready-made tasks you can clone as a starting point.

#### n8n, Make, and Zapier

There is no dedicated community node for this Actor yet, so use the official [Apify n8n integration](https://docs.apify.com/platform/integrations/n8n): Schedule Trigger, then the Apify node running `johnvc/trustradius-reviews-api`, then a Filter on `productsReplaced` or on a rating threshold, then Slack or email. The same four steps work in [Make](https://docs.apify.com/platform/integrations/make) and [Zapier](https://docs.apify.com/platform/integrations/zapier).

#### Keep the history in Supabase

Reviews are only worth much once you have a few months of them. Send each run into a table and query it later:

```python
from apify_client import ApifyClient
from supabase import create_client

apify = ApifyClient("APIFY_API_TOKEN")
db = create_client("SUPABASE_URL", "SUPABASE_SERVICE_KEY")

run = apify.actor("johnvc/trustradius-reviews-api").call(run_input={
    "mode": "product",
    "productUrls": ["zoominfo-sales"],
    "maxReviewsPerProduct": 50,
})

rows = [
    {
        "product": item["productName"],
        "rating": item.get("reviewRating"),
        "weighed_against": item.get("alternativesConsidered"),
        "differentiators": item.get("keyDifferentiators"),
        "replaced_a_tool": item.get("productsReplaced"),
        "reviewer_role": item.get("authorPosition"),
        "company_size": item.get("authorCompanySize"),
        "review_url": item.get("reviewUrl"),
    }
    for item in apify.dataset(run.default_dataset_id).iterate_items()
    if item.get("result_type") == "review"
]

db.table("trustradius_reviews").upsert(rows, on_conflict="review_url").execute()
```

The no-code version is the same idea: Apify node, then Supabase node, in n8n.

#### MCP and AI agents

Point an agent at the [Apify MCP server](https://mcp.apify.com/) and it can run this Actor itself. [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial), [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial), and Cursor all speak MCP. A question that works well: "pull the last 50 reviews for these three products and tell me which competitor is named most often in the alternatives field". The [AI competitor analysis task](https://apify.com/johnvc/trustradius-reviews-api/examples/run-ai-competitor-analysis-in-claude-via-mcp?fpr=9n7kx3) is set up for exactly that.

#### Webhooks

For anything custom, attach an [Apify webhook](https://docs.apify.com/platform/integrations/webhooks) on `ACTOR.RUN.SUCCEEDED` and have your own service pull the dataset the moment a run finishes.

### 🔗 Related Tools

Buyers check more than one review site before they sign anything, so one source only gets you part of the picture.

- [G2 Reviews API](https://apify.com/johnvc/g2-reviews-api?fpr=9n7kx3) covers the other large B2B software review site, so you can check whether a pattern holds across both.
- [Trustpilot Reviews API](https://apify.com/johnvc/trustpilot-reviews-api?fpr=9n7kx3) for consumer-facing business reviews, useful when the product also sells self-serve.
- [Glassdoor Reviews API](https://apify.com/johnvc/glassdoor-reviews-api?fpr=9n7kx3) for employer reviews, which often explain why a vendor's support quality moved.
- [Owler Company Intelligence API](https://apify.com/johnvc/owler-company-api?fpr=9n7kx3) returns the vendor's own stated competitor set, a useful cross-check against what buyers actually name.
- [Crunchbase Company API](https://apify.com/johnvc/crunchbase-company-api?fpr=9n7kx3) adds funding and firmographics, so a switching story can be read next to the vendor's runway.

For contrast, other TrustRadius Actors exist on the Store. The [TrustRadius Reviews Scraper](https://apify.com/parseforge/trustradius-reviews-scraper?fpr=9n7kx3) returns ratings, pros and cons, review text, and dates only; it does not return the alternatives the buyer weighed, the per-feature scores, or the replacement flag, its published run success rate is 83 percent, and its per-result price is roughly double this Actor's. Worth checking which fields are actually in the output before you build a comparison on top of one.

### Applications

Ready-to-run examples of this API in action. Open any one and run it in a single click.

#### Get B2B Software Reviews by API from Product URLs

Point it at a product page and pull the full review set as structured JSON.
[Run this task](https://apify.com/johnvc/trustradius-reviews-api/examples/b2b-software-reviews-api?fpr=9n7kx3)

#### Compare Software Vendors with Real Buyer Reviews

Put two vendors side by side on what buyers actually scored, not on marketing claims.
[Run this task](https://apify.com/johnvc/trustradius-reviews-api/examples/compare-software-vendors-with-real-buyer-reviews?fpr=9n7kx3)

#### Monitor Competitor Reviews for Competitive Intelligence

Watch a rival's review feed on a schedule and catch sentiment shifts early.
[Run this task](https://apify.com/johnvc/trustradius-reviews-api/examples/monitor-competitor-reviews-for-competitive-intelligence?fpr=9n7kx3)

#### Run AI Competitor Analysis in Claude via MCP

Hand the Actor to an agent and let it summarize who buyers compare you against.
[Run this task](https://apify.com/johnvc/trustradius-reviews-api/examples/run-ai-competitor-analysis-in-claude-via-mcp?fpr=9n7kx3)

#### Export a Software Comparison Spreadsheet from Reviews

Get a flat table of feature scores you can drop straight into Excel or Sheets.
[Run this task](https://apify.com/johnvc/trustradius-reviews-api/examples/export-a-software-comparison-spreadsheet-from-reviews?fpr=9n7kx3)

#### Find Competitive Displacement Signals in B2B Reviews

Surface the reviews where a buyer replaced an incumbent, and read what tipped it.
[Run this task](https://apify.com/johnvc/trustradius-reviews-api/examples/find-competitive-displacement-signals-in-b2b-reviews?fpr=9n7kx3)

#### Fill a Software Evaluation Matrix with Buyer Scores

Populate an evaluation matrix with per-feature numbers from real buyers.
[Run this task](https://apify.com/johnvc/trustradius-reviews-api/examples/fill-a-software-evaluation-matrix-with-buyer-scores?fpr=9n7kx3)

#### Run a Win Loss Analysis from Buyer Reviews

Read the alternatives and differentiators fields as a win loss record you did not have to run interviews for.
[Run this task](https://apify.com/johnvc/trustradius-reviews-api/examples/run-a-win-loss-analysis-from-buyer-reviews?fpr=9n7kx3)

#### See Which Rivals Overseas Buyers Compared (查看海外买家把你和哪些竞品放在一起比较)

Read the same competitive comparison fields with an overseas buyer audience in mind.
[Run this task](https://apify.com/johnvc/trustradius-reviews-api/examples/see-which-rivals-overseas-buyers-compared-zh?fpr=9n7kx3)

### ❓ FAQ

#### How do I find the software alternatives buyers considered?

Collect a product's reviews and read `alternativesConsidered`. Each entry is a buyer explaining, in their own words, what else they evaluated and why they chose what they chose. The **Competitive comparisons** dataset view shows that field next to the differentiators the buyer named.

#### How do I compare two B2B software products on real user reviews?

Collect reviews for both and compare `featureRatings` feature by feature, then `ratings` for usability, support, and implementation. That is a far finer comparison than two overall scores.

#### Which products do buyers replace most often?

Filter on `productsReplaced`. Reviews where it is true describe a switch, and the alternatives field usually names what was displaced.

#### Can I get per-feature ratings rather than one overall score?

Yes. `featureRatings` is an array of feature names with numeric scores, taken from the reviewer's own scoring.

#### What is the difference between product mode and review mode?

Product mode takes a product page or slug and discovers that product's reviews for you. Review mode takes individual review URLs and returns one review each. Product mode is the easier starting point because individual review URLs are hard to gather by hand.

#### How do I get individual review URLs?

Any review's own page URL works. They follow the pattern `trustradius.com/reviews/<product>-<timestamp>`, and you can gather them from the product page in a browser, from `reviewUrl` in an earlier product-mode run, or from your own existing list.

#### Are incentivized reviews marked?

Yes. `authorIncentivized` tells you whether the reviewer received something for writing it, which matters when you are weighting sentiment.

#### How is the rating scaled?

On the source's 1 to 10 scale, not 1 to 5. The summary line states it explicitly to avoid confusion.

#### Can I schedule this TrustRadius Scraper to run on its own?

Yes, and this is where most of the value is. Save your input as a [task](https://docs.apify.com/platform/actors/running/tasks), then attach a [schedule](https://docs.apify.com/platform/schedules) from the Actor's **Actions**, then **Schedule** menu. Weekly suits review data: `0 7 * * 1` runs every Monday at 7 AM, `0 */6 * * *` every six hours during a launch, `0 6 1 * *` on the first of the month. A single schedule can fire many tasks at once, so a whole competitor watchlist runs on one timer. The Integrations section above has the full monitoring recipe, including where to store the history.

#### Should I use an official API or a web Scraper for review data?

There is no public official [API](https://en.wikipedia.org/wiki/API) for this review data, which is why most teams end up doing [web scraping](https://en.wikipedia.org/wiki/Web_scraping) instead. This Actor sits in between: you get a clean JSON endpoint you call yourself, with no quota to negotiate and no browser automation to maintain, and you pay per review returned rather than per seat.

#### Can I use the TrustRadius Reviews API from the Apify API?

Yes. The Apify API runs the Actor, schedules it, and fetches datasets programmatically, and the `apify-client` package exists for both Python and Node.js. The ready-made snippets are on the [Actor's API tab](https://apify.com/johnvc/trustradius-reviews-api/api?fpr=9n7kx3), and the [example repo](https://github.com/johnisanerd/Apify-TrustRadius-Reviews-API) has a working Python quick-start.

#### Can I use this Actor through an MCP server?

Yes. Add it as a tool in any MCP client through the hosted [Apify MCP server](https://mcp.apify.com/) using the URL `https://mcp.apify.com/?tools=actors,docs,johnvc/trustradius-reviews-api`. [Claude Code](https://claude.ai/referral/uIlpa7nPLg) (free trial), [Claude Cowork](https://claude.ai/referral/uIlpa7nPLg) (free trial), and Cursor all work. See the [Apify MCP docs](https://docs.apify.com/platform/integrations/mcp) for client-specific setup.

#### Can I integrate this TrustRadius Scraper with other apps?

Yes. Through [Apify integrations](https://docs.apify.com/platform/integrations) the output can go almost anywhere: [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier), [Slack](https://docs.apify.com/platform/integrations/slack), Google Drive, and Google Sheets among them. For anything custom, a [webhook](https://docs.apify.com/platform/integrations/webhooks) on `ACTOR.RUN.SUCCEEDED` hands your own service the dataset as soon as a run finishes. The Integrations section above walks through the common setups.

#### How can I collect reviews from other B2B software review sites?

Run the same competitive read on the [G2 Reviews API](https://apify.com/johnvc/g2-reviews-api?fpr=9n7kx3) and compare the two sets, since the reviewer populations differ. [Trustpilot Reviews API](https://apify.com/johnvc/trustpilot-reviews-api?fpr=9n7kx3) covers consumer-facing sentiment, and [Glassdoor Reviews API](https://apify.com/johnvc/glassdoor-reviews-api?fpr=9n7kx3) covers what employees say about the vendor behind the product.

#### Is this an official TrustRadius API?

No. This Actor is not affiliated with, endorsed by, or connected to [TrustRadius](https://www.trustradius.com/). It returns public review data as structured JSON and is an independent tool.

#### What happens if an input returns nothing?

You get a row with `result_type: "error"` and a plain-language `error_message` naming the input that failed, so a failed URL is visible instead of silently missing. Rows like that are not charged.

#### Is it legal to scrape software review data?

Collecting publicly available information is generally permitted, though what you then do with it is governed by copyright, database rights, and privacy law in your jurisdiction. Apify's write-up on [the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) is a reasonable starting point. Ask your own counsel about your specific use.

### 🌐 About Alpha OSINT

This Actor is part of [Alpha OSINT](https://www.alphaosint.com), toolset of financial and operations data sources and APIs.
For support or requests for this actor, please start a ticket [directly on our support page](https://apify.com/johnvc/trustradius-reviews-api/issues/open?fpr=9n7kx3).

Last Updated: 2026.08.10

# Actor input Schema

## `mode` (type: `string`):

Review collects specific review URLs, one review each. Product discovers every review from a product's reviews page. Product mode depends on the source's product pages being readable; if they are not, you get a clear message and can fall back to review mode.

## `reviewUrls` (type: `array`):

Individual review URLs, for example https://www.trustradius.com/reviews/zoominfo-sales-2025-04-15-13-25-48. Used in review mode. Up to 500 per run. One review-scraped event is charged per review returned; URLs that return nothing are not charged.

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

Product pages or bare product slugs, for example https://www.trustradius.com/products/zoominfo-sales or just 'zoominfo-sales'. Used in product mode. Up to 50 per run.

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

How many reviews to return per product in product mode. You are charged per review returned, so this is also your cost control.

## `pages` (type: `integer`):

How many pages of a product's review list to walk in product mode. Higher values reach older reviews.

## Actor input object example

```json
{
  "mode": "review",
  "reviewUrls": [
    "https://www.trustradius.com/reviews/zoominfo-sales-2025-04-15-13-25-48"
  ],
  "maxReviewsPerProduct": 50
}
```

# Actor output Schema

## `allResults` (type: `string`):

Every dataset item from this run: collected reviews and any error rows.

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

Tabular overview: product, rating, title, reviewer role, company size and industry.

## `competitive` (type: `string`):

What each buyer weighed the product against, the differentiators they named, whether it replaced an incumbent, and per-feature scores.

# 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 = {
    "reviewUrls": [
        "https://www.trustradius.com/reviews/zoominfo-sales-2025-04-15-13-25-48"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("johnvc/trustradius-reviews-api").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 = { "reviewUrls": ["https://www.trustradius.com/reviews/zoominfo-sales-2025-04-15-13-25-48"] }

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

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

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

```

## CLI example

```bash
echo '{
  "reviewUrls": [
    "https://www.trustradius.com/reviews/zoominfo-sales-2025-04-15-13-25-48"
  ]
}' |
apify call johnvc/trustradius-reviews-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,johnvc/trustradius-reviews-api"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Tb1DVc1tVAN5m23bp/builds/saXQWLFqZcTeRhgkk/openapi.json