# G2 Intelligence API: Reviews, Products, Competitors & Changes (`sagepennystudio/g2-intelligence-api`) Actor

Scrape G2 reviews, product profiles, ratings, pricing and top competitors from a software name or URL. Monitoring mode returns only new or edited reviews and rating changes on scheduled runs, so you pay once per review.

- **URL**: https://apify.com/sagepennystudio/g2-intelligence-api.md
- **Developed by:** [Josh Goodman](https://apify.com/sagepennystudio) (community)
- **Categories:** Lead generation, AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 reviews

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## G2 Intelligence API: Reviews, Products, Competitors & Changes

Type a software name, such as **"HubSpot CRM"**, or paste any G2 link. The Actor returns clean, structured G2 data:

- **Reviews**: star rating, title, what users like and dislike, the problems solved, reviewer job title, company size and industry, verification badges, and dates.
- **Product profiles**: rating, review count, star breakdown, pricing plans, categories, vendor, and G2's pros and cons themes.
- **Competitors**: G2's top 10 alternatives, with rating, review count, categories in common and G2's head-to-head verdicts (for example, "easier to admin" or "more expensive").
- **Category rankings**: the ranked product list for any G2 category, with price ranges.

Then schedule it. In monitoring mode, later runs return **only new or edited reviews and product changes** (rating, review count, pricing). You don't pay again for the same review.

### What you can do with it

| Goal | How |
|---|---|
| **Get alerted when a competitor gets a bad review** ("Tell me whenever HubSpot gets a new 1- or 2-star review") | Products or companies: `HubSpot CRM`, Only these star ratings: `1, 2`, Mode: `Only new reviews`, then schedule it daily with an email, Slack or webhook integration |
| **Spot vendors in trouble** ("CRM vendors whose rating is falling while review volume grows") | Categories: `crm`, Scrape every product: on, Mode: `New and edited reviews`, weekly schedule. Product records carry a `changes` object, e.g. `rating: {previous: 4.4, current: 4.3}` |
| **Build an AI or RAG dataset** ("Up to 500 reviews each for 100 SaaS products, in one normalized dataset") | Paste 100 product names or URLs, Max reviews per product: `500`, Mode: `Full export` |
| **Win-loss and battlecards** | Include competitors: on, Also scrape the competitors: on. You get your product and its 10 alternatives, reviews included |
| **Voice-of-customer for your own product** | Your G2 URL + `Only new reviews`, pushed to Google Sheets, Slack, Clay, n8n or Make |

### Why this Actor

- **Names in, data out.** Enter "Zoho CRM" or "Slack" and the Actor finds the G2 page for you. You can also enter product, category, alternatives or search URLs.
- **Monitoring built in.** Every review is fingerprinted. `NEW_ONLY` and `NEW_AND_CHANGED` runs skip what you've already received, stop early, and bill only for fresh records.
- **Filters apply while crawling.** Star rating, reviewer company size and a published-after date are applied on G2 itself, so you don't pay for reviews you'll throw away.
- **One consistent schema** for reviews, products, competitors and categories. Every row has a `recordType`, so one dataset feeds any pipeline.
- **Built for G2's anti-bot protection.** A real browser runs behind residential proxies, each blocked page is retried with a fresh identity, and review pages are fetched from G2's lightweight review endpoint to keep runs fast.

### Input examples

**Monitor a competitor's complaints**

```json
{
    "searchTerms": ["HubSpot CRM"],
    "starRatings": ["1", "2"],
    "mode": "NEW_ONLY",
    "monitorName": "hubspot-complaints"
}
```

**Full export for a list of products**

```json
{
    "startUrls": [
        { "url": "https://www.g2.com/products/slack/reviews" },
        { "url": "https://www.g2.com/products/asana/reviews" }
    ],
    "maxReviewsPerProduct": 0,
    "reviewsPublishedAfter": "2026-01-01"
}
```

**Category leaderboard plus competitors**

```json
{
    "categories": ["crm"],
    "maxProductsPerCategory": 25,
    "searchTerms": ["Pipedrive"],
    "includeAlternatives": true
}
```

### Output

All records go to one dataset. The Console has three ready-made views: **Reviews**, **Products** and **Competitors & category rankings**. Download as JSON, CSV, Excel or HTML, or read it through the API. Filter by `recordType` (`review`, `product`, `alternative`, `categoryProduct`) to split them. Sample values below are illustrative.

**Review**

```json
{
    "recordType": "review",
    "changeType": "NEW",
    "reviewId": 13623488,
    "reviewUrl": "https://www.g2.com/products/slack/reviews/slack-review-13623488",
    "productName": "Slack",
    "productSlug": "slack",
    "title": "Very reliable for team communication",
    "rating": 5,
    "publishedDate": "2026-09-27",
    "updatedDate": "2026-09-27",
    "reviewer": {
        "name": "Jane D.",
        "jobTitle": "Program Manager",
        "companySize": "Mid-Market (51-1000 emp.)",
        "industry": null
    },
    "likeBest": "Slack brings meetings, chats and file sharing into one place…",
    "dislike": "There are too many notifications…",
    "problemsSolved": "I use Slack to share project progress updates…",
    "answers": [{ "question": "What do you like best about Slack?", "answer": "…" }],
    "badges": {
        "validatedReviewer": true,
        "currentUser": false,
        "incentivized": true,
        "aiTranslated": false,
        "reviewSource": "Seller invite"
    },
    "scoreExclusionNote": null,
    "contentHash": "1fd8d29103fc8b49",
    "scrapedAt": "2026-09-27T23:14:20.843Z"
}
```

**Product**

```json
{
    "recordType": "product",
    "changeType": "CHANGED",
    "changes": { "reviewCount": { "previous": 39830, "current": 39840 } },
    "name": "Slack",
    "slug": "slack",
    "productId": 3437,
    "vendorName": "Salesforce",
    "rating": 4.5,
    "reviewCount": 39840,
    "starDistributionPct": { "1": 0, "2": 0, "3": 3, "4": 20, "5": 75 },
    "pricing": [
        { "plan": "Free", "price": "$0.00", "unit": null },
        { "plan": "Standard", "price": "$6.67", "unit": "per active user, per month (billed annually)" }
    ],
    "prosThemes": ["Ease of Use", "Team Collaboration", "Communication"],
    "consThemes": ["Notification Issues", "Missing Features"],
    "categories": ["Business Instant Messaging", "Work Management"],
    "integrationsCount": 395
}
```

**Competitor**

```json
{
    "recordType": "alternative",
    "sourceProductSlug": "slack",
    "rank": 1,
    "name": "ClickUp",
    "slug": "clickup",
    "vendorName": "ClickUp",
    "rating": 4.6,
    "reviewCount": 14381,
    "comparisonNotes": ["Slower to reach roi", "More expensive"],
    "categoriesInCommon": ["Knowledge Base", "Unified Workspaces", "Work Management"]
}
```

A `RUN_SUMMARY` record in the run's key-value store lists the counts, new and changed reviews, unresolved names and any pages that failed.

### How monitoring works

1. The first run with a new **monitor name** returns everything that matches, up to your limits, and remembers each review's ID and a fingerprint of its content.
2. Each later run with the same monitor name in `NEW_ONLY` mode returns only reviews it hasn't delivered before. It reads newest-first and stops at the first page with nothing new, so a daily check usually costs a single page per product.
3. `NEW_AND_CHANGED` also returns reviews whose text, rating or "updated" date changed, marked `changeType: "CHANGED"`.
4. A product record is returned only when something about it changed. The `changes` object shows the previous and current values.

Use a separate monitor name for each client or watch list. The memory is stored in a named key-value store in your own Apify account (`g2-intel-<monitor name>`).

### Pricing

Pay per result, with no monthly rental:

| Event | Price |
|---|---|
| Review | $0.004 |
| Product profile | $0.01 |
| Competitor or category-ranking row | $0.002 |

Example: 5 products with 200 reviews each costs 5 × $0.01 + 1,000 × $0.004 = **$4.05**. A daily monitor that finds 3 new reviews costs about **$0.01** that day. Set a maximum cost per run in the run options to cap spend; the Actor stops cleanly when it reaches it.

### Tips

- **Keep the default residential proxy.** G2 is protected by DataDome and blocks datacenter IPs.
- **How many reviews per product?** G2 shows logged-out visitors about 100 reviews (10 pages) for any one sort or filter. When you ask for more than 100, the Actor automatically splits each product by star rating, gets up to 100 per star level, and shares your limit evenly across them. That's up to about **500 reviews per product**, fewer when a product has few reviews at some star levels. For a product's newest reviews over time, use monitoring mode: each daily run picks up whatever is new.
- Review pages after the first are fetched inside the already-loaded page, so each extra page of 10 reviews usually takes a couple of seconds.
- If a name matches the wrong product, paste the G2 URL instead, or raise **Matches per product name** and pick from the results.
- G2's star filter takes one star value at a time, so each selected rating is crawled separately. **Max reviews per product** is a total across all the ratings you pick, and each rating gets its own ~100-review view.

### FAQ

**Is scraping G2 legal?** The Actor collects only publicly visible data, without logging in. Reviews contain names and job titles people chose to publish. Your use of the data must still follow G2's terms and privacy laws such as GDPR in your jurisdiction. If in doubt, consult a lawyer.

**Do I need a G2 account?** No.

**Can I get reviews from before a certain date only?** Use **Only reviews published after** for a lower bound. For an upper bound, filter the dataset by `publishedDate`.

**Something broke or a field is missing.** Open an issue on the Issues tab with the run link. G2 changes its pages often, and fixes usually ship within a day.

# Actor input Schema

## `searchTerms` (type: `array`):

Software or company names, e.g. "HubSpot CRM" or "Slack". Each name is looked up on G2 and the best match is scraped, so you don't need to find the URL.

## `startUrls` (type: `array`):

Any G2 URL: a product (https://www.g2.com/products/slack/reviews), a competitor list (.../competitors/alternatives), a category (https://www.g2.com/categories/crm) or a search (https://www.g2.com/search?query=crm).

## `categories` (type: `array`):

G2 category slugs or URLs, e.g. "crm" or "project-management". Returns the ranked product list. Turn on "Scrape every product in the categories" to also get each product's reviews.

## `mode` (type: `string`):

FULL returns everything that matches. NEW_ONLY returns only reviews (and product changes) not seen in earlier runs of the same monitor, so a daily schedule bills you only for fresh data. NEW_AND_CHANGED also returns reviews whose text, rating or update date changed.

## `monitorName` (type: `string`):

Runs that share a monitor name share their memory of what has already been seen. Use a different name per client or watch list.

## `includeProductDetails` (type: `boolean`):

One record per product: rating, review count, star breakdown, pricing plans, categories, vendor, pros and cons themes. In monitoring modes it is only returned when something changed.

## `includeReviews` (type: `boolean`):

Turn off to get product profiles and competitor lists only.

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

Stops after this many reviews per product. 0 means as many as G2 shows. G2 shows about 100 per view to logged-out visitors; above 100 the Actor splits by star rating automatically to reach up to ~500. In monitoring modes the limit applies to new reviews.

## `reviewSort` (type: `string`):

Order in which G2 returns reviews. Most recent is required for efficient monitoring and for the date cutoff to stop early.

## `starRatings` (type: `array`):

Filter reviews by star rating at crawl time, so you don't pay for reviews you don't want. Example: \[1, 2] for complaint monitoring. Leave empty for all ratings.

## `companySizes` (type: `array`):

Filter reviews by the reviewer's company size. Leave empty for all.

## `reviewsPublishedAfter` (type: `string`):

Skip older reviews (YYYY-MM-DD). With "Most recent" order the crawl stops as soon as it reaches this date.

## `includeAlternatives` (type: `boolean`):

Adds G2's top alternatives for each product: rank, rating, review count, categories in common and G2's comparison notes (e.g. "easier to admin").

## `maxAlternatives` (type: `integer`):

G2 lists up to 10.

## `scrapeAlternatives` (type: `boolean`):

Scrape every competitor's product profile and reviews too (with the same review settings). Great for competitor monitoring; multiplies the volume by up to 10.

## `maxSearchResults` (type: `integer`):

How many G2 search results to scrape for each name in "Products or companies". 1 takes the best match.

## `maxProductsPerCategory` (type: `integer`):

How many ranked products to return from each category.

## `scrapeCategoryProducts` (type: `boolean`):

Also scrape each category product's profile and reviews.

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

G2 is protected by DataDome, which blocks datacenter IPs. Residential proxies are required.

## `maxConcurrency` (type: `integer`):

Higher is faster but raises the chance of being blocked.

## `maxRequestRetries` (type: `integer`):

Each retry uses a fresh browser identity and IP.

## `debugSaveBlockedPages` (type: `boolean`):

Store the HTML of anti-bot pages in the key-value store.

## `blockResources` (type: `boolean`):

Skips images, fonts and third-party scripts to cut proxy bandwidth (the main running cost). Turn off only if pages fail to load.

## Actor input object example

```json
{
  "searchTerms": [
    "Slack"
  ],
  "mode": "FULL",
  "monitorName": "default",
  "includeProductDetails": true,
  "includeReviews": true,
  "maxReviewsPerProduct": 20,
  "reviewSort": "most_recent",
  "includeAlternatives": false,
  "maxAlternatives": 10,
  "scrapeAlternatives": false,
  "maxSearchResults": 1,
  "maxProductsPerCategory": 15,
  "scrapeCategoryProducts": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  },
  "maxConcurrency": 3,
  "maxRequestRetries": 8,
  "debugSaveBlockedPages": false,
  "blockResources": true
}
```

# Actor output Schema

## `reviews` (type: `string`):

No description

## `products` (type: `string`):

No description

## `competitors` (type: `string`):

No description

## `allRecords` (type: `string`):

No description

## `runSummary` (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 = {
    "searchTerms": [
        "Slack"
    ],
    "maxReviewsPerProduct": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("sagepennystudio/g2-intelligence-api").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 = {
    "searchTerms": ["Slack"],
    "maxReviewsPerProduct": 20,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("sagepennystudio/g2-intelligence-api").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchTerms": [
    "Slack"
  ],
  "maxReviewsPerProduct": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call sagepennystudio/g2-intelligence-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sagepennystudio/g2-intelligence-api"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/x5pWOJBtugOpr1I5t/builds/L9bMzdU535Fk2FbWZ/openapi.json