TrustRadius Reviews API: Software Alternatives and Buyer Comparisons

Find the software alternatives real buyers considered, in their own words. This API turns TrustRadius 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 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.

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

Review mode takes the same shape with review URLs instead:

{
  "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.

{
  "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 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 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 (free trial), Claude Cowork (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 (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".

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. 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 and it can discover, pay for, and run this Actor autonomously. Read the Apify x402 announcement 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.

Tasks and schedules, the part that matters

Save one task per product you care about, your own and each rival, then attach a single schedule 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: 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 and 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:

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 and it can run this Actor itself. Claude Code (free trial), Claude Cowork (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 is set up for exactly that.

Webhooks

For anything custom, attach an Apify webhook 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 covers the other large B2B software review site, so you can check whether a pattern holds across both.
• Trustpilot Reviews API for consumer-facing business reviews, useful when the product also sells self-serve.
• Glassdoor Reviews API for employer reviews, which often explain why a vendor's support quality moved.
• Owler Company Intelligence API returns the vendor's own stated competitor set, a useful cross-check against what buyers actually name.
• Crunchbase Company API 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 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

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

Monitor Competitor Reviews for Competitive Intelligence

Watch a rival's review feed on a schedule and catch sentiment shifts early. Run this task

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

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

Find Competitive Displacement Signals in B2B Reviews

Surface the reviews where a buyer replaced an incumbent, and read what tipped it. Run this task

Fill a Software Evaluation Matrix with Buyer Scores

Populate an evaluation matrix with per-feature numbers from real buyers. Run this task

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

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

Read the same competitive comparison fields with an overseas buyer audience in mind. Run this task

❓ 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, then attach a schedule 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 for this review data, which is why most teams end up doing 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, and the example repo 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 using the URL https://mcp.apify.com/?tools=actors,docs,johnvc/trustradius-reviews-api. Claude Code (free trial), Claude Cowork (free trial), and Cursor all work. See the Apify MCP docs for client-specific setup.

Can I integrate this TrustRadius Scraper with other apps?

Yes. Through Apify integrations the output can go almost anywhere: Make, Zapier, Slack, Google Drive, and Google Sheets among them. For anything custom, a webhook 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 and compare the two sets, since the reviewer populations differ. Trustpilot Reviews API covers consumer-facing sentiment, and Glassdoor Reviews API 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. 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 is a reasonable starting point. Ask your own counsel about your specific use.

🌐 About Alpha OSINT

This Actor is part of Alpha OSINT, 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.

Last Updated: 2026.08.10