# G2 Reviews Scraper (Cheap) (`data_api/g2-reviews-scraper-cheap`) Actor

G2 reviews scraper that pulls full customer reviews from any G2 product page, so you can keep tabs on what people actually think about your competitors.

- **URL**: https://apify.com/data\_api/g2-reviews-scraper-cheap.md
- **Developed by:** [Data API](https://apify.com/data_api) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Software Reviews Scraper

![G2 Software Reviews Scraper](cover.jpg)

G2 holds thousands of honest reviews for almost every B2B tool, but reading them one card at a time is slow and there is no download button. This scraper fixes that. Paste a G2 product reviews link and every review comes back as a tidy row: the star score, the pros and cons in the reviewer's own words, their job role and company size, the date, and the trust badges. Point it at your own product or a competitor's and pull one page or thousands. It's quick, cheap, and code-free, and you only pay for the reviews you collect.

### What you get

Each review becomes one row with a steady set of columns, so the data drops straight into a sheet, a database, or a model. Three groups of data per review:

- **The review** — `headline`, `starScore`, `prosText`, `consText`, `problemsAddressed`, `datePosted`, `reviewLink`
- **The reviewer** — `authorName`, `authorRole`, `authorCompanySize`, `reviewerBadges`, `validatedReviewer`, `activeUser`, `incentivized`, `sourceChannel`, `hasVideo`
- **Context and IDs** — `softwareName`, `softwareKey`, `reviewKey`, `authorKey`, `vendorReply`, `pageUrl`, `collectedAt`

### Quick start

1. Open the G2 reviews page you care about and copy the link from the address bar.
2. Hit **Try for free** and paste that link into **G2 reviews page link**.
3. Set **How many reviews to fetch** to cap the run.
4. Press **Start**, then export the results as JSON, CSV, Excel, or XML.

![How it works](how-it-works.jpg)

### Use cases

- **Competitor research** — read what real users praise and complain about in a rival tool, at scale
- **Product feedback** — group your own reviews by `prosText` and `consText` to spot recurring themes
- **Win-loss analysis** — pair `starScore` with `authorRole` and `authorCompanySize` to see who rates you how
- **Marketing and social proof** — pull validated five-star reviews for testimonials and case studies
- **Market sizing** — compare review volume and average score across a category of tools
- **Sentiment tracking** — run a reviews link on a schedule and watch scores move over time

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `reviewsPageUrl` | string | Yes | Link to the G2 product reviews page. Plain, sorted, sentiment-filtered, and reviews_and_filters links all work. Prefilled with the Slack reviews page. |
| `resultsLimit` | integer | No | Top number of reviews to gather per run; the scraper turns the pages on its own. Default `25`. |
| `timeoutSeconds` | integer | No | How long to wait on a single request before giving up. Default `240`. |

#### Example input

```json
{
    "reviewsPageUrl": "https://www.g2.com/products/slack/reviews",
    "resultsLimit": 25,
    "timeoutSeconds": 240
}
````

### Output

Each review on the page becomes one row, paginated automatically up to your limit. Anything G2 does not show for a given review comes back empty rather than guessed.

#### Example output

```json
{
    "reviewKey": "9418273",
    "authorKey": "5821094",
    "reviewLink": "https://www.g2.com/products/slack/reviews/slack-review-9418273",
    "softwareName": "Slack",
    "softwareKey": "12345",
    "authorName": "Jordan M.",
    "authorRole": "Operations Manager",
    "authorCompanySize": "Mid-Market (51-1000 emp.)",
    "starScore": 4.5,
    "headline": "Keeps the whole team on the same page",
    "datePosted": "2026-05-14",
    "prosText": "Channels and threads keep conversations organized, and search across our whole history is genuinely fast.",
    "consText": "Notifications can get noisy on busy days, and the free plan caps message history sooner than I'd like.",
    "problemsAddressed": "Cut down on internal email and gave us one place for project chat across three offices.",
    "reviewerBadges": ["Validated Reviewer", "Current User"],
    "validatedReviewer": true,
    "activeUser": true,
    "incentivized": false,
    "sourceChannel": "Organic",
    "hasVideo": false,
    "vendorReply": "Thanks for the kind words, Jordan — we're glad Slack keeps your team connected.",
    "pageUrl": "https://www.g2.com/products/slack/reviews",
    "collectedAt": "2026-06-29T12:00:00.000000+00:00"
}
```

#### Output fields

| Field | Type | Description |
|-------|------|-------------|
| `reviewKey` | string | G2 identifier for the review |
| `authorKey` | string | G2 identifier for the reviewer |
| `reviewLink` | string | Direct link to the single review |
| `softwareName` | string | Name of the reviewed product |
| `softwareKey` | string | G2 identifier for the product |
| `authorName` | string | Reviewer's display name |
| `authorRole` | string | Reviewer's job title |
| `authorCompanySize` | string | Company-size bracket of the reviewer |
| `starScore` | number | Star rating on a five-point scale |
| `headline` | string | Quoted headline of the review |
| `datePosted` | string | Date the review was published |
| `prosText` | string | What the reviewer liked most |
| `consText` | string | What the reviewer disliked |
| `problemsAddressed` | string | Problems the software solves for the reviewer |
| `reviewerBadges` | array | Trust badges shown on the review |
| `validatedReviewer` | boolean | True when G2 has validated the reviewer |
| `activeUser` | boolean | True when the reviewer is a current user of the product |
| `incentivized` | boolean | True when the review was incentivized |
| `sourceChannel` | string | Where the review came from |
| `hasVideo` | boolean | True when the review includes a video |
| `vendorReply` | string | The vendor's public response, when present |
| `pageUrl` | string | The reviews page link you supplied |
| `collectedAt` | string | ISO 8601 timestamp of when the row was captured |

### Tips for best results

- **Sort or filter on G2 first.** A `?order=most_recent` link gets you the newest reviews, and sentiment filters narrow the set before you scrape, so your run stays focused.
- **Start with a small `resultsLimit`.** Pull 25 reviews to confirm the columns fit your pipeline, then raise it for the full set.
- **Pull pros and cons separately.** `prosText` and `consText` come split, which saves you from cleaning a single review blob later.
- **Lean on the trust flags.** Filter on `validatedReviewer` for testimonials, or drop `incentivized` reviews when you want unbiased sentiment only.
- **Raise `timeoutSeconds`** if you see timeouts while pulling large products with thousands of reviews.

### How can I use G2 review data?

**How can I use the G2 Software Reviews Scraper to research a competitor?**
Paste a competitor's G2 reviews link and run it. Each row carries `starScore`, `prosText`, `consText`, `authorRole`, and `authorCompanySize`, so you can see what their customers love, where they get frustrated, and which segments rate the tool best — a clean base for any competitive teardown.

**How can I export G2 reviews to a spreadsheet?**
Set `resultsLimit` to the number you need and run the scraper. Every review comes back as one structured row, and you export the whole dataset to CSV, Excel, or JSON in one click — no copy-paste off the G2 page.

**How can I track software review sentiment over time?**
Run the same reviews link on a schedule. With `starScore` and `datePosted` on every row, you can chart how a product's rating shifts week to week and catch a drop in sentiment as new reviews land.

### Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses or private contact information. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Support

Questions, feature requests, or a field you'd like added? Reach out at <data.apify@proton.me> and we'll get back to you.

# Actor input Schema

## `reviewsPageUrl` (type: `string`):

Paste the address of the G2 product reviews page you want to collect. Plain review links, sorted or sentiment-filtered links, and reviews\_and\_filters links all work. Example: https://www.g2.com/products/slack/reviews

## `resultsLimit` (type: `integer`):

Top number of reviews to gather in a single run. G2 lists ten reviews per page, and the scraper turns the pages on its own until it hits this figure.

## `timeoutSeconds` (type: `integer`):

How long to wait on a single request before giving up on it.

## Actor input object example

```json
{
  "reviewsPageUrl": "https://www.g2.com/products/notion/reviews?order=most_recent#reviews",
  "resultsLimit": 10,
  "timeoutSeconds": 240
}
```

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "G2 Reviews Scraper (Cheap)",
        "description": "G2 reviews scraper that pulls full customer reviews from any G2 product page, so you can keep tabs on what people actually think about your competitors.",
        "version": "0.0",
        "x-build-id": "WRqBIWDp4Bk6Qg910"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/data_api~g2-reviews-scraper-cheap/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-data_api-g2-reviews-scraper-cheap",
                "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/data_api~g2-reviews-scraper-cheap/runs": {
            "post": {
                "operationId": "runs-sync-data_api-g2-reviews-scraper-cheap",
                "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/data_api~g2-reviews-scraper-cheap/run-sync": {
            "post": {
                "operationId": "run-sync-data_api-g2-reviews-scraper-cheap",
                "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": [
                    "reviewsPageUrl"
                ],
                "properties": {
                    "reviewsPageUrl": {
                        "title": "G2 reviews page link",
                        "type": "string",
                        "description": "Paste the address of the G2 product reviews page you want to collect. Plain review links, sorted or sentiment-filtered links, and reviews_and_filters links all work. Example: https://www.g2.com/products/slack/reviews"
                    },
                    "resultsLimit": {
                        "title": "How many reviews to fetch",
                        "minimum": 1,
                        "maximum": 5000000,
                        "type": "integer",
                        "description": "Top number of reviews to gather in a single run. G2 lists ten reviews per page, and the scraper turns the pages on its own until it hits this figure.",
                        "default": 10
                    },
                    "timeoutSeconds": {
                        "title": "Request timeout in seconds",
                        "minimum": 5,
                        "maximum": 300,
                        "type": "integer",
                        "description": "How long to wait on a single request before giving up on it.",
                        "default": 240
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
