# G2 & Capterra Software Reviews Scraper (`kingly_contest_7cb/g2-capterra-reviews`) Actor

Scrape G2 and Capterra software reviews into one normalized dataset: ratings, dates, pros, cons, full text, reviewer role, company size, industry and incentive flags. Built for SaaS marketers and competitive intelligence.

- **URL**: https://apify.com/kingly_contest_7cb/g2-capterra-reviews.md
- **Developed by:** [Carina Hatton](https://apify.com/kingly_contest_7cb) (community)
- **Categories:** Lead generation, E-commerce, AI
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 85.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 review scrapeds

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

## G2 & Capterra Software Reviews Scraper

Scrape software reviews from **G2** and **Capterra** into **one clean, normalized dataset**. Paste product review URLs from either site (or mix both in one run) and get every review with the same fields: star rating, date, title, pros, cons, full text, reviewer role, company size, industry, and incentive / verification flags.

Built for **SaaS marketers, product marketers, and competitive-intelligence teams** who need review data they can drop straight into a spreadsheet, BI tool, or LLM pipeline without writing two different parsers.

### What you get

- **Both sites, one schema.** G2 and Capterra reviews share the same field names, so you can compare your product against competitors across both sites in a single table. Fields a site does not publish are `null`, never guessed.
- **Pros and cons kept separate** (plus "problems solved" on G2 and the overall comment on Capterra), and a combined `fullText` field for sentiment analysis or LLM summarization.
- **Reviewer context:** job title / role, company size, industry, how long they used the product (Capterra), anonymous or named.
- **Trust signals:** `isIncentivized`, `isVerified`, verification methods, review source (e.g. G2 "Organic" or "Seller invite"), and G2's "current user" badge, so you can filter out incentivized reviews if you need to.
- **Capterra extras:** sub-ratings (ease of use, customer support, features, value for money), likelihood-to-recommend score, products the reviewer switched from and why, and vendor responses.
- **Filters:** max reviews per product, star ratings (e.g. only 1–2 star reviews), date range (since / until, absolute or relative like `90 days`), and newest-first sorting on G2 (see Capterra note under Tips & limitations).
- **Optional product summary rows:** average rating, total review count, categories, and G2's top pros/cons themes when G2 includes them in the page it serves.
- **Reliable by design:** HTTP-only (no browser), Apify's unblocking proxy, automatic retries with fresh sessions, detection of half-loaded pages, and per-product error handling: one bad URL never kills the whole run.

### Use cases

- **Competitor teardown:** pull the newest 1–2 star reviews of your top competitors and see what their customers complain about.
- **Battlecards and positioning:** collect pros/cons by company size or industry to sharpen messaging.
- **Voice-of-customer research:** feed `fullText` into an LLM to find recurring themes, objections, and phrases buyers actually use.
- **Review monitoring:** schedule a weekly run with "Only reviews since: 7 days" to track new reviews of your product and competitors.
- **Ad and landing-page copy:** mine real customer language from pros sections.

### How to use

1. Add one or more product review URLs to **Products**, for example:

   - `https://www.g2.com/products/slack/reviews`
   - `https://www.capterra.com/p/135003/Slack/`

   Shortcuts also work: `g2:slack` and `capterra:135003/Slack`.
2. Set **Max reviews per product** (you pay per review saved, so start small).
3. Optionally pick **star ratings**, a **date range**, and the **sort order**.
4. Click **Start**. Download results as JSON, CSV, Excel, or HTML, or pull them via the Apify API or integrations (Make, Zapier, Google Sheets, webhooks, and more).

#### Example input

```json
{
    "products": [
        "https://www.g2.com/products/slack/reviews",
        "https://www.capterra.com/p/135003/Slack/"
    ],
    "maxReviewsPerProduct": 100,
    "sort": "newest",
    "ratings": ["1", "2"],
    "reviewsSince": "180 days"
}
```

#### Example output (one review)

```json
{
    "recordType": "review",
    "source": "g2",
    "productName": "Slack",
    "productId": "3437",
    "productUrl": "https://www.g2.com/products/slack/reviews",
    "reviewId": "13217252",
    "reviewUrl": "https://www.g2.com/products/slack/reviews/slack-review-13217252",
    "title": "Easy Team Connection: Presence, Huddles, and Effortless Groups",
    "rating": 5,
    "ratingScale": 5,
    "date": "2026-10-30",
    "reviewerRole": "Senior customer success executive",
    "reviewerCompanySize": "Mid-Market (51-1000 emp.)",
    "reviewerIndustry": null,
    "pros": "We can connect with anyone from the company ...",
    "cons": "The only thing I dislike is there is no option available to see whether a person has seen the message or not ...",
    "problemsSolved": "It solves basic problems like getting details of any unknown executive ...",
    "fullText": "What do you like best? ...",
    "isIncentivized": false,
    "isVerified": true,
    "reviewSource": "Organic",
    "scrapedAt": "2026-10-31T15:00:00.000Z"
}
```

The full field list with descriptions is in the **Output** / dataset schema tab. The dataset has ready-made views: **Overview**, **Pros & cons**, **Reviewers**, and **Product summaries**.

### Output fields (summary)

| Field | Description |
|---|---|
| `source` | `g2` or `capterra` |
| `productName`, `productId`, `productUrl` | Product being reviewed |
| `reviewId` | Review identifier on the source site |
| `reviewUrl` | Direct link to the review (**G2 only**; Capterra has no per-review link, so the field is left out of Capterra rows) |
| `pageUrl` | The review-list page the review was read from (both sites) |
| `rating`, `ratingScale` | Star rating out of 5, exactly as the site displays it. G2 uses half stars from 0 to 5, so a very negative G2 review can genuinely be 0 or 0.5 (these fall in G2's own "1 star" filter); Capterra uses 1–5 |
| `date` | Publish date (`YYYY-MM-DD`), both sites |
| `dateTime` | Full publish timestamp with time zone (**G2 only**; Capterra only publishes a date, so the field is left out of Capterra rows) |
| `title`, `pros`, `cons`, `fullText` | Review text (both sites) |
| `problemsSolved`, `reviewerProfileUrl`, `isCurrentUser`, `reviewerNotice` | G2 only |
| `reviewerName`, `reviewerRole`, `reviewerCompanySize`, `reviewerIndustry` | Reviewer context, as published by the site |
| `isIncentivized`, `isVerified`, `verificationMethods`, `reviewSource` | Trust signals |
| `summaryComment`, `reviewerTimeUsedProduct`, `subRatings`, `recommendationRating`, `switchedFrom`, `reasonsForSwitching`, `vendorResponse` | Capterra only |

Fields that a site never provides are left out of that site's rows instead of being filled with empty values. Fields a site does provide can still be `null` when the reviewer skipped that question.

A `RUN_SUMMARY` record in the key-value store lists each product's status (`ok`, `partial`, `failed`), review count, pages read, and any error message.

### Pricing

This Actor uses **pay-per-event** pricing: you pay a fixed price **per review saved** to the dataset (see the Pricing tab for the current price). Product summary rows are free. You are not charged for retries, blocked pages, or failed products.

To control spend, set **Max reviews per product** and, in the run options, **Max cost per run**. When the cost limit is reached the Actor stops cleanly and keeps everything saved so far.

### Tips and limitations

- **Use the default proxy setting (Apify UNBLOCKER group).** G2 and Capterra both use strong bot protection; plain datacenter or residential proxies are usually blocked.
- **G2 star filter** is applied by G2 itself. G2 groups half stars upward (a 4.5-star review counts as 5 stars).
- **Capterra sorting:** Capterra is read in its default "Most Helpful" order; newest-first is not available there (we tried, and Capterra did not honor it). Rating and date filters are applied while paging, so narrow filters on Capterra can require reading many pages (capped by **Max listing pages per product**) and may return fewer reviews than requested.
- **Capterra speed:** Capterra pages load through the unblocker proxy in roughly 10–25 seconds each, and some requests stall. The Actor cuts a Capterra request off after 35 s (configurable), starts a parallel request on a fresh proxy session if the first has not answered after 15 s, and retries timeouts almost immediately. This shortens stalls but does not remove them: a Capterra product can still take a few minutes, and on a bad run a later page can fail, in which case the product is marked `partial` and the reviews already saved are kept.
- **G2 pages** sometimes come back without the review list; the Actor detects that and retries (also via G2's lighter review-list URL), which can add time but not charges.
- **Capterra caps listings at 100 pages** (25 reviews per page). G2 shows 10 reviews per page.
- **Capterra has no per-review links or timestamps**, so Capterra rows have no `reviewUrl` or `dateTime`; use `pageUrl`/`productUrl` plus `reviewId`, and `date`.
- **No "helpful" vote counts:** neither site exposes them in the pages this Actor reads, so there is no such field.
- Fields depend on what each reviewer filled in and what the site displays publicly; unanswered questions are `null`.
- Site layouts change. If a site changes its pages, the run will report the product as `failed` with a clear message rather than returning broken data.

### FAQ

**Is scraping G2 and Capterra legal?**
This Actor collects publicly visible review content only and does not log in. Reviews can contain personal data such as reviewer names. Make sure your use complies with applicable laws (e.g. GDPR) and the sites' terms. If unsure, consult a lawyer.

**Can I scrape many products at once?**
Yes. Add as many URLs as you like; products run in parallel (configurable) and each one is handled independently.

**Can I get only negative reviews?**
Yes: select 1 and 2 stars under **Star ratings to include**.

**Something doesn't work?**
Open an issue on the Actor's Issues tab with the run ID and product URL, and we'll look into it.

# Actor input Schema

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

G2 or Capterra product review URLs; the site is detected automatically. Also accepts <code>g2:\<slug></code> (e.g. <code>g2:slack</code>) and <code>capterra:\<id>/\<Slug></code> (e.g. <code>capterra:135003/Slack</code>). A bare slug is treated as G2.

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

Stop after this many reviews per product (after filters). You pay per review saved.

## `sort` (type: `string`):

<b>Newest first</b>: G2 'most recent' order. For Capterra the Actor requests 'Most Recent' order and checks the review dates; if Capterra returns its default 'Most Helpful' order instead, the run continues in that order and filters are applied while paging. <b>Site default</b>: G2 'most relevant', Capterra 'Most Helpful'.

## `ratings` (type: `array`):

Only keep reviews with these star ratings (empty = all). Use it as a min/max range, e.g. 1+2 for negative reviews only. G2 filters server-side (half stars round up, e.g. 4.5 counts as 5); Capterra filters while paging.

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

Only keep reviews published on or after this date. Absolute (YYYY-MM-DD) or relative (e.g. '90 days', '6 months').

## `reviewsUntil` (type: `string`):

Only keep reviews published on or before this date (inclusive). Absolute (YYYY-MM-DD) or relative (e.g. '30 days' = up to 30 days ago). Combine with 'Only reviews since' for a date range.

## `includeProductSummary` (type: `boolean`):

Also save one 'product' row per product (average rating, total reviews, categories, G2 pros/cons themes, scrape status). Product rows are free. They are always in the RUN_SUMMARY record too.

## `maxPagesPerProduct` (type: `integer`):

Safety cap on listing pages per product (G2: 10 reviews/page, Capterra: 25/page, max 100 pages). Matters mostly when filters discard many reviews.

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

How many products to scrape at the same time.

## `maxRetries` (type: `integer`):

Retries per page, each with a fresh proxy session.

## `requestTimeoutSecs` (type: `integer`):

Timeout for one G2 page request (Capterra uses the lower of this and the Capterra timeout below).

## `capterraTimeoutSecs` (type: `integer`):

Hard cap for one Capterra page request. Capterra pages normally load in 10-25 s through the unblocker; slower requests are usually stuck, so they are cut off and retried on a new proxy session.

## `capterraHedgeAfterSecs` (type: `integer`):

If a Capterra page has not answered after this many seconds, a second request on a fresh proxy session starts in parallel and the first good answer wins. 0 disables it.

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

G2 and Capterra use strong bot protection. The Apify UNBLOCKER proxy group is strongly recommended; residential/datacenter IPs are usually blocked.

## Actor input object example

```json
{
  "products": [
    "https://www.g2.com/products/slack/reviews",
    "https://www.capterra.com/p/135003/Slack/"
  ],
  "maxReviewsPerProduct": 10,
  "sort": "newest",
  "includeProductSummary": false,
  "maxPagesPerProduct": 40,
  "maxConcurrency": 3,
  "maxRetries": 4,
  "requestTimeoutSecs": 60,
  "capterraTimeoutSecs": 35,
  "capterraHedgeAfterSecs": 15,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "UNBLOCKER"
    ]
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset of normalized reviews (and optional product summary rows)

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

Per-product status, review counts, product info and request stats

# 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.g2.com/products/slack/reviews",
        "https://www.capterra.com/p/135003/Slack/"
    ],
    "maxReviewsPerProduct": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "UNBLOCKER"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("kingly_contest_7cb/g2-capterra-reviews").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.g2.com/products/slack/reviews",
        "https://www.capterra.com/p/135003/Slack/",
    ],
    "maxReviewsPerProduct": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["UNBLOCKER"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("kingly_contest_7cb/g2-capterra-reviews").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.g2.com/products/slack/reviews",
    "https://www.capterra.com/p/135003/Slack/"
  ],
  "maxReviewsPerProduct": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "UNBLOCKER"
    ]
  }
}' |
apify call kingly_contest_7cb/g2-capterra-reviews --silent --output-dataset

```

## MCP server setup

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

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/7pCZ33rAYbmmPB3iO/builds/iDVNNTqZusUfMkjzV/openapi.json