# G2 Reviews Scraper + Insights Report (`berkaydev/g2-reviews-insights-scraper`) Actor

Scrape reviews from any G2 product page, plus a free report on top: rating trends, top complaints and praise, vendor response rate, spike detection, B2B segment breakdown, and a comparison table for multiple products. Runs a real browser to get past G2's bot protection.

- **URL**: https://apify.com/berkaydev/g2-reviews-insights-scraper.md
- **Developed by:** [Gezgin Data](https://apify.com/berkaydev) (community)
- **Categories:** Lead generation, SEO tools
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.01 / 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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

Most G2 scrapers hand you a pile of raw review rows and leave the analysis to you. This one returns the reviews and a ready-made report on top, so you can see what the data is telling you without building a pipeline first.

Give it a product slug like `slack` or a full G2 URL. You get one row per review (rating, pros, cons, reviewer job title, company size, date, vendor reply) plus a report: rating trends by month, the words that come up most in good and bad reviews, vendor response rate, suspicious volume spikes, and a breakdown of how Enterprise buyers rate the product versus small business. Scrape several products and you get a side-by-side comparison too.

Under the hood it runs a real browser through a residential proxy, which is what it takes to get past G2's bot protection. A residential proxy is required (see the note under Pricing).

To try it, put `slack` in the Product URLs field and hit Start.

### G2 review insights report: complaint analysis, B2B segments, and competitor comparison

The built-in insights report turns raw reviews into answers: a complaint and praise keyword analysis, ratings broken down by company size and job role, vendor response rate, suspicious-spike detection, and a side-by-side competitor review comparison when you scrape more than one product.

### What you get

Two outputs per run.

A dataset with one row per review. Download as JSON, CSV, Excel, or XML, or pull through the Apify API.

A report in the key-value store:

- `REPORT` is an HTML file. Open it in any browser.
- `INSIGHTS` is the same data as JSON for programmatic use.

The report covers:

- Average rating, star breakdown with percentages, and what share of reviewers are verified.
- How often the vendor responds.
- Rating by month with spike detection — months where volume is three times the usual median get flagged.
- Top 15 words and phrases from low-star reviews. The complaints.
- Top 15 from high-star reviews. The praise.
- Ratings broken down by company size (Small-Business, Mid-Market, Enterprise) and by job role.
- A comparison table across products when you scrape more than one.

### How it compares

| | This actor | Typical scraper |
|---|---|---|
| Ready-made insights report | yes | no |
| Rating breakdown by company size and job role | yes | no |
| Complaint and praise keyword mining | yes | no |
| Multi-product comparison in one run | yes | rarely |
| Suspicious-spike detection | yes | no |
| Pros and cons as separate fields | yes | sometimes |
| Gets past G2's bot protection | real browser + IP rotation | varies |

Common uses:

- Competitive intelligence for SaaS products.
- Tracking your own product's G2 reputation over time.
- Pulling out recurring complaints before a product review cycle.
- Checking a vendor's reviews before a procurement decision.
- Client reporting at agencies or consultancies.

### How to use it

1. Open the Input tab.
2. Put one or more G2 product slugs or URLs in Product URLs — for example `slack` or `https://www.g2.com/products/notion/reviews`.
3. Set Max reviews per product. Leave it at 0 for all of them, or set 25-100 for a quick test.
4. Filter by star rating if you want.
5. Hit Start. Reviews land in the Dataset tab. The report lands in the Key-value store tab under `REPORT`.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `productUrls` | array (required) | `["slack"]` | G2 product URLs or slugs, one per line |
| `maxReviewsPerProduct` | integer | 0 (all) | Cap per product |
| `stars` | array | all | Keep only these star ratings |
| `sort` | string | `most_recent` | `most_recent` or `most_helpful` |
| `generateInsights` | boolean | true | Build the report after scraping |
| `maxConcurrency` | integer | 1 | Parallel browser contexts |
| `requestDelayMs` | integer | 500 | Wait between page fetches |
| `proxyConfiguration` | object | Apify datacenter proxy | Proxy settings |

#### Example input

```json
{
  "productUrls": ["slack", "microsoft-teams"],
  "maxReviewsPerProduct": 200,
  "generateInsights": true
}
```

### Output

One row per review:

```json
{
  "reviewId": "abc123",
  "productName": "Slack",
  "productSlug": "slack",
  "rating": 4,
  "pros": "The channel organisation and integrations are excellent. Search works well across long histories.",
  "cons": "Gets expensive at scale. Notifications can be overwhelming without careful configuration.",
  "text": "The channel organisation... Gets expensive...",
  "publishedDate": "2024-09-12",
  "isVerified": true,
  "replyMessage": null,
  "reviewerName": "Jane D.",
  "reviewerRole": "Product Manager",
  "reviewerCompanySize": "Mid-Market",
  "helpfulVotes": 3,
  "reviewUrl": "https://www.g2.com/products/slack/reviews/slack-review-abc123"
}
```

Key-value store:

| Key | Type | What it is |
|---|---|---|
| `INSIGHTS` | application/json | Full analytics object per product plus comparison |
| `REPORT` | text/html | The report. Open in a browser |

#### Fields

| Field | Type | Description |
|---|---|---|
| `reviewId` | string | G2 review ID |
| `productName` | string | Product display name |
| `productSlug` | string | G2 product slug |
| `rating` | integer | Star rating (1 to 5) |
| `pros` | string | What the reviewer likes best |
| `cons` | string | What the reviewer dislikes |
| `text` | string | Combined text (pros + cons) for search |
| `publishedDate` | ISO 8601 | Review date |
| `isVerified` | boolean | Whether the reviewer is verified |
| `replyMessage` | string | Vendor reply, null if none |
| `reviewerName` | string | Reviewer display name |
| `reviewerRole` | string | Job title |
| `reviewerCompanySize` | string | Small-Business, Mid-Market, or Enterprise |
| `helpfulVotes` | integer | Helpful vote count, when shown |
| `reviewUrl` | string | Direct link to the review |

### Pricing

A $0.02 base fee per successful run, plus $0.004 per review. The base fee covers the residential-proxy and browser work needed to get past G2's bot protection. If a run returns no reviews, you are not charged at all.

| Reviews (one run) | Cost |
|---|---|
| 25 | $0.12 |
| 100 | $0.42 |
| 1,000 | $4.02 |
| 10,000 | $40.02 |

The insights report is always included. You pay for the run and the reviews, not for the analysis.

Note on proxy: this actor needs a residential proxy because G2 uses DataDome, which blocks datacenter IPs. Residential proxy requires a paid Apify plan (the free plan includes 20 GB of residential traffic per month).

### Tips

- For competitive benchmarking, put 3-5 competitor slugs in the list and set `maxReviewsPerProduct` to 200-500. The comparison table in the report gives you a quick side-by-side.
- To find recurring complaints, look at `topConsTerms` in the G2 extras section of INSIGHTS.
- For segment analysis, check `segmentByCompanySize` — if Enterprise users rate it lower than SMB, that is worth knowing before a procurement decision.
- For rep tracking, schedule the run monthly with Apify's scheduler and compare the monthly INSIGHTS files over time.

### FAQ

**Is scraping G2 legal?**
G2 is a public website. Scraping public, non-login data for research, competitive analysis, or your own use is generally acceptable in most jurisdictions. Don't collect personal data without a legal basis or breach G2's terms.

**Why are some fields empty?**
G2's page layout varies by product and A/B test. The actor returns null for anything it can't find rather than crashing, and logs a short diagnostic line on the first page (page title, cards found, a sample reviewer role) so you can see what it parsed.

**I got fewer reviews than expected, or zero.**
G2 uses DataDome, which CAPTCHA-walls a share of proxy IPs. The actor rotates to a fresh residential IP and retries up to five times, so most runs get through, but a heavy IP can occasionally block a whole run (you are not charged when that happens). It can also block mid-run on a later page, in which case you keep the reviews collected so far. If you see this a lot, raise `requestDelayMs` to 1000 or 2000. A residential proxy is required; datacenter IPs are always blocked.

**What B2B breakdowns does the report include?**
Ratings broken down by company size (Small-Business, Mid-Market, Enterprise) and by reviewer job role, plus separate top-terms lists for pros and cons. These appear in the HTML report under each product and in the `g2Extras` key of the INSIGHTS JSON.

**Issues or feature requests?**
Use the Issues tab on the actor page.

***

### More data tools by Gezgin Data

- [Google Maps Email Scraper — Business Leads](https://apify.com/berkaydev/google-maps-email-scraper-business-leads)
- [Trustpilot Reviews Scraper + Insights Report](https://apify.com/berkaydev/trustpilot-insights-scraper)
- [App Store & Google Play Reviews Scraper + Insights](https://apify.com/berkaydev/app-review-insights-scraper)
- [SEO & Technical Site Audit](https://apify.com/berkaydev/seo-audit-tool)

# Actor input Schema

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

G2 product review page URLs or bare slugs to scrape. Examples: 'slack', 'https://www.g2.com/products/slack/reviews'. One per line.

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

Maximum number of reviews to scrape per product. Set to 0 for unlimited.

## `stars` (type: `array`):

Only return reviews with these star ratings. Leave empty for all ratings.

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

Sort reviews by recency or helpfulness.

## `generateInsights` (type: `boolean`):

Compute an analytics/insights report after scraping: rating trends, top complaint/praise keywords, response rate, suspicious spikes, B2B segment breakdown, and multi-product comparison. Written to key-value store as JSON (INSIGHTS) and HTML (REPORT).

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

Apify proxy settings. RESIDENTIAL is mandatory, not a preference: G2 is protected by DataDome, which serves a hard CAPTCHA to every datacenter IP — such runs return zero reviews. Residential proxy requires a paid Apify plan; verify your account actually lists the RESIDENTIAL group (Settings → Proxy), because selecting it here does not grant access. Prefer a US exit: G2 localizes by IP.

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

Number of parallel browser contexts. Higher values use more memory.

## `requestDelayMs` (type: `integer`):

Milliseconds to wait between page fetches within a product. Raise it to be more polite.

## `selfTest` (type: `boolean`):

Diagnostic mode: parse a recorded G2 page offline and verify every extracted field, then exit. Uses no network and no proxy. Use this to check whether the scraper still understands G2's markup.

## `maxRunTimeSecs` (type: `integer`):

Internal run deadline. The actor will flush collected data and exit cleanly before this limit.

## Actor input object example

```json
{
  "productUrls": [
    "slack"
  ],
  "maxReviewsPerProduct": 25,
  "stars": [],
  "sort": "most_recent",
  "generateInsights": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 1,
  "requestDelayMs": 500,
  "selfTest": false,
  "maxRunTimeSecs": 3000
}
```

# Actor output Schema

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

One row per scraped G2 review: rating, pros, cons, reviewer role and company size, vendor reply, and dates.

## `report` (type: `string`):

Ready-to-read report: rating trends, complaint and praise keywords, vendor response rate, spike detection, and a breakdown by company size and job role.

## `insights` (type: `string`):

The full analytics object behind the report, machine-readable for your own pipelines.

# 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 = {
    "productUrls": [
        "slack"
    ],
    "maxReviewsPerProduct": 25,
    "generateInsights": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("berkaydev/g2-reviews-insights-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 = {
    "productUrls": ["slack"],
    "maxReviewsPerProduct": 25,
    "generateInsights": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("berkaydev/g2-reviews-insights-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "productUrls": [
    "slack"
  ],
  "maxReviewsPerProduct": 25,
  "generateInsights": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call berkaydev/g2-reviews-insights-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=berkaydev/g2-reviews-insights-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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