# G2 Reviews Scraper (`ef12/g2-reviews-scraper`) Actor

Scrape G2 product reviews for any software. Get review text, ratings, pros, cons, author details, dates, and company responses. Filter by rating and sort by newest or most helpful.

- **URL**: https://apify.com/ef12/g2-reviews-scraper.md
- **Developed by:** [Daniel Wilson](https://apify.com/ef12) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## G2 Reviews Scraper

Extract **authentic user reviews** from any product page on [G2.com](https://www.g2.com) — the world's largest software marketplace. This Actor scrapes review titles, ratings, pros/cons, author metadata, and more, delivering structured JSON data ready for analysis, dashboards, or competitive research.

Runs on the **Apify platform** with automatic proxy rotation, scheduling, and API access — no infrastructure to manage.

---

### What does G2 Reviews Scraper do?

The **G2 Reviews Scraper** visits any G2 product reviews page (like `https://www.g2.com/products/slack/reviews`), parses every review card on the page using **BeautifulSoup** — a fast, lightweight HTML parser — and extracts structured data fields including the reviewer's name, star rating, review title, full review body, the "pros" and "cons" sections, review date, verified status, company size, and industry. It **automatically paginates** through multiple pages using G2's `?page=N` URL parameter, stopping when it has collected the number of reviews you specify.

Each review is pushed to the Apify dataset, where you can export it as **JSON, CSV, Excel, HTML, or XML** — or consume it programmatically via the Apify API.

---

### Why use G2 Reviews Scraper?

#### Competitive Intelligence

Monitor how users talk about competing products. Track rating trends over time, identify common complaints, and find features users wish existed. Export review data into a spreadsheet or BI tool for side-by-side comparison.

#### Market Research

Aggregate reviews across multiple product categories to understand what buyers value most — pricing, ease of use, customer support, integrations. The structured data (pros/cons lists, star ratings, company size) makes quantitative analysis straightforward.

#### Product Management

Feed real user feedback into your product roadmap. Pull verified reviews for your own product to surface recurring themes in what users like and dislike, then share summarized insights with your engineering and design teams.

#### Lead Generation & Sales Intelligence

Combine reviewer metadata (company size, industry, verified status) with review content to qualify leads. A reviewer who works at an enterprise company and complains about a competitor's lack of a specific feature is a warm lead for your product.

#### Content Marketing & SEO

Use G2 review excerpts (properly attributed) in case studies, testimonial pages, or social proof sections. The structured format makes it easy to filter for the best quotes by rating or topic.

#### Academic & Data Science Research

Build datasets of software reviews for sentiment analysis, topic modeling (LDA), or training NLP classifiers. Each review comes with a 1–5 numeric rating — a built-in label for supervised learning.

---

### How to use G2 Reviews Scraper

#### 1. Find Product Reviews URL

Go to G2.com, search for the product you're interested in, and navigate to its **Reviews** tab. Copy the full URL from your browser's address bar. It should look like:

```text
https://www.g2.com/products/slack/reviews
````

#### 2. Configure the Actor

Open the **Input** tab in Apify Console (or use `test-input.json` for local runs). Fill in:

- **Product Reviews URL** — paste the URL from step 1
- **Max Reviews** — how many reviews to collect (the first **10 are free**, then [PPE pricing](#pricing--cost-estimation) kicks in)
- **Minimum Rating** — filter out reviews below a star threshold
- **Sort Order** — newest, most helpful, highest rated, or lowest rated first

#### 3. Run and Export

Click **Run** (or run locally with `apify run --input-file=test-input.json`). When the Actor finishes, open the **Output** tab to browse the scraped reviews in a table. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

***

### Input

| Field | Type | Required | Default | Description |
| --- | --- | --- | --- | --- |
| `product_url` | string | ✅ | — | Full G2 reviews URL |
| `max_results` | integer | ❌ | 25 | Max reviews to scrape (1–500) |
| `min_rating` | integer | ❌ | 0 | Minimum star rating filter (1–5, 0 = no filter) |
| `sort` | string | ❌ | `newest` | Sort order: `newest`, `most_helpful`, `highest`, `lowest` |
| `proxyConfiguration` | object | ❌ | Apify RESIDENTIAL | Proxy settings |

#### Example input

```json
{
  "product_url": "https://www.g2.com/products/slack/reviews",
  "max_results": 25,
  "min_rating": 4,
  "sort": "most_helpful"
}
```

***

### Output

Each item in the dataset represents one review with the following fields:

```json
{
  "author": "John D.",
  "rating": 4.5,
  "title": "Great for team communication",
  "body": "Slack has transformed how our distributed team communicates...",
  "pros": "Easy to use, great integrations, fast search",
  "cons": "Can be distracting with too many channels",
  "date": "Mar 15, 2025",
  "is_verified": true,
  "company_size": "Mid-Market",
  "industry": "Technology"
}
```

#### Data table

| Field | Type | Description |
| --- | --- | --- |
| `author` | string | Reviewer display name |
| `rating` | number | Star rating (1.0 – 5.0, supports half-stars) |
| `title` | string | Review headline |
| `body` | string | Full review text |
| `pros` | string | What the reviewer liked best |
| `cons` | string | What the reviewer disliked or suggested improving |
| `date` | string | Publication date |
| `is_verified` | boolean | Whether G2 verified the reviewer |
| `company_size` | string | Company size category (if available) |
| `industry` | string | Reviewer's industry (if available) |

***

### Pricing / Cost estimation

#### How much does it cost to scrape G2 reviews?

- The **first 10 reviews per run** are free — no charges applied
- Each additional review beyond 10 incurs a **$0.005 PPE (Pay Per Event)** charge under the event name `result`
- A separate **$0.00005** charge for `apify-actor-start` is applied once per run

**Example:** Scraping 100 reviews costs approximately **$0.45** (90 paid reviews × $0.005 + $0.00005 start fee).

Apify's [free tier](https://apify.com/pricing) includes $5 of monthly Platform Usage credits for new users — enough to scrape thousands of reviews before hitting any charges.

***

### Tips & Advanced Options

#### Proxy Configuration

G2 may block or throttle scrapers that send many requests from the same IP. This Actor defaults to **Apify's residential proxy** (`RESIDENTIAL` group), which rotates through real user IPs to avoid detection. If you have your own proxy pool, update the `proxyConfiguration` field in the input.

#### Sort Order for Efficient Scraping

If you only need the most recent reviews, use `sort: "newest"` (default). This gives you the freshest data first and lets you stop early with a smaller result set.

#### Filtering by Rating

Set `min_rating: 4` to collect only positive reviews, or `min_rating: 1` to exclude the small number of one-star ratings. Zero means no filter — you get everything.

#### Rate Limiting and Delays

The BeautifulSoupCrawler handles polite crawling automatically with configurable concurrency, retries, and backoff. G2's pages are static HTML, so no browser overhead is needed — this keeps runs fast and cost-effective.

***

### FAQ, Disclaimers, and Support

#### Is scraping G2 legal?

Web scraping of **publicly available data** (information visible to any website visitor without logging in) is generally legal in most jurisdictions. However, you should review G2's Terms of Service and robots.txt before running this Actor at scale. This Actor is designed for research, competitive analysis, and personal use — always respect the target website's terms.

#### Does G2 block scrapers?

G2 employs anti-bot protections including Cloudflare challenge pages and rate limiting. **Residential proxies are strongly recommended** for runs that scrape more than ~50 reviews. The Actor handles 403/429 errors gracefully and will not continue if the page is completely blocked.

#### What if a field is empty?

Some reviews may not include all metadata fields (e.g., company size or industry). Empty fields are returned as empty strings. The actor skips review cards that contain no meaningful content (less than 50 characters of text).

#### Can I scrape multiple products in one run?

Not directly. Run the Actor once per product URL. You can automate multiple runs via the Apify API, then merge the datasets programmatically.

#### Known limitations

- G2 sometimes changes its CSS class names (React CSS modules). The Actor uses multiple fallback selectors per field to stay resilient, but a major layout change may require updating the selectors.
- Reviews behind a login wall (private products) cannot be scraped.
- The Actor does not resolve JavaScript-rendered content — it relies on server-rendered HTML that G2 serves on the first load.

#### Need help or a custom solution?

Open an issue on the [GitHub repository](https://github.com/apify/apify-templates) or contact Apify support for custom Actor development, enterprise crawling pipelines, or integration into your existing data stack.

# Actor input Schema

## `product_url` (type: `string`):

Full URL to the G2 product reviews page (e.g., https://www.g2.com/products/slack/reviews)

## `max_results` (type: `integer`):

Maximum number of reviews to scrape (10 free, then PPE $0.005/result)

## `min_rating` (type: `integer`):

Only return reviews with this rating or higher (0 = no filter)

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

How to sort reviews on G2

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

Proxy settings (recommended: Apify proxy with residential IPs to avoid G2 blocking)

## Actor input object example

```json
{
  "product_url": "https://www.g2.com/products/slack/reviews",
  "max_results": 25,
  "min_rating": 0,
  "sort": "newest",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "product_url": "https://www.g2.com/products/slack/reviews"
};

// Run the Actor and wait for it to finish
const run = await client.actor("ef12/g2-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 = { "product_url": "https://www.g2.com/products/slack/reviews" }

# Run the Actor and wait for it to finish
run = client.actor("ef12/g2-reviews-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 '{
  "product_url": "https://www.g2.com/products/slack/reviews"
}' |
apify call ef12/g2-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "G2 Reviews Scraper",
        "description": "Scrape G2 product reviews for any software. Get review text, ratings, pros, cons, author details, dates, and company responses. Filter by rating and sort by newest or most helpful.",
        "version": "0.0",
        "x-build-id": "2Wgv3wMGGdQMCK2hR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ef12~g2-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ef12-g2-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/ef12~g2-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-ef12-g2-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/ef12~g2-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-ef12-g2-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "product_url"
                ],
                "properties": {
                    "product_url": {
                        "title": "Product Reviews URL",
                        "type": "string",
                        "description": "Full URL to the G2 product reviews page (e.g., https://www.g2.com/products/slack/reviews)"
                    },
                    "max_results": {
                        "title": "Max Reviews",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape (10 free, then PPE $0.005/result)",
                        "default": 25
                    },
                    "min_rating": {
                        "title": "Minimum Rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only return reviews with this rating or higher (0 = no filter)",
                        "default": 0
                    },
                    "sort": {
                        "title": "Sort Order",
                        "enum": [
                            "newest",
                            "most_helpful",
                            "highest",
                            "lowest"
                        ],
                        "type": "string",
                        "description": "How to sort reviews on G2",
                        "default": "newest"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings (recommended: Apify proxy with residential IPs to avoid G2 blocking)",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
