# G2 Software Review Feed Scraper (`automation-lab/g2-software-review-feed-scraper`) Actor

Extract public G2 product review RSS feeds into clean review records for SaaS sentiment monitoring and competitive research.

- **URL**: https://apify.com/automation-lab/g2-software-review-feed-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Review Feed Scraper

Extract public G2 product-review RSS feeds into clean, analysis-ready review records.

Use it to monitor ratings, review text, pros, cons, reviewer context, and newly published feedback for SaaS products.

> This actor is deliberately RSS-only. It does not browse G2 HTML pages or require an account.

### What does it do?

It turns public `g2.com/products/<slug>/reviews.rss` feeds into one dataset row per review.

Each run accepts G2 product URLs or product slugs and derives the canonical RSS URL safely.

### Who is it for?

- SaaS product marketers tracking review sentiment.
- Competitive-intelligence agencies monitoring several vendors.
- Product-research teams collecting public customer feedback.
- Data teams that need a repeatable G2 review extractor.

### Why use the RSS feed?

G2 HTML can use anti-bot protection. Public review feeds are a stable, lightweight HTTP source.

The actor never falls back to HTML, so its scope stays predictable and transparent.

### What data do I get?

| Field | Meaning |
| --- | --- |
| `productSlug` | Canonical G2 product slug |
| `rating` | Numeric rating when included by the feed |
| `title` | Review headline |
| `body` | Review content |
| `pros` / `cons` | Structured positive and negative feedback |
| `reviewerName` | Public reviewer label |
| `reviewerRole` | Reviewer role when available |
| `reviewerCompanySize` | Company-size context when available |
| `publishedAt` | RSS publication date |
| `reviewUrl` | Original public G2 review URL |
| `sourceStatus` | `ok` or `error` for feed visibility |

### Quick start

1. Enter one or more G2 product URLs or slugs.
2. Keep the default limit low for a quick first run.
3. Run the actor.
4. Export the default dataset to CSV, JSON, or your warehouse.

### Product URL examples

Use a product page, review page, or RSS feed URL.

```json
{"productUrls":[{"url":"https://www.g2.com/products/slack/reviews.rss"}],"maxReviewsPerProduct":20}
````

### Slug examples

A slug is the part after `/products/` in a G2 product URL.

```json
{"productSlugs":["slack","hubspot-marketing-hub"],"maxReviewsPerProduct":25}
```

### Filter by date

Use `sinceDate` for recurring monitoring workflows.

```json
{"productSlugs":["slack"],"sinceDate":"2026-01-01","maxReviewsPerProduct":50}
```

Reviews without a usable feed date are retained so you do not silently miss data.

### Input reference

`productUrls` accepts only G2 product paths. Non-G2 URLs are ignored rather than crawled.

`productSlugs` is an optional compact alternative to URLs.

`maxReviewsPerProduct` is capped at 100 because an RSS feed is a recent-review feed, not a full historical archive.

### Output example

```json
{"productSlug":"slack","rating":4.5,"reviewerRole":"Consultant","pros":"Fast team communication","cons":"Many notifications","sourceStatus":"ok"}
```

Missing public fields are returned as `null`, not invented values.

### Source errors

A missing or unavailable feed produces a dataset row with `sourceStatus: "error"` and an `error` message.

This makes scheduled monitoring easy to audit without inspecting logs.

### Review identity and duplicates

The actor uses the RSS GUID or review URL as `reviewId`.

Duplicate product inputs and repeated feed entries are de-duplicated within the run.

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

Pricing uses a small run-start fee plus a per-review event.

Volume tiers are applied by Apify automatically. Check the Actor pricing panel for current tier prices.

You are charged for successfully extracted review records, not feed-error status rows.

### Integrations

Send exported rows to Google Sheets for a weekly voice-of-customer report.

Use Make, Zapier, or an Apify webhook to alert Slack when new low-rating feedback appears.

Load `reviewId` into a database and compare it with prior runs for incremental monitoring.

### Node.js API

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/g2-software-review-feed-scraper').call({ productSlugs: ['slack'], maxReviewsPerProduct: 20 });
console.log(await client.dataset(run.defaultDatasetId).listItems());
```

### Python API

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/g2-software-review-feed-scraper').call(run_input={'productSlugs':['slack'], 'maxReviewsPerProduct':20})
print(list(client.dataset(run['defaultDatasetId']).iterate_items()))
```

### cURL API

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~g2-software-review-feed-scraper/runs?token=YOUR_APIFY_TOKEN' -H 'content-type: application/json' -d '{"productSlugs":["slack"],"maxReviewsPerProduct":20}'
```

### AI assistant prompts

In Claude Code or Claude Desktop, add the Apify MCP integration with `?tools=automation-lab/g2-software-review-feed-scraper`.

Prompt: “Extract the newest public G2 reviews for Slack and summarize recurring cons.”

Prompt: “Monitor these G2 product slugs and return review records published since last month.”

### Tips for reliable runs

Use canonical G2 product URLs whenever possible.

Start with 20 reviews per product, then increase only when the RSS feed contains more recent entries.

Schedule one run per day or week for competitor monitoring.

### Limits

This actor reads public RSS feeds only. It cannot retrieve reviews that G2 does not expose in the feed.

It does not access private data, user accounts, or browser-only G2 content.

### Legal and ethical use

Use public data responsibly and comply with G2 terms, applicable law, and your organization’s policies.

Do not use extracted reviewer context for harassment, discrimination, or prohibited profiling.

### Troubleshooting

**Why did I get an error row?** The product slug may be wrong, the feed may be unavailable, or G2 may have removed the product feed.

**Why are there fewer rows than requested?** RSS feeds contain a limited set of recent entries; the actor does not invent pagination beyond what the feed exposes.

**Why are pros or cons empty?** Some review entries do not publish those sections.

### FAQ

**Do I need G2 credentials?** No. The actor accesses only the public RSS endpoint.

**Can I pass a category URL?** No. Use a G2 product URL or a product slug.

**Does it scrape G2 HTML?** No. That is intentionally out of scope for reliability.

### Related scrapers

For G2 category discovery, use [G2 Software Categories Scraper](https://apify.com/automation-lab/g2-software-categories-scraper).

For broader review workflows, combine this actor with your CRM or sentiment-analysis pipeline.

### Changelog

See [the actor changelog](.actor/CHANGELOG.md) for user-visible release notes.

### MCP setup

Connect this actor directly over Apify's hosted MCP endpoint. In Claude Code, add the actor-scoped HTTP tool:

```bash
claude mcp add --transport http apify-g2-reviews "https://mcp.apify.com?tools=automation-lab/g2-software-review-feed-scraper"
```

For Claude Desktop, Cursor, or VS Code, add this HTTP server configuration and restart the client:

```json
{
  "mcpServers": {
    "apify-g2-reviews": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/g2-software-review-feed-scraper"
    }
  }
}
```

#### Example prompts

- “Use the G2 Software Review Feed Scraper to collect the 20 newest Slack reviews and group the cons by theme.”
- “Run the G2 review-feed tool for slack, zoom, and notion; return new low ratings with reviewer role and review URL.”
- “Monitor the G2 review feeds for these competitor slugs and summarize changes since last month.”

### API Usage

The Node.js, Python, and cURL examples above start a run and retrieve its default dataset through the Apify API.

### Legality

Only collect public RSS review data for legitimate research and monitoring. Follow G2 terms, applicable privacy law, and your organization’s policies.

### Support

Include the product URL or slug and the `sourceStatus` field when reporting a feed problem.

# Actor input Schema

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

G2 product pages or RSS URLs, for example https://www.g2.com/products/slack/reviews.rss.

## `productSlugs` (type: `array`):

Alternative to URLs, e.g. slack or hubspot-marketing-hub.

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

Newest RSS reviews to save for each product.

## `sinceDate` (type: `string`):

ISO date, for example 2026-01-01. Reviews with unavailable dates are retained.

## `includeRawFeed` (type: `boolean`):

Adds the original feed XML to the first review from each product for troubleshooting.

## Actor input object example

```json
{
  "productUrls": [
    {
      "url": "https://www.g2.com/products/slack/reviews.rss"
    }
  ],
  "productSlugs": [
    "slack"
  ],
  "maxReviewsPerProduct": 20,
  "includeRawFeed": false
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "productUrls": [
        {
            "url": "https://www.g2.com/products/slack/reviews.rss"
        }
    ],
    "productSlugs": [
        "slack"
    ],
    "maxReviewsPerProduct": 20,
    "includeRawFeed": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/g2-software-review-feed-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "productUrls": [{ "url": "https://www.g2.com/products/slack/reviews.rss" }],
    "productSlugs": ["slack"],
    "maxReviewsPerProduct": 20,
    "includeRawFeed": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/g2-software-review-feed-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "productUrls": [
    {
      "url": "https://www.g2.com/products/slack/reviews.rss"
    }
  ],
  "productSlugs": [
    "slack"
  ],
  "maxReviewsPerProduct": 20,
  "includeRawFeed": false
}' |
apify call automation-lab/g2-software-review-feed-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "G2 Software Review Feed Scraper",
        "description": "Extract public G2 product review RSS feeds into clean review records for SaaS sentiment monitoring and competitive research.",
        "version": "0.1",
        "x-build-id": "OqdRgZ7xDU26qM7Gq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~g2-software-review-feed-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-g2-software-review-feed-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/automation-lab~g2-software-review-feed-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-g2-software-review-feed-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/automation-lab~g2-software-review-feed-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-g2-software-review-feed-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": {
                    "productUrls": {
                        "title": "🔗 G2 product URLs",
                        "type": "array",
                        "description": "G2 product pages or RSS URLs, for example https://www.g2.com/products/slack/reviews.rss.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "productSlugs": {
                        "title": "G2 product slugs (optional)",
                        "type": "array",
                        "description": "Alternative to URLs, e.g. slack or hubspot-marketing-hub.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerProduct": {
                        "title": "Maximum reviews per product",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Newest RSS reviews to save for each product.",
                        "default": 20
                    },
                    "sinceDate": {
                        "title": "Only reviews published since (optional)",
                        "type": "string",
                        "description": "ISO date, for example 2026-01-01. Reviews with unavailable dates are retained."
                    },
                    "includeRawFeed": {
                        "title": "Include raw RSS XML",
                        "type": "boolean",
                        "description": "Adds the original feed XML to the first review from each product for troubleshooting.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```