# G2 Reviews Scraper (It works) (`kawsar/g2-reviews-scraper`) 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/kawsar/g2-reviews-scraper.md
- **Developed by:** [Kawsar](https://apify.com/kawsar) (community)
- **Categories:** Automation, Developer tools, Lead generation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 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 Reviews Scraper

![G2 Reviews Scraper](https://i.imgur.com/itndorW.png)

Scrape full customer reviews from any G2 product page. You get reviewer names, job titles, company sizes, star ratings, full pros and cons text, vendor responses, and trust badges. Works with filtered URLs and pages automatically to go well beyond what the G2 interface shows.

### What this actor does

G2 is a software review platform where verified buyers leave detailed feedback about products they actually use. This actor pulls that data out so you can work with it.

Paste a G2 product reviews URL and it returns structured records. Each record covers everything on the page: who left the review, what they liked and disliked, how they rated the product, whether their account was validated, and whether the submission was organic or came from an incentivized invite.

It pages automatically. G2 shows 10 reviews per page; the actor keeps going until it hits your limit or runs out of reviews. The default is 10 (first page), and you can go up to 5,000,000.

### Why this data is useful

G2 reviews are written by people with opinions, not by marketing teams. A single detailed review often tells you more about a competitor's real weaknesses than any analyst report.

Some practical uses:

- Schedule the actor weekly on a competitor's page sorted by `most_recent`. When a new wave of complaints appears, you know about it before your next sales call.
- Pull reviews from people who mention a specific pain point your product addresses. That reviewer's job title, company size, and G2 profile is right there in the output.
- Run it on your own product to feed structured feedback into your roadmap. The `likedBest`, `dislikedMost`, and `problemsSolved` fields are already separated out.
- Scrape several competitors at once and aggregate the ratings into a single spreadsheet for comparison.
- Feed review data into an LLM to generate weekly competitor intelligence summaries automatically.
- Filter by `isIncentivized` to separate organic opinions from review campaigns, useful when evaluating the credibility of a product's rating.
- Use `reviewerJobTitle` and `reviewerCompanySize` to segment feedback by role or company size, so you know whether complaints are coming from enterprise buyers or small teams.
- Track a product's average rating over time by storing scraped data in a database and running the actor on a schedule.

### What you can do with G2 review data

**Competitive intelligence.** Software buyers often describe exactly what they switched from, what they miss, and what they wish were different. That language is useful. If 40 reviewers of a competitor all say the same thing about a missing feature, that's a pattern worth knowing.

**Sales and prospecting.** Reviewers are named, with job titles and company sizes. Someone who wrote a negative review of a direct competitor is a warm lead. They've already told you what they don't like about the alternative.

**Product research.** Your own G2 reviews are structured feedback you don't need to manually read through one by one. Scrape them into a spreadsheet, run a sentiment pass, and you have a prioritized list of what's working and what isn't.

**Reputation monitoring.** Set up a daily or weekly schedule and connect the dataset to a Slack webhook or Google Sheet. You'll see new reviews in near real time without having to check the G2 page manually.

**Market research.** Scrape reviews across an entire software category to understand what buyers in that market care about, what language they use, and what they're willing to pay for.

### Sample output

![Sample output 1](https://i.imgur.com/WYWW7N8.png)

![Sample output 2](https://i.imgur.com/kXsv96m.png)

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| startUrl | string | required | Full G2 product reviews URL |
| maxItems | integer | 10 | Max reviews to collect (up to 5,000,000) |
| requestTimeoutSecs | integer | 300 | Per-request timeout in seconds |

#### URL formats

Plain reviews URL:
````

https://www.g2.com/products/apify/reviews

```

Filtered URL (the actor preserves your filters and sort order):
```

https://www.g2.com/products/chatgpt/reviews?filters%5Bcomment\_answer\_values%5D=\&order=most\_recent\&utf8=%E2%9C%93#reviews

```

Deep pagination URL:
```

https://www.g2.com/products/run-powered-by-adp/reviews\_and\_filters?page=50#reviews

````

#### A note on pagination

G2's page navigation caps out at around 10 pages in the UI. The data goes much further. This actor uses the `reviews_and_filters` endpoint with a `page` parameter to reach any page in the history. A product with 5,000 reviews is fully accessible; just raise `maxItems` and let it run.

### Output fields

| Field | Description |
|---|---|
| reviewId | G2 internal review ID |
| reviewerId | G2 internal reviewer ID |
| reviewUrl | Direct permalink to the review on G2 |
| productName | Product name |
| productId | G2 product ID |
| reviewerName | Reviewer name (first name + last initial) |
| reviewerJobTitle | Job title as listed on G2 |
| reviewerCompanySize | Company size (e.g. "Small-Business (50 or fewer emp.)") |
| rating | Star rating out of 5 |
| reviewTitle | Review headline |
| publishedDate | Date published (YYYY-MM-DD) |
| likedBest | Full text of "What do you like best?" |
| dislikedMost | Full text of "What do you dislike?" |
| problemsSolved | Full text of "What problems is X solving?" |
| badges | Array of trust badges on the review |
| isValidatedReviewer | Reviewer was validated via business email |
| isCurrentUser | Reviewer verified as a current user |
| isIncentivized | Review was incentivized |
| reviewSource | Source label ("Organic", "G2 invite", etc.) |
| videoReview | Review includes video |
| vendorResponse | Full vendor response text, if any |
| sourceUrl | The input URL you provided |
| scrapedAt | ISO 8601 scrape timestamp |

#### Example output

```json
{
  "reviewId": "12611447",
  "reviewerId": "7156957",
  "reviewUrl": "https://www.g2.com/products/capsule-crm/reviews/capsule-crm-review-12611447",
  "productName": "Capsule CRM",
  "productId": "1585",
  "reviewerName": "Yllza H.",
  "reviewerJobTitle": "Admissions Coordinator",
  "reviewerCompanySize": "Small-Business (50 or fewer emp.)",
  "rating": 5.0,
  "reviewTitle": "Highly Customizable Pipelines and Tasks That Fit Our Needs",
  "publishedDate": "2026-04-10",
  "likedBest": "What I like best about Capsule CRM is its flexibility and ease of use. The ability to customize pipelines and tasks allows us to align the system with our specific workflows...",
  "dislikedMost": "I don't like that we can't separate milestones or tracks by pipeline...",
  "problemsSolved": "It helps us stay in regular contact with our customers and keep our workflow organized...",
  "badges": ["Current User", "Validated Reviewer", "Source: Organic"],
  "isValidatedReviewer": true,
  "isCurrentUser": true,
  "isIncentivized": false,
  "reviewSource": "Organic",
  "videoReview": false,
  "vendorResponse": "Thank you for your review! We're so pleased you're finding Capsule easy to use...",
  "sourceUrl": "https://www.g2.com/products/capsule-crm/reviews",
  "scrapedAt": "2026-04-19T10:30:00+00:00"
}
````

### Scheduling for continuous monitoring

To catch new reviews as they come in, set up a schedule in Apify. Go to your actor's Schedules tab and configure it to run daily or weekly. Use a URL sorted by `order=most_recent` so you always get the newest reviews first. New records accumulate in the dataset over time and can feed a webhook, a spreadsheet sync, or any downstream pipeline.

### Other review platforms

If you're building a cross-platform review monitoring pipeline, these actors cover complementary platforms:

- [GetApp Scraper](https://apify.com/coder_luffy/getapp-com-scraper) covers many of the same software products as G2
- [Capterra Reviews Scraper](https://apify.com/kawsar/capterra-reviews-scraper) pulls structured reviews from Capterra
- [Capterra Scraper](https://apify.com/kawsar/capterra-scraper) covers broader Capterra product data

![Review Monitoring](https://i.imgur.com/LSYFTO9.png)

# Actor input Schema

## `startUrl` (type: `string`):

Full URL of the G2 product reviews page to scrape. Accepts plain review URLs, filtered URLs (order, sentiment), and reviews\_and\_filters URLs. Example: https://www.g2.com/products/apify/reviews

## `maxItems` (type: `integer`):

Maximum number of reviews to collect per run. G2 shows 10 reviews per page; the actor pages automatically to reach this number.

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

Per-request timeout in seconds.

## Actor input object example

```json
{
  "startUrl": "https://www.g2.com/products/chatgpt/reviews?filters%5Bcomment_answer_values%5D=&order=most_recent&utf8=%E2%9C%93#reviews",
  "maxItems": 10,
  "requestTimeoutSecs": 300
}
```

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

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "G2 Reviews Scraper (It works)",
        "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": "Rgh7wmVCSerjJoaqf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kawsar~g2-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kawsar-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/kawsar~g2-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-kawsar-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/kawsar~g2-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-kawsar-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": [
                    "startUrl"
                ],
                "properties": {
                    "startUrl": {
                        "title": "G2 product reviews URL",
                        "type": "string",
                        "description": "Full URL of the G2 product reviews page to scrape. Accepts plain review URLs, filtered URLs (order, sentiment), and reviews_and_filters URLs. Example: https://www.g2.com/products/apify/reviews"
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000000,
                        "type": "integer",
                        "description": "Maximum number of reviews to collect per run. G2 shows 10 reviews per page; the actor pages automatically to reach this number.",
                        "default": 10
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 300,
                        "type": "integer",
                        "description": "Per-request timeout in seconds.",
                        "default": 300
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
