# G2 Scraper API — Reviews, Products, Ratings & Competitors (`pro100chok/g2-scraper`) Actor

G2 scraper and unofficial G2.com API: extract B2B software reviews with full reviewer detail, product profiles, ratings, pricing plans, review breakdowns by segment and industry, alternatives and comparisons. Past G2's 100-review cap. Export JSON, CSV, Excel. From $4.50/1k reviews.

- **URL**: https://apify.com/pro100chok/g2-scraper.md
- **Developed by:** [Raven](https://apify.com/pro100chok) (community)
- **Categories:** Developer tools, E-commerce, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 review scrapeds

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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 Scraper — Reviews, Products, Ratings & Competitors

**Scrape G2.com reviews and product intelligence from $4.50 per 1,000 reviews.** No login, no API key, no code, no proxies to configure — paste a product, a category, a search or a comparison URL and get clean rows.

> **One input field for everything.** A product URL or slug, a category, a G2 search URL, a comparison URL, or just a search phrase — each entry is recognised automatically. No separate field per task.
>
> **$4.50 / 1,000 reviews** · $0.012 per product profile · $3.00 / 1,000 listing rows · $0.007 per run. **Free tier:** new Apify users get $5 in platform credits — that's about **1,100 reviews** at no cost.

**Contents**: [What it does](#what-does-this-g2-scraper-do) · [Why use it](#why-use-this-scraper) · [Data you get](#what-data-can-you-extract) · [Step by step](#how-to-scrape-g2-step-by-step) · [Past the 100-review limit](#how-to-get-more-than-100-reviews-per-product) · [Recipes](#ready-to-paste-input-recipes) · [Pricing](#how-much-does-it-cost-to-scrape-g2) · [MCP](#use-with-ai-agents-mcp) · [Legality](#is-it-legal-to-scrape-g2) · [FAQ](#faq)

### What does this G2 Scraper do?

G2.com is the largest B2B software review platform. Its official API is enterprise-only — a sales call, a contract and a procurement cycle before you see a single row. This actor works as an **unofficial G2 API**: an HTTP endpoint you can call today, with no contract and no login, returning the same publicly visible review and product data as structured JSON.

Pick what you want in **What to collect**, paste where to start, and each mode returns exactly one record type:

| Mode | Record type | What you get |
| --- | --- | --- |
| **Reviews** | `review` | One row per review: full text of every G2 review question, rating, reviewer job title, industry, company size, verification badges |
| **Product profiles** | `product` | One row per product: rating, review count, categories, top pros & cons, pricing plans, seller, review breakdown, switching data |
| **Listing only** | `search_result` / `category_product` / `comparison_product` | The ranked product list from a category, a search or a comparison page |
| **Alternatives & competitors** | `alternative` | The competitor set G2 lists for a product, with ratings and review counts |
| **All G2 categories** | `category` | The full G2 category directory — no input needed |

### Why use this scraper?

- ✅ **26–31 fields per review** — every G2 review question in full, not a truncated snippet
- ✅ **35 fields per product profile**, including G2's own ranked top pros and cons
- ✅ **Past G2's 100-review ceiling** — the site itself never shows more than 10 pages per filter view; this actor slices and de-duplicates to go deeper
- ✅ **One input field** that accepts products, categories, searches, comparisons, slugs or plain phrases — mixed freely
- ✅ **Two steps in one run** — start from a search, get reviews for every product it finds
- ✅ **One mode, one record type** — your dataset is already a single clean table, not a mixed bag needing a filter
- ✅ **Exact review breakdowns** — counts by company size, reviewer role, industry, region and category
- ✅ **Switching data** — how many reviewers came from another tool, and where they went after
- ✅ **Anti-bot handling and proxy rotation built in** — nothing to configure
- ✅ **Charge cap respected** — set a maximum charge per run and the actor stops there instead of overrunning it

| | G2's official API | Typical G2 scrapers | This actor |
| --- | --- | --- | --- |
| Access | Enterprise contract, sales call | Apify account | Apify account |
| Setup | Weeks of procurement | Minutes | Minutes |
| Input | API keys and docs | Usually one URL type per actor | Products, categories, searches and comparisons in one field |
| Reviews per product | Contract-dependent | Often capped at what one filter view shows | Sliced past the public 100-per-view ceiling |
| Review breakdowns by segment/industry/region | — | Rarely | ✅ with exact counts |
| Switching data | — | Rarely | ✅ counts in and out |
| Record types | — | Often mixed in one dataset | One type per run |

### What data can you extract?

#### Review fields

| Field | Example |
| --- | --- |
| `rating` | `4.5` |
| `title` | `Organized Team Communication with Powerful Search` |
| `likeBest` | Full answer to "What do you like best?" |
| `dislike` | Full answer to "What do you dislike?" |
| `problemsSolved` | Which problems the product solves for them |
| `recommendations` | Advice to other buyers, when the reviewer left any |
| `reviewerName` | `Diana C.` |
| `reviewerJobTitle` | `Lead Business Efficiency Architect` |
| `reviewerIndustry` | `Information Technology and Services` |
| `companySegment` / `companySize` | `Mid-Market` / `51-1000 emp.` |
| `publishedDate` / `updatedDate` | `2026-07-29` / `2026-07-31` |
| `reviewSource` | `Organic`, `G2 invite` |
| `isValidatedReviewer` / `isCurrentUser` / `isIncentivized` / `isVideoReview` | `true` / `false` |
| `badges` | `["Current User", "Validated Reviewer", "Source: Organic"]` |
| `vendorResponse` | The vendor's official reply, when present |
| `disclaimer` | Any G2 notice attached to the review |
| `reviewId` / `reviewerId` / `url` | Stable IDs and a direct link to the review |
| `productId` / `productUuid` / `vendorId` / `productName` | Join keys back to the product |

#### Product profile fields

Ratings and volume: `rating`, `reviewCount`, `totalReviews`, `bestRating`, `worstRating`.
Positioning: `categories`, `breadcrumbs`, `topPros`, `topCons`, `tagline`, `metaDescription`.
Commercial: `pricingPlans` (name, price, billing unit), `entryPrice`, `sellerName`, `sellerUrl`, `integrationsCount`.
Breakdowns with exact counts: `byCompanySegment`, `byReviewerRole`, `byIndustry`, `byRegion`, `byCategory`.
Switching: `switchedFrom`, `switchedTo` with review counts per option.
Identity: `slug`, `name`, `url`, `productId`, `productUuid`, `vendorId`, `imageUrl`, `operatingSystem`.

#### Listing fields

`position`, `name`, `slug`, `url`, `rating`, `reviewCount`, `bestFor` (G2's editorial one-liner in category tables), plus `sourceUrl`, `sourceTitle` and the query or category the row came from.

### How to scrape G2 step by step

1. Sign in to Apify — new accounts get **$5 in free monthly credits**, enough for roughly 1,100 reviews.
2. Open the actor and choose **What to collect** (Reviews, Product profiles, Listing, Alternatives, or All categories).
3. Paste your targets into the single input field — `slack`, `https://www.g2.com/categories/crm`, `https://www.g2.com/search?query=bank`, or just `project management`.
4. Optionally set **Max reviews per product**, a sort order, and filters for star rating, company size, reviewer role or region.
5. Click **Start**. Rows appear while the run is still going.
6. Export from the **Dataset** tab as JSON, CSV, Excel, XML or JSONL — or pull it through the API.

### How to get more than 100 reviews per product

G2's own website only ever shows 10 pages — 100 reviews — for any single filter view. Page 11 returns the same rows as page 10. Most scrapers inherit that ceiling silently and simply stop.

This actor works around it: when you ask for more than a single view can give, it collects reviews in slices along G2's own filter axes — star rating, company size, reviewer role, then region — and de-duplicates every row by review ID. Ask for 500 or 5,000 and you get 500 or 5,000 **distinct** reviews.

Nothing to configure — just set **Max reviews per product**. Set it to `0` to take everything a product has (Slack alone has over 39,000).

### One input field, any starting point

You never pick a different field per task. Paste anything into **targets** — mix types freely, one per line:

| You paste | Recognised as |
| --- | --- |
| `https://www.g2.com/products/slack/reviews` or `slack` | a product |
| `https://www.g2.com/categories/crm` or `crm` | a category |
| `https://www.g2.com/search?query=bank` or `project management` | a search |
| `https://www.g2.com/compare/slack-vs-microsoft-teams` or `slack,microsoft-teams` | a comparison |

### Two steps in one run

Because the mode says *what* you want and the input says *where to start*, chaining is automatic. Ask for reviews but start from a search, and the actor walks the listing itself, then collects reviews for every product it found:

```json
{
  "scrapeType": "reviews",
  "targets": ["https://www.g2.com/search?query=bank"],
  "maxProductsToFollow": 10,
  "maxReviewsPerProduct": 200
}
```

The listing is used to find products, and its rows are **not** added to your dataset — so you are never billed for rows you did not ask for. When the product list itself is what you want, use the Listing mode.

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `scrapeType` | select | `reviews` | What to collect: `reviews`, `product_profile`, `listing`, `alternatives`, `categories_directory` |
| `targets` | array | — | Products, categories, searches, comparisons, slugs or plain phrases — mixed freely |
| `maxProductsToFollow` | integer | `10` | How many products to scrape from a listing. `0` = no limit |
| `maxReviewsPerProduct` | integer | `100` | Review cap per product. `0` = every review available |
| `sortBy` | select | `most_recent` | `most_recent`, `most_helpful`, `highest_rated`, `lowest_rated` |
| `stars` | array | all | Keep only selected star ratings (`5`…`1`) |
| `companySegments` | array | all | `Small-Business`, `Mid-Market`, `Enterprise` |
| `reviewerRoles` | array | all | `User`, `Administrator`, `Executive Sponsor`, `Internal Consultant`, `Consultant`, `Agency`, `Industry Analyst / Tech Writer` |
| `regions` | array | all | `North America`, `Asia`, `Europe`, `Latin America`, `Middle East`, `Africa`, `ANZ` |
| `maxItems` | integer | `0` | Hard cap on total records for the run |
| `maxListingPages` | integer | `1` | Pages to walk in a category listing (~20–30 products each) |
| `proxyConfiguration` | proxy | Residential US | Proxy used for the run |

### Ready-to-paste input recipes

#### Latest reviews for two products

```json
{
  "scrapeType": "reviews",
  "targets": ["https://www.g2.com/products/slack/reviews", "notion"],
  "maxReviewsPerProduct": 500,
  "sortBy": "most_recent"
}
```

#### Mine complaints from enterprise buyers

```json
{
  "scrapeType": "reviews",
  "targets": ["salesforce-crm"],
  "stars": ["1", "2"],
  "companySegments": ["Enterprise"],
  "sortBy": "lowest_rated",
  "maxReviewsPerProduct": 200
}
```

#### Profiles of the top 20 CRM products

```json
{
  "scrapeType": "product_profile",
  "targets": ["crm"],
  "maxProductsToFollow": 20
}
```

#### Reviews for everything a keyword search returns

```json
{
  "scrapeType": "reviews",
  "targets": ["https://www.g2.com/search?query=customer support"],
  "maxProductsToFollow": 15,
  "maxReviewsPerProduct": 100
}
```

#### Admin-only reviews from North America

```json
{
  "scrapeType": "reviews",
  "targets": ["hubspot-sales-hub"],
  "reviewerRoles": ["Administrator"],
  "regions": ["North America"],
  "maxReviewsPerProduct": 300
}
```

#### Competitor set for a product

```json
{
  "scrapeType": "alternatives",
  "targets": ["slack", "microsoft-teams"]
}
```

#### The whole G2 category directory

```json
{ "scrapeType": "categories_directory" }
```

### Output examples

#### Review row

```json
{
  "type": "review",
  "reviewId": 13183206,
  "url": "https://www.g2.com/products/slack/reviews/slack-review-13183206",
  "rating": 5.0,
  "title": "Organized Team Communication with Powerful Search, Integrations, and Slack AI Summaries",
  "likeBest": "Honestly, the channel organization is what keeps things from falling apart...",
  "dislike": "The notification system drives me crazy. I've spent way too much time...",
  "problemsSolved": "Before Slack, keeping my team aligned was a nightmare...",
  "reviewerName": "Diana C.",
  "reviewerJobTitle": "Lead Business Efficiency Architect",
  "reviewerIndustry": "Information Technology and Services",
  "companySegment": "Mid-Market",
  "companySize": "51-1000 emp.",
  "publishedDate": "2026-07-29",
  "updatedDate": "2026-07-31",
  "reviewSource": "Organic",
  "isValidatedReviewer": true,
  "isCurrentUser": true,
  "badges": ["Current User", "Validated Reviewer", "Source: Organic"],
  "productName": "Slack",
  "productSlug": "slack"
}
```

#### Product row

```json
{
  "type": "product",
  "name": "Slack",
  "rating": 4.5,
  "reviewCount": 39229,
  "entryPrice": "$0.00",
  "pricingPlans": [
    { "name": "Free", "price": "$0.00" },
    { "name": "Standard", "price": "$6.67", "unit": "per active user, per month (billed annually)" },
    { "name": "Plus", "price": "$12.50", "unit": "per active user, per month (billed annually)" },
    { "name": "Enterprise Grid", "price": "Contact Us" }
  ],
  "topPros": ["Ease of Use", "Team Collaboration", "Communication", "Integrations", "Features"],
  "topCons": ["Notification Issues", "Missing Features", "Limited Features", "Overwhelming Experience"],
  "categories": ["Business Instant Messaging", "Work Management", "Project Collaboration"],
  "sellerName": "Salesforce",
  "integrationsCount": 460,
  "byCompanySegment": [
    { "value": "Small Business (50 or fewer emp.)", "reviewCount": 15911 },
    { "value": "Mid-Market (51-1000 emp.)", "reviewCount": 15801 },
    { "value": "Enterprise ( >1000 emp.)", "reviewCount": 7155 }
  ],
  "byIndustry": [{ "value": "Computer Software", "reviewCount": 5973 }],
  "byRegion": [{ "value": "North America", "reviewCount": 27240 }],
  "switchedFrom": [{ "label": "Product A", "reviewCount": 346 }],
  "tagline": "All your team's communication, wherever you go."
}
```

#### Listing row

```json
{
  "type": "category_product",
  "position": 2,
  "slug": "slack",
  "name": "Slack",
  "url": "https://www.g2.com/products/slack/reviews",
  "rating": 4.5,
  "reviewCount": 39229,
  "bestFor": "Channel-based messaging with deep integrations",
  "sourceTitle": "Best Business Instant Messaging Software"
}
```

### How much does it cost to scrape G2?

Pay only for the records you receive.

| Event | Price |
| --- | --- |
| Actor start | $0.007 per run |
| Review | $0.0045 |
| Product profile | $0.012 |
| Listing item (search / category / comparison) | $0.003 |
| Alternative / competitor | $0.003 |
| Category | $0.001 |

Worked examples, with the arithmetic shown:

| Task | Cost |
| --- | --- |
| 100 reviews for one product | $0.007 + 100 × $0.0045 = **$0.46** |
| 1,000 reviews for one product | $0.007 + 1,000 × $0.0045 = **$4.51** |
| 10,000 reviews | $0.007 + 10,000 × $0.0045 = **$45.01** |
| 100 product profiles | $0.007 + 100 × $0.012 = **$1.21** |
| 25 products from a search listing | $0.007 + 25 × $0.003 = **$0.08** |
| The full G2 category directory | under **$0.50** |

**On the free plan**, Apify's $5 monthly credit covers roughly **1,100 reviews**, **400 product profiles** or **1,600 listing rows** — enough to evaluate the actor properly before paying anything.

The price is all-in: there is nothing extra to buy on top, and you are never charged for a target that returns no data. Set **Maximum charge per run** in the actor's options and the run stops when it reaches your cap rather than overrunning it.

### Integrations

Because this runs on Apify, the output plugs into the tools you already use — no glue code:

- **Google Sheets** — auto-export every run's dataset into a sheet.
- **Slack / Microsoft Teams** — alert on new one- and two-star reviews for your product or a competitor's.
- **Make and Zapier** — push reviews into a CRM, a warehouse or a ticketing system.
- **n8n** — self-hosted workflows over the same dataset.
- **Webhooks** — fire your own endpoint the moment a run finishes.
- **API clients** — official Python and JavaScript clients, plus plain REST.
- **Schedules** — run daily or weekly and diff on `reviewId` to catch only what is new.

### Use with AI agents (MCP)

Every Apify actor is reachable through the **Apify MCP server**, so an AI assistant can run this scraper as a tool. Add it to Claude Desktop, Cursor or VS Code:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=pro100chok/g2-scraper"
    }
  }
}
```

Then just ask:

> "Pull the 200 most recent G2 reviews of Notion, keep only the one- and two-star ones from enterprise reviewers, and summarise the recurring complaints."

#### Copy to your AI assistant

Paste this block into ChatGPT, Claude or Cursor to have it write the integration for you:

```
Apify actor `pro100chok/g2-scraper` scrapes G2.com.
Call it: ApifyClient(token).actor("pro100chok/g2-scraper").call(run_input={...})
Input: scrapeType ("reviews" | "product_profile" | "listing" | "alternatives" | "categories_directory"),
targets (array of G2 URLs, product/category slugs, or search phrases),
maxReviewsPerProduct (int), maxProductsToFollow (int),
sortBy ("most_recent" | "most_helpful" | "highest_rated" | "lowest_rated"),
stars (["5".."1"]), companySegments (["Small-Business","Mid-Market","Enterprise"]),
reviewerRoles, regions, maxItems.
Each mode returns one record type, discriminated by the `type` field.
Full schema: GET https://api.apify.com/v2/acts/pro100chok~g2-scraper/builds/default
Get a token at https://console.apify.com/settings/integrations
```

### Popular use cases

- **Competitive intelligence** — pull a competitor's one- and two-star reviews with `stars` and `sortBy: lowest_rated`, then mine `dislike` for the objections your sales team keeps hearing.
- **Win/loss research** — `switchedFrom` and `switchedTo` show how many reviewers arrived from another tool and how many left.
- **Product management** — `topCons` gives G2's own ranked complaint themes; `problemsSolved` explains what users actually hired the product to do.
- **Market research** — `byIndustry`, `byCompanySegment` and `byRegion` reveal which segments a product really serves, with exact counts.
- **Sales enablement** — build battlecards from `topPros`, `topCons`, `pricingPlans` and the competitor set in one run.
- **Investor due diligence** — track rating and review volume across a category over time with a scheduled run.
- **AI and RAG pipelines** — full review text with reviewer role, industry and company size makes clean, well-labelled chunks.
- **Lead research** — category and search listings give you the ranked vendor landscape with ratings and review counts.

### Is it legal to scrape G2?

Scraping publicly available web pages is generally legal, and this actor only reads what any visitor can see on G2 — no login, no paywall, no private data. It does not attempt to access anything behind an account.

Review text and reviewer display names are personal data in some jurisdictions. If you store or process them, make sure you have a lawful basis under GDPR, CCPA or the equivalent local rules, and do not use the data to contact, profile or target individual reviewers. When in doubt, talk to your counsel.

Apify has a good primer on the topic: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

This is an independent tool. It is not affiliated with, endorsed by or sponsored by G2.com, Inc. All trademarks belong to their respective owners.

### FAQ

#### Does G2 have a public API?

Not an open one. G2's official API is sold on enterprise terms — a sales conversation and a contract before access. This actor gives you the same publicly visible review and product data immediately, with no contract.

#### How many reviews can I scrape per product?

As many as the product has. G2's own site caps any single filter view at 100 reviews, and this actor goes past that by slicing along G2's filter axes and de-duplicating. Slack has over 39,000 reviews and all of them are reachable; use **Max reviews per product** to keep runs bounded.

#### Do I need proxies or an API key?

No. Proxy handling and anti-bot protection are built in, and residential US proxies are the default. You do not need a G2 account or any key.

#### Can I export G2 reviews to CSV or Excel?

Yes. Every run's dataset exports as CSV, Excel, JSON, XML or JSONL from the Apify Console, or through the API with `?format=csv`.

#### Will I be charged for URLs that return nothing?

No. Charging is per delivered record, so a target with no reviews costs nothing beyond the run start.

#### Why do some reviews have no job title or industry?

Because the reviewer did not disclose it — those fields are optional on G2's form. Roughly a third of reviews omit the industry. Missing values are left out rather than filled with guesses, and reviews G2 publishes anonymously are flagged with `reviewerIsAnonymous`.

#### Can I get only new reviews since my last run?

Use `sortBy: "most_recent"` with a modest **Max reviews per product**, run it on a Schedule, and de-duplicate on `reviewId`. The actor does not keep state between runs, so the diff happens on your side.

#### Can I filter reviews by date?

There is no date filter. Sort by **Most recent** and stop at the volume you need — `publishedDate` and `updatedDate` are on every row for filtering afterwards.

#### Does it return the sub-ratings like Ease of Use?

No. G2 renders those only in its interactive interface, so they are not part of the output. What you do get is `topPros` and `topCons` — G2's own ranked strengths and complaints per product — plus the full text of every review answer.

#### Can I get the names of products people switched from?

You get the counts, not the names. G2 deliberately blurs the product names in its switching chart and only shows shares publicly, so `switchedFrom` and `switchedTo` carry review counts with placeholder labels.

#### What does one run return — reviews, products, or both?

Exactly what you asked for. Each mode returns a single record type, so your dataset is one clean table. If you want both reviews and profiles, run the actor twice.

#### My run returned fewer reviews than the product page shows. Why?

Filters narrow the pool — a star, segment, role or region filter reduces the count, and the review total shown in the actor's output reflects the filtered view. Also check **Max reviews per product** and **Max items**, which both cap the run.

#### Can I scrape a whole category instead of one product?

Yes. Paste a category URL or slug (`crm`) and pick Listing mode for the product list, or Reviews mode to walk the category and collect reviews for every product in it, bounded by **Max products per listing**.

#### How fresh is the data?

Every run fetches live pages — there is no cache. What you get is what G2 shows at that moment.

#### How fast is a run?

It depends on volume and on G2's response times, so no fixed throughput is promised. Rows stream into the dataset as they are parsed, so you can start using the output before the run finishes.

### Feedback & support

Found a bug or need a field that is not in the output? Open an issue on the **Issues** tab of the actor page and include the run ID — that makes it fast to reproduce and fix. Feature requests for additional G2 pages are welcome.

### More scrapers by this developer

- [Trustpilot All-in-One Scraper](https://apify.com/pro100chok/trustpilot-all-in-one-scraper) — consumer reviews to pair with G2's B2B data
- [Similarweb Scraper](https://apify.com/pro100chok/similarweb-scraper) — traffic and audience data for the vendors you shortlist
- [Semrush Scraper](https://apify.com/pro100chok/semrush-scraper) — keyword and competitor visibility data
- [Ahrefs SEO Tools](https://apify.com/pro100chok/ahrefs-seo-tools) — backlinks and organic traffic estimates
- [Meta Ads Library Scraper](https://apify.com/pro100chok/meta-ads-library-scraper) — what your competitors are advertising right now
- [Google Maps Scraper](https://apify.com/pro100chok/google-maps-scraper) — local business data and reviews

**Tags:** g2 scraper, g2.com scraper, g2 reviews scraper, scrape g2 reviews, g2 api, unofficial g2 api, g2 reviews api, g2 product data, g2 ratings scraper, g2 category scraper, g2 search scraper, g2 competitors scraper, g2 alternatives scraper, software reviews scraper, b2b software reviews, saas review data, software market research, competitive intelligence, win loss analysis, review monitoring, g2 crowd scraper, g2 csv export, g2 json export, no code scraper

# Actor input Schema

## `scrapeType` (type: `string`):

What you want back. This is independent of what you paste below: give it a category or search and ask for Reviews, and the actor walks the listing and then collects reviews for every product it finds - all in one run.

## `targets` (type: `array`):

One field for everything - mix and match freely, one entry per line. Accepts: a product URL (https://www.g2.com/products/slack/reviews) or slug (slack); a category URL or slug (https://www.g2.com/categories/crm, crm); a G2 search URL (https://www.g2.com/search?query=bank); a comparison URL (https://www.g2.com/compare/slack-vs-microsoft-teams) or two slugs (slack,microsoft-teams); or just a search phrase (project management). Each entry is recognised automatically.

## `maxProductsToFollow` (type: `integer`):

When a category, search or comparison is used as the starting point, how many of the products found there to scrape. Set 0 for no limit.

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

Stop after this many reviews per product. Set 0 to collect every review a product has (large products have tens of thousands).

## `sortBy` (type: `string`):

Order in which reviews are collected. Most recent is best for monitoring; highest or lowest rated pulls praise or complaints first.

## `stars` (type: `array`):

Only collect reviews with these star ratings. Leave empty for all ratings.

## `companySegments` (type: `array`):

Only collect reviews written by people at companies of these sizes. Leave empty for all.

## `reviewerRoles` (type: `array`):

Only collect reviews written by these roles. Leave empty for all roles.

## `regions` (type: `array`):

Only collect reviews from these regions. Leave empty for all regions.

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

Hard cap on the total number of records this run produces. Set 0 for no limit.

## `maxListingPages` (type: `integer`):

How many pages to walk through a category listing. Each page returns roughly 20-30 products.

## `maxRetries` (type: `integer`):

How many times to retry a page that fails to load before skipping it.

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

Proxy used for the run. Residential US proxies are strongly recommended and are the default.

## Actor input object example

```json
{
  "scrapeType": "reviews",
  "targets": [
    "https://www.g2.com/products/slack/reviews"
  ],
  "maxProductsToFollow": 10,
  "maxReviewsPerProduct": 100,
  "sortBy": "most_recent",
  "stars": [],
  "companySegments": [],
  "reviewerRoles": [],
  "regions": [],
  "maxItems": 0,
  "maxListingPages": 1,
  "maxRetries": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

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

No description

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

No description

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

No description

## `stats` (type: `string`):

No description

## `listings` (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 = {
    "targets": [
        "https://www.g2.com/products/slack/reviews"
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/Jwxb2NnpjBqbwi3JH/builds/BsxIvhbI2POz5Q4Lg/openapi.json