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

Scrape every TrustRadius review of any B2B software product: rating, pros, cons, use case, likelihood to recommend, feature ratings, alternatives, reviewer role, industry and company size. By product URL, slug or keyword search. From US$3 per 1,000 reviews.

- **URL**: https://apify.com/fabrikit/trustradius-reviews-scraper.md
- **Developed by:** [Fabrikit](https://apify.com/fabrikit) (community)
- **Categories:** AI, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 review 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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## TrustRadius Reviews Scraper

Scrape **every TrustRadius review of any B2B software product** into clean, analysis-ready JSON. Give it a product URL (`https://www.trustradius.com/products/hubspot-crm/reviews`), a bare slug (`hubspot-crm`) or just a keyword, and it returns each review with its **10-point rating, title, use case, pros, cons, likelihood to recommend (with the reviewer's explanation), return on investment, alternatives considered, other software used, per-feature ratings**, and the reviewer's **role, department, industry, company size and country**. No browser, no login, no API key.

What you get from a single run:

- **The full review, not a snippet.** Every published question-and-answer of the review form is returned: the headline fields as their own columns, plus a `sections` list and a ready-to-use `fullText` for LLM pipelines.
- **The whole review history.** Pagination goes all the way: 1,000 reviews take about 25 seconds. Set `maxReviewsPerProduct` above the product's review count to get every review.
- **B2B buyer context on every row**: reviewer job level, department, industry, company size band and country — the segmentation that makes TrustRadius data valuable — with **no reviewer names**.
- **Trust signals**: review source (vendor-invited, TrustRadius outreach, community), incentive, trusted-source flag, work-email verification and TrustRadius' own A/B/C quality grade, so you can weight or filter reviews.
- **Product context**: product name, vendor, category, TrScore and total review count on every row, and a per-product summary (rating breakdowns, feature averages) in the key-value store.
- **Find products by keyword** when you don't have the URLs: `searchQuery: "zendesk"` resolves the best-matching products that have reviews.

### Example output item

A real review, unedited except that the `featureRatings` (27 entries), `sections` and `fullText` arrays are shortened here:

```json
{
    "reviewId": "6a9acd7749470e91003cfdfc",
    "reviewUrl": "https://www.trustradius.com/reviews/hubspot-crm-2026-09-04-08-53-58",
    "productId": "552826bca2f0781500fa6c87",
    "productSlug": "hubspot-crm",
    "productName": "HubSpot CRM",
    "productUrl": "https://www.trustradius.com/products/hubspot-crm/reviews",
    "vendorName": "HubSpot",
    "productCategory": "Customer Relationship Management (CRM)",
    "productTrScore": 8.4,
    "productReviewCount": 1762,
    "title": "You can't miss HubSpot if you are considering a CRM",
    "rating": 8,
    "likelihoodToRecommend": 8,
    "likelihoodToRenew": null,
    "usabilityRating": 9,
    "supportRating": null,
    "implementationRating": null,
    "ratings": [
        { "name": "Likelihood to Recommend", "value": 8 },
        { "name": "Usability", "value": 9 }
    ],
    "useCases": "I used HubSpot and deployed it in my previous company as there was no CRM in place. HubSpot seemed to be the easiest and most powerful CRM amongst all the potential candidates. The integration abilities of HubSpot were particularly important for the company and HubSpot answered this requirement thanks to its vast marketplace.",
    "pros": [
        "Simple UI",
        "Integration abilities",
        "Easy configuration and customisation"
    ],
    "cons": [
        "Pricing can be adapted to smaller companies",
        "Rights management can be tricky to master",
        "Marketing module should be more powerful in standard"
    ],
    "recommendationContext": "HubSpot can work for companies of many sizes, that is the beauty of it. Whether you're a small company or a large one, you can adapt easily the solution to your needs. With a bit of time invested to understand all the configuration options, you can really craft a tailor-made CRM answering the needs of your business and teams.",
    "returnOnInvestment": [
        "Greater visibility on business opportunities helped the sales team to manage in a better way the business and improve the accuracy of the pipeline and the win rate",
        "Having all the contacts, companies and interactions saved heaps of time and improve the communication quality for the whole business",
        "The marketing module in Pro version was too expensive to buy despite all the benefits if could bring. We had to juggle between HubSpot and another tool for our emailing campaigns"
    ],
    "alternativesConsidered": ["Freshsales"],
    "alternativesComment": "HubSpot was more turnkey and easy to deploy rather than Freshsales. The cost of Freshdesk was cheaper but when you look for a CRM, price shouldn't be the only parameter to consider when making your choice. Freshsales was a great solution too but the integration capabilities were more limited than HubSpot and we wanted something to integrate almost from scratch.",
    "otherSoftwareUsed": ["Freshdesk", "Brevo", "PaperCut"],
    "featureRatings": [
        { "feature": "Customer data management / contact management", "featureId": "54bffd712e5757a94cb16deb", "rating": 8 },
        { "feature": "Workflow management", "featureId": "54bffd712e5757a94cb16dec", "rating": 8 },
        { "feature": "Opportunity management", "featureId": "54bffd712e5757a94cb16dee", "rating": 8 }
    ],
    "sections": [
        {
            "section": "Overall Satisfaction",
            "question": "Pros",
            "answer": "Simple UI\nIntegration abilities\nEasy configuration and customisation",
            "comment": null
        }
    ],
    "fullText": "Use Cases and Deployment Scope:\nI used HubSpot and deployed it in my previous company as there was no CRM in place. ...",
    "publishedAt": "2026-09-09T15:50:19.121Z",
    "updatedAt": "2026-09-06T10:41:24.837Z",
    "reviewerJobType": "C-Level Executive",
    "reviewerDepartment": "Information Technology",
    "companyIndustry": "Computer Software",
    "companySize": "11-50 employees",
    "reviewerCountry": "FRA",
    "yearsOfExperience": 3,
    "usageStatus": "recent",
    "reviewSource": "RaaS",
    "incentive": "TrustRadius",
    "incentivized": true,
    "trustedSource": true,
    "workEmailVerified": false,
    "qualityGrade": "B",
    "scrapedAt": "2026-10-12T16:00:15.596Z"
}
```

### How to scrape TrustRadius reviews

1. Put one or more products in **Products** — a product URL (any sub-page of it works), a bare slug, a review permalink, or a product id.
2. Or type a **Search query** (a product or vendor name works best) and choose how many matching products to take.
3. Set **Max reviews per product**. The Actor reads 100 reviews per request, so 1,000 reviews = 10 requests.
4. Optionally pick a **Sort order** and a **reviewsSince** date filter.
5. Press **Start**. Reviews land in the dataset and export as JSON, CSV or Excel, or sync to Google Sheets, webhooks, Zapier, Make or the Apify API.

#### Input examples

All reviews of three competitors:

```json
{
    "products": [
        "https://www.trustradius.com/products/zendesk-support-suite/reviews",
        "https://www.trustradius.com/products/hubspot-crm/reviews",
        "asana"
    ],
    "maxReviewsPerProduct": 100000
}
```

Weekly monitoring — only what was published in the last 7 days:

```json
{
    "products": ["hubspot-crm", "zoho-crm"],
    "sortBy": "newest",
    "reviewsSince": "7 days",
    "maxReviewsPerProduct": 500
}
```

Find products by keyword and pull their most critical reviews:

```json
{
    "searchQuery": "zendesk",
    "maxSearchResults": 3,
    "sortBy": "lowestRated",
    "maxReviewsPerProduct": 50
}
```

| Input | Description |
|---|---|
| `products` | One product per line: `https://www.trustradius.com/products/<slug>/reviews` (any sub-page), `<slug>`, a review permalink `https://www.trustradius.com/reviews/<slug>-<date>`, or the 24-character product id. Renamed products keep working with their old slug. Duplicates are collapsed. |
| `searchQuery` | Optional keyword. Takes the best-matching products **that have reviews**: products whose name contains every word come first, ordered by review count. Product and vendor names work best (`zendesk`, `hubspot`, `asana`). |
| `maxSearchResults` | How many products to take from the search (default 3). |
| `maxReviewsPerProduct` | Cap **per product** (default 50). Use 100000 for everything. |
| `sortBy` | `newest` (default), `oldest`, `highestRated`, `lowestRated`. |
| `reviewsSince` | `2026-01-01`, or relative: `30 days`, `6 months`, `1 year`. With `newest` the Actor stops as soon as it reaches older reviews. |
| `proxyConfiguration` | Not needed — see FAQ. |

### Output fields

| Field | Type | Description |
|---|---|---|
| `reviewId` | string | TrustRadius review id, stable across runs — use it to dedupe and diff |
| `reviewUrl` | string | Review permalink |
| `productId`, `productSlug`, `productName`, `productUrl` | string | The product reviewed |
| `vendorName` | string | Vendor of the product |
| `productCategory` | string | Primary TrustRadius category |
| `productTrScore` | number | Product's overall TrScore (0–10) at scrape time |
| `productReviewCount` | number | Product's published review count at scrape time |
| `title` | string | Review headline |
| `rating` | number | Overall rating, 1–10 |
| `likelihoodToRecommend` | number | 1–10 |
| `likelihoodToRenew`, `usabilityRating`, `supportRating`, `implementationRating` | number | null | Sub-ratings (1–10), only when the reviewer answered them |
| `ratings` | array | Every numeric rating in the review as `{name, value}` |
| `useCases` | string | "Use Cases and Deployment Scope" answer |
| `pros`, `cons` | string\[] | Bullet lists, one item per bullet |
| `recommendationContext` | string | Where the product is well suited / less appropriate |
| `returnOnInvestment` | string\[] | ROI bullets |
| `alternativesConsidered` | string\[] | Competing products evaluated |
| `alternativesComment` | string | Why this product was chosen over them |
| `otherSoftwareUsed` | string\[] | Other tools in the reviewer's stack |
| `featureRatings` | array | `{feature, featureId, rating}` per rated feature (N/A answers dropped) |
| `sections` | array | Every published answer: `{section, question, answer, comment}` — includes any custom questions |
| `fullText` | string | All answers as one text block, ready for an LLM |
| `publishedAt`, `updatedAt` | string | ISO 8601 timestamps |
| `reviewerJobType` | string | Job level / role, e.g. `Manager`, `Director`, `C-Level Executive`, `Account Manager` |
| `reviewerDepartment` | string | e.g. `Marketing`, `Information Technology`, `Sales` |
| `companyIndustry` | string | Reviewer's company industry |
| `companySize` | string | Size band, e.g. `51-200 employees` |
| `reviewerCountry` | string | ISO 3166 alpha-3 country code, e.g. `USA`, `GBR` |
| `yearsOfExperience` | number | Years using the product |
| `usageStatus` | string | `current`, `recent` or `older` user |
| `reviewSource` | string | How the review was collected: `VendorSourced`, `RaaS`, `DirectOutreach`, `CommunityInvite`, `CommunityInbound` |
| `incentive`, `incentivized` | string, boolean | Who offered the reviewer an incentive (`TrustRadius`, `Vendor`, `No`) |
| `trustedSource` | boolean | TrustRadius' trusted-source flag |
| `workEmailVerified` | boolean | null | Work-email check, when TrustRadius ran one |
| `qualityGrade` | string | TrustRadius' review quality grade, `A`–`C` |
| `scrapedAt` | string | When this item was scraped |

**Product summaries.** The run's key-value store has a `PRODUCTS` record with one entry per product: TrScore, rating count, review count, average of every rating question (likelihood to recommend, usability, support…), the average of every feature, categories, homepage, logo, free version / trial flags and deployment types. A `SUMMARY` record lists products resolved, reviews per product, requests and any errors. Both are free.

### Pricing

Pay per result — you only pay for reviews delivered.

| Event | When it is charged |
|---|---|
| Review (`review-result`) | Per review saved |
| Actor start | Once per run (a fraction of a cent) |
| Product summaries, search, run summary | free |

1,000 reviews cost US$3 on the Apify Free plan, and the same per-review price applies on paid plans — see the **Pricing** tab for the current rate. Typical costs at that rate: 50 reviews ≈ US$0.15, all 1,762 reviews of HubSpot CRM ≈ US$5.30. Set a maximum charge on the run and the Actor stops cleanly when it is reached.

### Performance & limits

- **Speed**: about 1,000 reviews in 25 seconds (measured on the Apify platform with 1 GB; the default is now 512 MB, well above the ~110 MB the Actor needs). No proxy is needed.
- **Sub-ratings are sparse by nature.** The current review form asks for likelihood to recommend and usability; support, implementation and renewal ratings appear mostly in older, longer-form reviews. Missing answers are `null`, never invented.
- **Reviewer identity is not collected.** TrustRadius shows some reviewers' names; this Actor never reads or outputs them — only role, department, industry, company size and country.
- **Order**: the dataset follows `sortBy` exactly; reviews with the same rating are ordered newest first.
- **Keyword search is fuzzy.** For exact targeting use product URLs or slugs.

### What can you do with TrustRadius review data?

- **Competitive intelligence**: pull every review of your top three competitors and cluster their `cons` — that's your roadmap and your sales battlecard.
- **Win/loss insight**: `alternativesConsidered` + `alternativesComment` tell you who you are compared against and why buyers chose one product over another.
- **ICP and segmentation**: split ratings by `companySize`, `companyIndustry`, `reviewerDepartment` and `reviewerJobType` to see where a product delights and where it struggles.
- **Feature gap analysis**: average `featureRatings` across products to see which capability each one is weak at.
- **Voice-of-customer for marketing**: 9–10 ratings give you buyer language for copy; `recommendationContext` says exactly which use case a product fits.
- **Monitoring**: schedule weekly with `sortBy: "newest"` and `reviewsSince: "7 days"`, dedupe on `reviewId`, and alert on new negative reviews.
- **LLM / RAG**: `fullText` plus product and segment metadata is a ready-made corpus for summarization and Q\&A over B2B software feedback.

### Integrations

Every Apify dataset exports to **CSV, Excel, JSON, XML or HTML** and syncs to **Google Sheets**. Run the Actor through the Apify API or the JavaScript and Python clients, trigger follow-ups with **webhooks**, or **schedule** weekly runs in Apify Console. It plugs into **n8n, Make and Zapier**, and into **LangChain and LlamaIndex** through their Apify integrations. AI agents in **Claude, ChatGPT, Cursor** and other MCP clients can find and run it through **Apify's MCP server**. From Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("fabrikit/trustradius-reviews-scraper").call(run_input={
    "products": ["https://www.trustradius.com/products/hubspot-crm/reviews"],
    "maxReviewsPerProduct": 500,
    "sortBy": "newest",
})
for review in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(review["rating"], review["companySize"], review["title"])
```

### FAQ

**Do I need a TrustRadius account, an API key or a proxy?**
No. The Actor reads the same public data the review pages show. It runs without a proxy; if TrustRadius ever starts blocking a run, it switches to Apify Proxy automatically (datacenter first, then US residential) and says so in the log.

**What rating scale does TrustRadius use?**
1 to 10 for every rating, including the overall `rating` and `featureRatings`. `productTrScore` is TrustRadius' weighted product score on the same 0–10 scale.

**Why do some reviews have `alternativesConsidered` or `supportRating` empty?**
Because the reviewer didn't answer that question. The review form is long and most questions are optional.

**Why does `productReviewCount` differ slightly from the number of reviews I got?**
TrustRadius updates its counters periodically, so a review published in the last hours may already be returned while the counter still shows the previous number.

**Can I get only new reviews since my last run?**
Yes: `sortBy: "newest"` with `reviewsSince` (for example `"7 days"`), and dedupe on `reviewId`.

**Is scraping TrustRadius legal?**
See *Is it legal to scrape TrustRadius?* below.

**Something broke?**
TrustRadius' internal API is undocumented. The Actor validates every response and fails with a clear message (instead of silently returning nothing) if the format changes. Open an issue on the Actor page and it will be fixed quickly.

### Is it legal to scrape TrustRadius?

The Actor collects publicly visible review content and aggregate reviewer attributes, without logging in, and deliberately skips reviewer names. Role, department, industry, company size and country can still make a reviewer identifiable in combination, so data-protection laws such as the EU GDPR, Chile's Ley 21.719 or the California CCPA may apply to how you store and use the data; you are responsible for a lawful purpose and for keeping only what you need. Use the data in line with TrustRadius' terms — for example, for analysis rather than republishing reviews wholesale, since review texts belong to their authors. This is general information, not legal advice.

### Use with AI agents

Use this actor to get every public TrustRadius review of a B2B software product (by URL, slug or keyword), with 1–10 ratings, pros, cons, alternatives considered and the reviewer's role, industry and company size (never names).

```json
{ "products": ["hubspot-crm"], "sortBy": "newest", "maxReviewsPerProduct": 50 }
```

Main output fields: `productName`, `title`, `rating`, `likelihoodToRecommend`, `pros`, `cons`, `alternativesConsidered`, `featureRatings`, `fullText`, `publishedAt`, `reviewerJobType`, `companyIndustry`, `companySize`. It is pay-per-event: an agent pays a small start fee plus a fixed price per review saved, not for compute time.

### Related actors

- [App Reviews Scraper](https://apify.com/fabrikit/app-reviews-unified) — App Store and Google Play reviews of mobile apps in one run.
- [Shopify App Store Reviews Scraper](https://apify.com/fabrikit/shopify-app-store-reviews-scraper) — reviews of Shopify apps.
- [Chrome Web Store Reviews Scraper](https://apify.com/fabrikit/chrome-web-store-reviews-scraper) — reviews of browser extensions, including many SaaS companions.
- [Chrome Web Store Scraper](https://apify.com/fabrikit/chrome-web-store-scraper) — extension listings with users, ratings and developer details.
- [ATS Jobs Scraper](https://apify.com/fabrikit/ats-jobs-api) — see what a software vendor is hiring for.

#### Ready-made examples

- [CRM software reviews from TrustRadius](https://apify.com/fabrikit/trustradius-reviews-scraper/examples/crm-software-reviews)

### Changelog

- **2026-10-16** — README: legal notes, integrations, AI-agent usage, related actors and example task added.
- **2026-10-15** — Published on the Apify Store. Default memory lowered from 1,024 to 512 MB.
- **2026-10-12** — Builds 0.1.1–0.1.2: initial release with product URLs, slugs, permalinks and keyword search; full review form, buyer context and trust signals; per-product summaries in the key-value store.

### En español

**TrustRadius Reviews Scraper** extrae todas las reseñas de cualquier software B2B publicado en TrustRadius: calificación de 1 a 10, título, casos de uso, pros, contras, probabilidad de recomendar (con la explicación del revisor), retorno de inversión, alternativas evaluadas, otro software usado y calificación por funcionalidad, más el cargo, área, industria, tamaño de empresa y país del revisor (nunca su nombre). Acepta la URL del producto, el slug o una búsqueda por palabra clave; recorre el historial completo de reseñas, filtra por fecha y ordena por más recientes o por calificación. No requiere cuenta, API key ni proxy. Precio: US$3 por cada 1.000 reseñas; los resúmenes por producto son gratis.

# Actor input Schema

## `products` (type: `array`):

TrustRadius products to scrape, one per line. Accepts a product URL (`https://www.trustradius.com/products/hubspot-crm/reviews`, any sub-page works), a bare slug (`hubspot-crm`), a review permalink (the product is taken from it) or a 24-character product id. Old slugs of renamed products resolve to the current product.

## `searchQuery` (type: `string`):

Find products by keyword with TrustRadius' own search (e.g. `zendesk`, `hubspot`, `project management`) and scrape the top matches that have reviews. Combined with the Products list if both are set. For precise targeting, use product URLs instead.

## `maxSearchResults` (type: `integer`):

How many products (with at least one review) to take from the search results, in TrustRadius relevance order.

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

Stop after this many reviews for each product. Set it above the product's review count (e.g. 100000) to get every review — the largest products have 1,000–6,000.

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

Order in which reviews are collected. `newest` is the right choice for monitoring and for the date filter (it stops as soon as it reaches older reviews).

## `reviewsSince` (type: `string`):

Optional date filter: an absolute date (`2026-01-01`) or a relative period (`30 days`, `6 months`, `1 year`). Leave empty for all reviews.

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

Not needed: TrustRadius' data API answers plain requests. If it ever blocks a run, the Actor switches to Apify Proxy on its own (datacenter first, then US residential).

## Actor input object example

```json
{
  "products": [
    "https://www.trustradius.com/products/hubspot-crm/reviews"
  ],
  "searchQuery": "",
  "maxSearchResults": 3,
  "maxReviewsPerProduct": 50,
  "sortBy": "newest",
  "reviewsSince": "",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All reviews collected during the run

## `products` (type: `string`):

One record per product: TrScore, rating and review counts, per-question and per-feature averages, categories

## `summary` (type: `string`):

Products resolved, reviews per product, requests, proxy tier used and errors

# 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 = {
    "products": [
        "https://www.trustradius.com/products/hubspot-crm/reviews"
    ],
    "searchQuery": "",
    "maxReviewsPerProduct": 50,
    "reviewsSince": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabrikit/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 = {
    "products": ["https://www.trustradius.com/products/hubspot-crm/reviews"],
    "searchQuery": "",
    "maxReviewsPerProduct": 50,
    "reviewsSince": "",
}

# Run the Actor and wait for it to finish
run = client.actor("fabrikit/trustradius-reviews-scraper").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 '{
  "products": [
    "https://www.trustradius.com/products/hubspot-crm/reviews"
  ],
  "searchQuery": "",
  "maxReviewsPerProduct": 50,
  "reviewsSince": ""
}' |
apify call fabrikit/trustradius-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

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/lTPSx4p2hN0VGBFL2/builds/a68eDRwUwRROi3bTo/openapi.json