# TrustRadius $1💰 Reviews, Products, Category & Compare Scraper (`memo23/trustradius-scraper`) Actor

💰 $1 per 1,000 results TrustRadius all-in-one scraper — product, reviews, category & compare URLs in one actor. Flat per-review rows with full Q\&A sections, reviewer firmographics & LinkedIn URL, dual 0–10/0–5 ratings, awards & featureList. Sitemap-driven bulk mode. Pure HTTP, no browser.

- **URL**: https://apify.com/memo23/trustradius-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Automation, Agents, Lead generation
- **Stats:** 36 total users, 4 monthly users, 94.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#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, Products, Categories & Compare Scraper

### How it works

![How TrustRadius Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-trustradius.png)

### 🧠 NEW: AI Pain-Point Analysis — reviews → product intel

Flip on **`painPointAnalysis`** and the scraper doesn't just return reviews — it tells you **what to fix and build next**. After scraping, one AI pass per product clusters every complaint into ranked themes and surfaces the features users keep asking for. One `painPointAnalysis` row per product, straight from real TrustRadius reviews. Paid plans only, billed per product analyzed.

All-in-one TrustRadius.com scraper — paste any mix of URL kinds in the same input list and the actor auto-classifies each one:

| Input | Row(s) emitted |
|---|---|
| **Any product URL** — `/products/{slug}`, `/products/{slug}/reviews`, or `/products/{slug}/reviews/all` | **1 product row + N review rows** — all three variants are treated identically. The actor fetches both the product page (rich `SoftwareApplication` JSON-LD with name/description/awards/featureList/vendor + 5 sample reviews with `reviewer.profilePicUrl` + `linkedInUrl` nested) and `/reviews/all` (paginated full review thread, 10 per page). Review count capped by `maxReviewsPerProduct`. |
| **Category URL** — `/categories/{slug}` (e.g. `collaboration`, `crm`) | **N category-product rows** — one per product in the category (`rowType: "category-product"`). Each row carries a nested `categoryAggregate` with description, total count, **FAQs** (from JSON-LD `FAQPage`), and related categories. |
| **Compare URL** — `/compare-products/{slug-a}-vs-{slug-b}` | 1 compare row: side-by-side products with ratings, vendor info, logos |
| **Sitemap URL** — `/sitemap_index.xml` | **Bulk discovery** — expands the sitemap into product URLs and scrapes the first `maxProductsFromSitemap` (default 50). |

Bare product slugs (`slack`) also work. JSON + CSV.

> **One product URL → product overview + every review.** You don't need to paste both `/reviews` and `/reviews/all` — any product-shaped URL gives you the full coverage. The three variants (`/products/slack`, `/products/slack/reviews`, `/products/slack/reviews/all`) all dedupe to the same canonical URL internally.

> **Reviews are flat with the aggregate denormalized into every row.** Every dataset row from a reviews URL is a single review. The thread-level aggregate (rating, awards, features, vendor info, total reviews, pages scraped) lives under each row's `productAggregate` field — duplicated on every review row from the same URL, but that keeps each row self-contained and makes billing trivial: one row = one paid `outputrecord` event.

> Pure HTTP. No Puppeteer, no Playwright, no headless Chromium. TrustRadius is open (no Cloudflare) so we use a simple impit Firefox fingerprint at concurrency 5.

***

TrustRadius's anti-bot posture is far gentler than Capterra's or G2's — there's **no Cloudflare gate, no challenge JS, no IP banning** at our request volume. We confirmed this with parallel probes across 9 URL kinds: every one returned 200 on the first impit attempt through Apify Residential US. `robots.txt` is permissive — `/products/`, `/categories/`, `/compare-products/`, and `/sitemap_index.xml` are all crawl-allowed.

So no warmup, no session rotation, no cookie jar. We fan out parallel requests through a sliding-window scheduler (default concurrency 5).

#### Data architecture

- **Product / reviews / category pages** use Next.js App-router with `__next_f.push` RSC streaming + comprehensive JSON-LD. We extract structured data from both sources:
  - `SoftwareApplication` JSON-LD ships `aggregateRating`, `featureList`, `award`, `offers`, **plus 5 fully-structured `review[]` objects** (Person author + Rating + reviewBody + datePublished).
  - The RSC stream carries `reviewer:{firstName, lastName, jobTitle, companyName, companySize, department, user:{pictureUrl, linkedInProfileUrl, linkedInIsVerified}}` blocks per visible review — same brace-balanced extractor we proved on Capterra.
- **`/reviews/all?page=N`** is the paginated review thread: 10 visible `<article>` cards per page, JSON-LD only carries `aggregateRating` here. We DOM-walk articles for title + date + rating + section headings (Q\&A) and align them with RSC reviewer blocks for firmographics.
- **`/categories/{slug}`** has `ItemList` JSON-LD (product cards), `FAQPage` JSON-LD (editorial Q\&A), and `BreadcrumbList` — three structured sources we merge into one row per product.
- **`/compare-products/{a}-vs-{b}`** is HTML-only (6 MB of editorial content; no embedded data JSON). We extract product info per slug via visible card walking — best-effort in v1.

***

### Input

Field | Type | Required | Notes
\--- | --- | --- | ---
`startUrls` | `string[]` | yes | Any mix of product / reviews / category / compare / sitemap URLs (or bare product slugs). Auto-classified.
`maxItems` | `integer` | no | Safety cap on **total dataset rows**, not URLs. A reviews URL with 100 reviews emits 100 review rows; a category URL with 50 products emits 50 rows. Default `1000`. Free-tier users are capped at `100`.
`maxReviewsPerProduct` | `integer` | no | Max individual review rows emitted per reviews URL. TrustRadius paginates 10 per page; Slack has ~10,000 reviews across ~1,000 pages — cap aggressively. Default `100`, `0` = no limit.
`maxProductsPerCategory` | `integer` | no | Max category-product rows emitted per category URL. Default `50`, `0` = no limit.
`maxProductsFromSitemap` | `integer` | no | When you paste a sitemap URL, the actor discovers product URLs and scrapes the first N. Default `50`.
`normalizeRatings` | `boolean` | no | Add `averageNormalized` (0–5 scale) alongside native 0–10. Default `true`.
`includeReviewSections` | `boolean` | no | Include full per-question `sections[]` on each review row. Adds 1–3 KB per row but captures TrustRadius's unique Q\&A structure. Default `true`.
`maxConcurrency` | `integer` | no | Parallel HTTP requests. TrustRadius is open — concurrency up to 10 is safe. Default `5`.
`maxRequestRetries` | `integer` | no | Per-URL retry budget on 5xx/network errors. Default `3`.
`proxy` | object | no | Apify Residential US recommended.

#### Example input

```json
{
  "startUrls": [
    "https://www.trustradius.com/products/slack",
    "https://www.trustradius.com/categories/collaboration",
    "https://www.trustradius.com/compare-products/slack-vs-microsoft-teams"
  ],
  "maxItems": 100,
  "maxReviewsPerProduct": 30,
  "maxProductsPerCategory": 20,
  "normalizeRatings": true,
  "includeReviewSections": true,
  "proxy": { "useApifyProxy": true, "apifyProxyGroups": ["RESIDENTIAL"], "apifyProxyCountry": "US" }
}
```

That yields **52 rows** on Slack: 1 product row (with 5 rich nested review snippets + LinkedIn URLs) + 30 flat review rows (paginated `/reviews/all`, with `productAggregate` nested) + 20 category-product rows + 1 compare. Use `maxItems` / `maxReviewsPerProduct` / `maxProductsPerCategory` to cap per-URL fan-out.

***

### Output schema

Four row shapes, distinguished by the `rowType` field: `product`, `review`, `category-product`, `compare`.

#### `rowType: "product"`

```jsonc
{
  "rowType":             "product",
  "productUrl":          "https://www.trustradius.com/products/slack/reviews",
  "productSlug":         "slack",
  "name":                "Slack",
  "description":         "Slack brings team communication and collaboration into one place…",
  "applicationCategory": "BusinessApplication",
  "categories":          ["Collaboration"],
  "rating": {
    "average":           9,
    "averageNormalized": 4.5,                              // 0–5 scale for cross-platform consumers
    "count":             9979,
    "bestRating":        10,
    "worstRating":       1
  },
  "vendor": {
    "name":              "Salesforce",
    "url":               "https://slack.com/%E2%80%A6"
  },
  "offer": {
    "price":             0,
    "priceCurrency":     "USD",
    "offerUrl":          null
  },
  "awards": [
    { "title": "Buyer's Choice 2026", "year": "2026" }
  ],
  "features":            ["Task Management", "Gantt Charts", "Scheduling", /* +20 more */],
  "reviewSnippets":      [ /* up to 5 fully-structured reviews from JSON-LD */ ],
  "breadcrumbs":         [ /* ... */ ],
  "scrapedAt":           "2026-05-12T17:36:00.000Z"
}
```

#### `rowType: "review"` (one per individual review)

```jsonc
{
  "rowType":             "review",
  "reviewsUrl":          "https://www.trustradius.com/products/slack/reviews/all",
  "productSlug":         "slack",
  "productName":         "Slack",

  "reviewId":            null,                              // TrustRadius doesn't surface stable IDs on /reviews/all
  "title":               "Slack Review",
  "reviewUrl":           "https://www.trustradius.com/products/slack/reviews",

  "rating": {
    "average":           10,                                // native 0–10
    "averageNormalized": 5,                                 // 0–5 normalized
    "count":             1,
    "bestRating":        10,
    "worstRating":       1
  },

  "text":                "So we use it for daily collaboration, just notifications…",
  "pros":                null,
  "cons":                null,
  "publishedAt":         "2026-05-12T01:30:29.251Z",        // ISO 8601 — cleaner than Capterra's "May 31, 2024"

  // Reviewer firmographics — RICHER than Capterra (companyName + department + LinkedIn URL)
  "reviewer": {
    "name":              "Sapna Nayak",
    "firstName":         "Sapna",
    "lastName":          "Nayak",
    "jobTitle":          "Senior Salesforce Administrator",
    "jobType":           "Administrator",
    "companyName":       "Side",                            // ← Capterra doesn't surface company NAME
    "companySize":       "51-200 employees",
    "department":        "Other",                           // ← richer than Capterra
    "industry":          null,
    "profileUrl":        null,
    "profilePicUrl":     "https://media.trustradius.com/profile-photos/%E2%80%A6jpeg",   // when available
    "linkedInUrl":       "https://www.linkedin.com/in/sapna-nayak-%E2%80%A6",            // ← UNIQUE to TrustRadius
    "linkedInVerified":  null
  },

  // Per-question Q&A — UNIQUE to TrustRadius
  "sections": [
    {
      "title":     "Use Cases and Deployment Scope",
      "responses": [
        {
          "question": "Use Cases and Deployment Scope",
          "answer":   "So we use it for daily collaboration, just notifications for different things…"
        }
      ]
    },
    {
      "title":     "Pros",
      "responses": [{ "question": "Pros", "answer": "Real-time messaging | File sharing | Channel organization" }]
    },
    {
      "title":     "Cons",
      "responses": [{ "question": "Cons", "answer": "Search can be slow for large workspaces" }]
    }
    /* + more sections per review */
  ],

  "incentive":           null,                              // "Incentivized" when TrustRadius flags it
  "source":              "TrustRadius",
  "trusted":             null,

  // Thread-level aggregate (same on every review row from the same reviews URL)
  "productAggregate": {
    "rating":                { "average": 9, "averageNormalized": 4.5, "count": 9980, "bestRating": 10, "worstRating": 1 },
    "awards":                [{ "title": "Buyer's Choice 2026", "year": "2026" }],
    "features":              ["Task Management", "Gantt Charts", /* +21 */],
    "vendor":                { "name": "Salesforce", "url": "https://slack.com/%E2%80%A6" },
    "totalReviewsEmitted":   30,
    "pagesScraped":          3
  },

  "scrapedAt":           "2026-05-12T17:36:00.000Z"
}
```

#### `rowType: "category-product"` (one per product in the category)

```jsonc
{
  "rowType":             "category-product",
  "categoryUrl":         "https://www.trustradius.com/categories/collaboration",
  "categorySlug":        "collaboration",

  "productSlug":         "slack",
  "productUrl":          "https://www.trustradius.com/products/slack",
  "name":                "Slack",
  "description":         "Slack brings team communication into one place…",
  "rating":              { "average": 9, "averageNormalized": 4.5, "count": null, "bestRating": 10, "worstRating": 1 },
  "vendor":              { "name": "Salesforce", "url": "…" },
  "logoUrl":             "https://media.trustradius.com/product-logos/%E2%80%A6png",
  "sponsored":           null,

  "categoryAggregate": {
    "categoryUrl":         "https://www.trustradius.com/categories/collaboration",
    "categorySlug":        "collaboration",
    "categoryName":        "Collaboration Tools",
    "description":         "Collaboration tools help teams work together…",
    "totalProductsOnPage": 25,
    "faqs": [                                              // ← TrustRadius ships editorial Q&A as JSON-LD FAQPage
      { "question": "What is collaboration software?", "answer": "…" },
      { "question": "How much does it cost?",          "answer": "…" }
    ],
    "relatedCategories":   [{ "name": "Web Conferencing", "url": "…" }, /* +29 */]
  },

  "scrapedAt":           "2026-05-12T17:36:00.000Z"
}
```

#### `rowType: "compare"`

```jsonc
{
  "rowType":   "compare",
  "compareUrl": "https://www.trustradius.com/compare-products/slack-vs-microsoft-teams",
  "title":      "Microsoft Teams vs Slack",
  "products": [
    {
      "productSlug": "slack",
      "productUrl":  "https://www.trustradius.com/products/slack",
      "name":        "Slack",
      "rating":      { "average": 9, "averageNormalized": 4.5, /* … */ },
      "vendor":      null,
      "logoUrl":     "https://media.trustradius.com/product-logos/%E2%80%A6png"
    },
    {
      "productSlug": "microsoft-teams",
      "productUrl":  "https://www.trustradius.com/products/microsoft-teams",
      "name":        "Microsoft Teams",
      "rating":      { "average": 8.6, "averageNormalized": 4.3, /* … */ },
      /* … */
    }
  ],
  "scrapedAt": "2026-05-12T17:36:00.000Z"
}
```

> **Compare row is best-effort in v1.0.** TrustRadius compare pages are HTML-rendered editorial articles (no embedded JSON data block). We DOM-walk the visible cards per slug — good for slug + name + rating + logo, but vendor info may be partial. For full data, scrape each product separately.

***

### Pricing

Pay-per-event. **Reviews and category-products are billed flat** — each is its own dataset row, one `outputrecord` event per row. Cost = `rows × outputrecord-price`. No nested-array arithmetic.

Event | When | Suggested rate
\--- | --- | ---
`outputrecord` | Once per dataset row pushed — `product`, `review`, `category-product`, `compare`. Thread/category aggregate is nested INSIDE each flat row. | configured on the actor page
`additional-data` | Once per nested item inside a product / compare row only (features, awards, review snippets, breadcrumb categories, compared products). Reviews and category-products are never billed here. | **$0.75 per 1,000 items** ($0.00075 each)

***

### What makes this richer than the competition

We surveyed all 16 TrustRadius actors on Apify Store (May 2026). The top specialist (`zen-studio/trustradius-review-scraper`, 25 users) covers **reviews only**. Same gap we filled for Capterra.

Capability | Competitor actors | **This actor**
\--- | --- | ---
Product + reviews + category + compare in **one actor** | ❌ (reviews-only is the norm) | ✅
Sitemap-driven bulk discovery | ❌ | ✅
URL auto-classification (paste any mix) | ❌ | ✅
**Per-question `sections[]` Q\&A** captured on every review | partial (1 actor mentions Q\&A, partial coverage) | ✅
**Reviewer LinkedIn URL** | ❌ | ✅
**Reviewer company name** (not just size) | ❌ | ✅
**Reviewer department** | ❌ | ✅
Dual **0–10 native + 0–5 normalized** ratings | ❌ | ✅
Capterra-style **awards** (Buyer's Choice etc.) | ❌ | ✅
Category **FAQ** extraction (from JSON-LD `FAQPage`) | ❌ | ✅
Flat-per-review billing (1 review = 1 paid row) | mixed | ✅

***

### Notes & limitations

- **TrustRadius is open** — no Cloudflare, no warmup needed. Apify Residential US works first-attempt at 100%.
- **Reviews pagination** auto-walks `/reviews/all?page=N` until empty or `maxReviewsPerProduct` hits. Slack has ~10,000 reviews across ~1,000 pages — set caps appropriately.
- **Compare extraction** is best-effort in v1.0 — TrustRadius compare pages ship as HTML-only editorial. v1.1 will follow per-product fetches for richer compare rows (same pattern that worked on Capterra).
- **`reviewer.profilePicUrl` / `linkedInUrl` data-source notes.** These fields are surfaced **on the product page (`/products/{slug}/reviews`)** — the 5 reviews shipped via JSON-LD + RSC carry full reviewer.user blocks (profile pic + LinkedIn URL + verification flag). On the paginated `/products/{slug}/reviews/all?page=N`, TrustRadius ships a slimmer payload that does **not** include these fields — reviewer firmographics (name, company, jobTitle, department, companySize) are still 100%-filled, but profile pic + LinkedIn URLs come back null. If you need full reviewer enrichment, prefer the `/reviews` URL over `/reviews/all`.
- **Sitemap mode** is conservative — only walks `maxProductsFromSitemap` URLs to avoid runaway costs. Buyers wanting full-catalog scrapes should run multiple sitemap calls with `maxItems` set high.

***

### Support

Issues, feature requests, or custom output shapes? Open a ticket on the actor's Apify page or message the maintainer.

***

### 🤖 Related MCP servers for AI agents

Building an AI agent, or using Claude, Cursor or ChatGPT? Skip the scraping setup — connect our hosted **MCP servers** (no API keys, billed per call):

- **[Reviews MCP Server](https://apify.com/memo23/reviews-mcp-server)** — search companies, read real Trustpilot review texts, and pull multi‑platform ratings (Trustpilot + App Store + Google Play) straight from your assistant.
- **[Reddit MCP Server](https://apify.com/memo23/reddit-mcp-server)** — search Reddit, browse subreddits, read comment threads.
- **[Email Finder & Verifier MCP](https://apify.com/memo23/email-mcp-server)** — find and verify company emails.
- **[Video Transcripts MCP](https://apify.com/memo23/transcripts-mcp-server)** — full YouTube & TikTok transcripts.

# Actor input Schema

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

Paste any mix of:
• Product URLs — `https://www.trustradius.com/products/{slug}` (any of `/products/{slug}`, `/products/{slug}/reviews`, or `/products/{slug}/reviews/all` work — each emits 1 product row + N flat review rows automatically)
• Category URLs — `https://www.trustradius.com/categories/{slug}`
• Compare URLs — `https://www.trustradius.com/compare-products/{slug-a}-vs-{slug-b}`
• Sitemap URL — `https://www.trustradius.com/sitemap_index.xml` (bulk discovery)

Bare product slugs (e.g. `slack`) also work. Each entry is auto-classified.

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

Safety cap on total dataset rows. Product / compare URLs emit 1 row each. A reviews URL emits 1 row per individual review; a category URL emits 1 row per product listed. Sitemap URLs can expand to thousands — start small. Each emitted row = one paid `outputrecord` event.

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

Maximum review rows emitted per reviews URL. TrustRadius paginates 10 reviews per page on `/reviews/all`; Slack has ~10,000 reviews across ~1,000 pages — cap aggressively. Set 0 for no limit.

## `maxProductsPerCategory` (type: `integer`):

Maximum category-product rows emitted per category URL. Set 0 for no limit.

## `maxProductsFromSitemap` (type: `integer`):

When you paste a sitemap index URL (`/sitemap_index.xml`), the actor discovers product URLs and scrapes the first N. Recommended cap when exploring the catalog.

## `normalizeRatings` (type: `boolean`):

TrustRadius uses a 0–10 scale. Enable to also emit a 0–5 normalized rating field (`ratingNormalized`) on every row for cross-platform comparison with Capterra / G2 / Trustpilot consumers.

## `includeReviewSections` (type: `boolean`):

When enabled, every review row carries the full `sections[]` array — each section has its title + list of `{question, answer}` pairs. Adds ~1–3 KB per row but captures TrustRadius's unique structured-Q\&A feature. Disable for compact CSV exports.

## `reviewInsights` (type: `boolean`):

Adds one `review_insights` row per product: rating breakdown & sentiment split, recurring software complaint themes (bugs, pricing, support, missing features, onboarding, integrations…), top negative-review terms, and feature-request snippets. Deterministic — instant, no AI credits or keys. Billed per product analyzed.

## `painPointAnalysis` (type: `boolean`):

Runs an AI (Claude) pass over each product's reviews and adds a `painPointAnalysis` row: clustered pain-point themes with severity & recurrence, missing features users ask for, quick wins, overall sentiment and a short summary. Requires a paid Apify plan (uses AI credits) and is billed per product analyzed.

## `reviewGapReport` (type: `boolean`):

Adds a single `reviewGapReport` row comparing the subject product against the other products scraped in this run (up to 4 competitors, biggest first). Needs at least 2 products with 3+ reviews each. Billed once via the `review-gap-report` event; never charged when the report can't be built.

## `gapReportSubject` (type: `string`):

Which of the scraped products is YOURS (the report subject). Use (part of) the product name, e.g. `Asana`. If empty, the first product scraped is the subject.

## `enrichEmails` (type: `boolean`):

If enabled, finds a contact email for each result from its own website (or by discovering it from the name). Adds contactEmail + contactWebsite columns plus a detailed emailEnrichment object. Billed per contact email found; only charged when an email is returned, never for misses.

## `maxConcurrency` (type: `integer`):

Parallel HTTP requests. TrustRadius is open (no Cloudflare), so concurrency up to 10 is safe.

## `maxRequestRetries` (type: `integer`):

Per-URL retry budget on 5xx / network errors.

## `proxy` (type: `object`):

Apify residential proxy is recommended (US country). TrustRadius accepts datacenter IPs too, but residential is more reliable for high-volume runs.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.trustradius.com/products/slack",
    "https://www.trustradius.com/categories/collaboration",
    "https://www.trustradius.com/compare-products/slack-vs-microsoft-teams"
  ],
  "maxItems": 1000,
  "maxReviewsPerProduct": 100,
  "maxProductsPerCategory": 50,
  "maxProductsFromSitemap": 50,
  "normalizeRatings": true,
  "includeReviewSections": true,
  "reviewInsights": false,
  "painPointAnalysis": false,
  "reviewGapReport": false,
  "enrichEmails": false,
  "maxConcurrency": 5,
  "maxRequestRetries": 3,
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        "https://www.trustradius.com/products/slack",
        "https://www.trustradius.com/categories/collaboration",
        "https://www.trustradius.com/compare-products/slack-vs-microsoft-teams"
    ],
    "proxy": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "startUrls": [
        "https://www.trustradius.com/products/slack",
        "https://www.trustradius.com/categories/collaboration",
        "https://www.trustradius.com/compare-products/slack-vs-microsoft-teams",
    ],
    "proxy": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/trustradius-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 '{
  "startUrls": [
    "https://www.trustradius.com/products/slack",
    "https://www.trustradius.com/categories/collaboration",
    "https://www.trustradius.com/compare-products/slack-vs-microsoft-teams"
  ],
  "proxy": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call memo23/trustradius-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,memo23/trustradius-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/jfNcTBZ14B0xBamce/builds/suHDWZq2MwsXVp0vA/openapi.json