# G2.Com Scraper (It works) (`coder_luffy/g2-scraper`) Actor

G2.com scraper that pulls software listings, ratings, pros and cons, and market segment data from any category page, so you can track a market without checking it manually.

- **URL**: https://apify.com/coder\_luffy/g2-scraper.md
- **Developed by:** [Luffy](https://apify.com/coder_luffy) (community)
- **Categories:** Developer tools, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.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.com Scraper](https://i.imgur.com/4OwVZQu.png)

## G2.com Scraper

Extract software listings from G2.com category pages, including ratings, reviews, pricing, pros and cons highlights, market segment breakdowns, and direct product URLs.

### What it does

G2.com is a peer-to-peer software review platform with millions of verified reviews. This scraper takes any G2.com category page URL and collects all listings, paginating automatically.

For each listing it collects:

- Product name, slug, and direct URL to the G2 reviews page
- Logo URL
- Vendor name and vendor page URL
- Average star rating and total review count
- Entry level pricing
- Full product description
- Pros highlights (top positive aspects from reviewers)
- Cons highlights (top negative aspects from reviewers)
- Typical user roles and industries
- Market segment breakdown (Small-Business / Mid-Market / Enterprise percentages)
- Category name and ID

### Why it matters

G2 ratings come from verified buyers. The market segment field is the one worth paying attention to — a 4.2 from mostly SMB users reads differently than a 4.2 from enterprise teams. Same number, different story.

The pros and cons are aggregated from reviewer text. You get the recurring themes rather than individual opinions. When "Learning Curve" shows up in the cons column for five tools in a row, that's the category telling you something.

Schedule it and you get a running record. Useful for watching what happens to a competitor's score after a rough release, or spotting a newer product quietly picking up reviews before it shows up anywhere else.

### Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `urls` | Array of strings | required | One or more G2.com category page URLs |
| `maxItems` | Integer | 25 | Maximum listings to collect across all URLs (up to 50000) |
| `requestTimeoutSecs` | Integer | 30 | Per-request timeout in seconds (5 to 120) |

#### Example input

```json
{
  "urls": [
    "https://www.g2.com/categories/crm",
    "https://www.g2.com/categories/marketing-automation"
  ],
  "maxItems": 25
}
````

G2.com shows 15 listings per page. `maxItems: 15` = 1 page, `maxItems: 150` = 10 pages. Maximum supported value is `50000`.

#### Popular category URLs

**Marketing and sales**

- https://www.g2.com/categories/crm
- https://www.g2.com/categories/marketing-automation
- https://www.g2.com/categories/email-marketing
- https://www.g2.com/categories/lead-generation
- https://www.g2.com/categories/sales-intelligence
- https://www.g2.com/categories/sales-engagement

**Customer support**

- https://www.g2.com/categories/help-desk
- https://www.g2.com/categories/live-chat
- https://www.g2.com/categories/customer-success

**HR and finance**

- https://www.g2.com/categories/core-hr
- https://www.g2.com/categories/applicant-tracking-systems
- https://www.g2.com/categories/payroll
- https://www.g2.com/categories/accounting

**Collaboration and productivity**

- https://www.g2.com/categories/project-management
- https://www.g2.com/categories/team-collaboration
- https://www.g2.com/categories/video-conferencing
- https://www.g2.com/categories/task-management

Tip: G2 category slugs are predictable. If you know the category name, try `/categories/the-category-name` with hyphens. Most work on the first guess.

### Output

Each item represents one software listing.

```json
{
  "productId": 506,
  "productUuid": "16e299ae-0256-44e3-8989-7647815550d4",
  "productName": "Agentforce Sales (formerly Salesforce Sales Cloud)",
  "productSlug": "agentforce-sales-formerly-salesforce-sales-cloud",
  "productUrl": "https://www.g2.com/products/agentforce-sales-formerly-salesforce-sales-cloud/reviews",
  "logoUrl": "https://images.g2crowd.com/uploads/product/hd_favicon/826ce87155a61f72d3dfd92c5283eed8/agentforce.svg",
  "vendor": "Salesforce",
  "vendorUrl": "https://www.g2.com/sellers/salesforce",
  "ratingAvg": 4.4,
  "numReviews": 25619,
  "entryLevelPrice": "$25.00",
  "productDescription": "Accelerate revenue from pipeline to paycheck with Salesforce Sales Cloud...",
  "prosHighlights": ["Ease of Use", "Features", "Lead Management", "Customization"],
  "consHighlights": ["Learning Curve", "Pricing", "Complexity"],
  "userSentiment": "Reviewers appreciate Agentforce Sales for its powerful automation, customizable dashboards, and real-time insights. Users reported it can be complex to set up and has a steep learning curve.",
  "typicalUsers": "Account Executive, Account Manager, Sales Manager",
  "industries": "Computer Software, Information Technology and Services",
  "marketSegment": "46% Mid-Market, 34% Enterprise",
  "consultingServicesUrl": "https://www.g2.com/products/agentforce-sales-formerly-salesforce-sales-cloud/imp",
  "category": "CRM",
  "categoryId": 179,
  "pageNumber": 1,
  "sourceUrl": "https://www.g2.com/categories/crm",
  "scrapedAt": "2026-04-19T10:00:00.000000+00:00",
  "error": null
}
```

#### Output in Apify table view

![Table view](https://i.imgur.com/EkP8glK.png)

#### Output in Apify JSON view

![JSON view](https://i.imgur.com/1UnM5F0.png)

### Pagination

The actor reads the total page count from each category page and paginates automatically.

- `maxItems: 15` = 1 page per URL
- `maxItems: 150` = 10 pages per URL
- `maxItems: 975` = 65 pages (full CRM category)
- `maxItems: 50000` = maximum supported value

### Scheduled runs

1. Open your actor and click Schedules
2. Set a cron expression. `0 8 * * 1` runs every Monday at 8 AM
3. Save

Each run appends fresh data. Run weekly for a few months and you have a genuine time-series of category ratings, review counts, and market segment shifts.

### Best practices

Run with `maxItems: 15` first to confirm the URL works before scaling up.

Market segment data only appears when enough users from each company size have reviewed a product. Newer or lightly-reviewed products may return `null` here — that's expected.

The pros and cons highlights are G2's own aggregation of reviewer language, not individual quotes. They're better for bulk comparison across a category than reading individual reviews one by one.

If you want to track a specific set of tools rather than a whole category, collect the full category once, filter to the products you care about, then use their individual G2 review URLs for deeper scraping.

Export to Google Sheets via the Apify integration tab. New runs append rows automatically, giving you a live sheet that updates on every scheduled run without any manual work.

### About G2.com

G2.com is a software review platform with millions of verified reviews across thousands of categories. Reviews are verified through LinkedIn or business email. The G2 Score is calculated from satisfaction ratings, review volume, and market presence data. Products that clear a threshold on these metrics earn a G2 Leader badge and appear at the top of their category.

### Related actors

These actors cover other major software review platforms in the same family:

- [GetApp.com Scraper](https://apify.com/kawsar/getapp-com-scraper) — software listings from GetApp.com category pages
- [Capterra Scraper](https://apify.com/kawsar/capterra-scraper) — software listings from Capterra category pages
- [Capterra Reviews Scraper](https://apify.com/kawsar/capterra-reviews-scraper) — individual user reviews from Capterra product pages

***

[![Visit Apify](https://i.imgur.com/ZPi3odq.png)](https://apify.com/kawsar)

# Actor input Schema

## `urls` (type: `array`):

One or more G2.com category page URLs to scrape. Use the category page URL, e.g. https://www.g2.com/categories/crm or https://www.g2.com/categories/marketing-automation

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

Maximum number of software listings to collect in total across all URLs. Each G2.com category page shows 15 listings, so 15 = 1 page, 150 = 10 pages. Maximum supported value is 50000.

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

Per-request timeout in seconds.

## Actor input object example

```json
{
  "urls": [
    "https://www.g2.com/categories/email-marketing"
  ],
  "maxItems": 25,
  "requestTimeoutSecs": 30
}
```

# 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 = {
    "urls": [
        "https://www.g2.com/categories/crm"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("coder_luffy/g2-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 = { "urls": ["https://www.g2.com/categories/crm"] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "G2.Com Scraper (It works)",
        "description": "G2.com scraper that pulls software listings, ratings, pros and cons, and market segment data from any category page, so you can track a market without checking it manually.",
        "version": "0.0",
        "x-build-id": "YyCJYXXtnQhLj4cR7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/coder_luffy~g2-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-coder_luffy-g2-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/coder_luffy~g2-scraper/runs": {
            "post": {
                "operationId": "runs-sync-coder_luffy-g2-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/coder_luffy~g2-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-coder_luffy-g2-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",
                "properties": {
                    "urls": {
                        "title": "Category URLs",
                        "type": "array",
                        "description": "One or more G2.com category page URLs to scrape. Use the category page URL, e.g. https://www.g2.com/categories/crm or https://www.g2.com/categories/marketing-automation",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of software listings to collect in total across all URLs. Each G2.com category page shows 15 listings, so 15 = 1 page, 150 = 10 pages. Maximum supported value is 50000.",
                        "default": 25
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout (seconds)",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Per-request timeout in seconds.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
