# G2 Reviews Scraper - Software Reviews, Ratings & Profiles (`haketa/g2-reviews-scraper`) Actor

Scrape software product reviews from G2.com via public RSS feeds: star rating, pros/cons, use case, reviewer role, industry & company size. HTTP-only, no Cloudflare fight, no residential proxy. Up to 125 reviews per product.

- **URL**: https://apify.com/haketa/g2-reviews-scraper.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** Business, Marketing
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 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/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 Reviews Scraper — Software Reviews, Ratings & Reviewer Profiles

[![Apify Actor](https://img.shields.io/badge/Apify%20Actor-Ready-blue?logo=apify)](https://apify.com/haketa/g2-reviews-scraper)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://apify.com/haketa/g2-reviews-scraper)
[![Data Format](https://img.shields.io/badge/Data-JSON%20%7C%20CSV%20%7C%20Excel-orange)](https://apify.com/haketa/g2-reviews-scraper)
[![Authentication](https://img.shields.io/badge/Auth-No%20Login%20Required-blueviolet)](#)
[![Pagination](https://img.shields.io/badge/Scale-1%2C000%2B%20Reviews-success)](#)

**Extract B2B software reviews from [G2.com](https://www.g2.com) without fighting complex anti-bot walls.** This high-performance **G2 reviews scraper** extracts star ratings, full review titles, pros ("what do you like best?"), cons ("what do you dislike?"), use cases ("what problems does it solve?"), and verified reviewer profiles (role, industry, company size) across any software product on G2.

Whether auditing negative feedback for sales battlecards, tracking competitor sentiment shifts, or bulk-exporting 1,000+ reviews across an entire SaaS category, everything exports cleanly into **JSON, CSV, Excel, or programmatic API**.

***

### ⚡ At a glance

| Feature | Specification |
|---|---|
| **Target Website** | G2.com (`g2.com/products/{slug}/reviews`) |
| **Data Extraction Method** | High-speed HTTP syndication feeds (bypasses browser overhead) |
| **Capacity Per Product** | Up to ~125 unique reviews per product across 5 star ratings |
| **Bulk Capacity** | Fully unlocked for **1,000+ reviews** across multi-product portfolios |
| **Data Fields** | Product, rating, title, pros, cons, useCase, reviewerType, role, industry, companySize, date, URL |
| **Star Rating Filters** | Selectable 1 to 5 stars (`filters[nps_score][]={1-5}`) |
| **Deduplication** | Automatic `reviewId` collision detection with 0 duplicate records |
| **Throughput & Speed** | Pure HTTP (under 30s for ~125–250 reviews across products) |
| **Memory Footprint** | Lightweight (256 MB to 512 MB default) |
| **Proxy Requirement** | Standard Apify datacenter proxies (no costly residential required) |
| **Export Formats** | Dataset JSON, flat CSV, spreadsheet Excel, XML, HTML, Webhook |

***

### 🔎 Why scrape G2?

**G2.com** is the definitive global authority for B2B software ratings and enterprise technology evaluation. With over 2.5 million verified user reviews, G2 represents an irreplaceable source of voice-of-customer (VoC) feedback, competitive intelligence, and software market trends.

However, extracting review text from G2 poses significant challenges:

1. **Aggressive anti-bot defenses**: G2's HTML front-end relies on Cloudflare and DataDome challenges that block standard datacenter scrapers with HTTP 403 errors.
2. **Browser automation overhead**: Using headless browser clusters (Playwright, Puppeteer) to click through pagination is prohibitively slow, fragile, and memory-intensive.
3. **Fragmented review text**: G2 splits review responses across structured prompts ("What do you like best", "What do you dislike", "Recommendations for others", and "Problems solved").

This **G2 data extractor** circumvents these roadblocks entirely. By querying G2's public review syndication endpoints directly over high-speed HTTP, it captures clean, unblocked review data in seconds with zero browser overhead and zero proxy friction.

***

### ⚖️ Feature comparison: Why choose this Actor?

| Feature | Browser-Based G2 Scrapers | Manual Research | This Apify Actor |
|---|---|---|---|
| **Anti-Bot Resistance** | Frequently 403-blocked | High labor cost | **100% Unblocked HTTP Access** |
| **Run Speed** | 3–5 minutes per product | Hours per batch | **10–25 seconds per product** |
| **Star-Level Targeting** | Manual page navigation | Error-prone | **Direct 1–5 Star Rating Filter** |
| **Reviewer Metadata** | Parsing HTML DOM | Copy-pasting text | **Structured role, industry, size** |
| **Negative Review Mining** | Must scroll all pages | Manual sorting | **Instant 1-Star & 2-Star isolation** |
| **Bulk Scaling** | High memory cost | Unscalable | **1,000+ reviews across SaaS lists** |
| **Reliability** | Breaks on CSS redesigns | Fatigue-prone | **Standardized feed schema** |

***

### ✨ Core capabilities

- ⭐ **Multi-star coverage**: Queries all 5 individual star levels (1 to 5) to collect up to ~125 fresh, unique reviews per target product.
- 💬 **Complete Q\&A breakdown**: Separates each review into distinct, actionable fields: **pros** (strengths), **cons** (weaknesses), and **useCase** (business impact).
- 👤 **Verified reviewer profiles**: Extracts reviewer verification status, job title/role, target industry, and company headcount size.
- 🎯 **Negative review isolation**: Narrow `starFilters` to `["1", "2"]` to extract churn risks, technical grievances, and competitor vulnerabilities instantly.
- 📦 **Bulk category scaling**: When requesting `maxItems: 1000+`, the actor automatically expands review collection across leading category leaders.
- 🧹 **Automatic deduplication**: Merges review records across feeds using unique `reviewId` identifiers to guarantee 0 duplicated items.
- ⚡ **Lightweight & fast**: Consumes only 256–512 MB of RAM, executing in seconds without expensive residential proxy bandwidth.

***

### 🎯 Use cases & industry applications

#### 1. Competitive intelligence & battlecards

- **Identify competitor flaws**: Mine 1-star and 2-star reviews of rivals to discover recurring bugs, pricing complaints, or customer support breakdowns.
- **Arm sales teams**: Build competitive battlecards with direct verbatim quotes explaining why customers switched away from legacy solutions.

#### 2. Product management & roadmap prioritization

- **Voice-of-customer (VoC) analysis**: Feed hundreds of pros and cons into an LLM or clustering model to detect emergent feature requests and UI friction points.
- **Benchmark satisfaction**: Compare average star ratings and sentiment across direct market competitors.

#### 3. Sales enablement & marketing copy

- **Social proof mining**: Pull 5-star positive reviews to uncover the exact terminology and value propositions real buyers use.
- **Customer testimonial research**: Find enthusiastic users within specific industries (e.g., Healthcare, FinTech) or company sizes (Enterprise vs. SMB).

#### 4. SaaS investment & market diligence

- **Alternative data for VCs & hedge funds**: Assess product adoption velocity, brand loyalty, and sentiment health before investment rounds.
- **Category market mapping**: Benchmark market leaders across CRM, ERP, project management, and developer tooling.

***

### 📋 Popular software product slugs on G2

You can use either full G2 URLs or short product slugs. Below is a reference list of popular software slugs ready for scraping:

| Category | Popular Slugs |
|---|---|
| **Collaboration & Chat** | `slack`, `zoom`, `microsoft-teams`, `loom`, `miro` |
| **Project & Task Management** | `asana`, `trello`, `monday-com`, `clickup`, `jira`, `basecamp` |
| **CRM & Sales** | `salesforce-sales-cloud`, `hubspot-sales-hub`, `pipedrive`, `zoho-crm` |
| **Customer Support** | `zendesk-support-suite`, `freshdesk`, `intercom` |
| **Productivity & Docs** | `notion`, `airtable`, `coda-io`, `confluence` |
| **Developer Tools** | `github`, `gitlab`, `postman`, `datadog` |
| **Marketing & SEO** | `hubspot-marketing-hub`, `semrush`, `ahrefs`, `mailchimp` |
| **Design & Media** | `figma`, `canva`, `adobe-creative-cloud` |

***

### 📥 Input parameters

The actor is designed to run instantly with zero configuration (defaulting to popular tools like `slack`), while providing fine-grained filters for specialized review mining.

| Parameter | Type | Default | Description |
|---|---|---|---|
| `productUrls` | `array` | `["slack"]` | List of G2 product slugs (e.g. `slack`, `asana`, `zoom`) or full URLs (e.g. `https://www.g2.com/products/zoom/reviews`), one per line. |
| `starFilters` | `array` | `["1","2","3","4","5"]` | Star ratings to collect. Narrow to `["1","2"]` for negative feedback, or `["4","5"]` for testimonials. |
| `maxReviewsPerProduct` | `integer` | `0` | Maximum reviews to collect per product (`0` = all available, up to ~125). |
| `maxItems` | `integer` | `0` | Total maximum reviews across all products. Set to `1000` to trigger broad multi-product category coverage. |
| `maxConcurrency` | `integer` | `5` | Number of simultaneous products to scrape in parallel (1 to 12). |
| `proxyConfiguration` | `object` | `Apify Proxy` | Apify datacenter proxy. Enabled by default to distribute requests across multiple IPs. |

#### Sample JSON configuration

```json
{
  "productUrls": [
    "slack",
    "https://www.g2.com/products/zoom/reviews",
    "asana",
    "monday-com",
    "clickup"
  ],
  "starFilters": ["1", "2", "3", "4", "5"],
  "maxReviewsPerProduct": 0,
  "maxItems": 500,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

***

### 📊 Output data fields

Every record pushed to the Apify dataset represents a verified software review. All textual values are sanitized, decoded, and normalized.

| Field | Coverage | Type | Description |
|---|---|---|---|
| `product` | 🟢 High (100%) | String | G2 software product slug (e.g., `"slack"`, `"zoom"`). |
| `reviewId` | 🟢 High (100%) | String | Unique numeric identifier for the review. |
| `title` | 🟢 High (100%) | String | Headline title of the review written by the user. |
| `rating` | 🟢 High (100%) | Number | Star rating awarded by the reviewer (1.0 to 5.0). |
| `pros` | 🟢 High (98%) | String | Full text response to "What do you like best?". |
| `cons` | 🟢 High (96%) | String | Full text response to "What do you dislike?". |
| `useCase` | 🟢 High (92%) | String | Business problem solved and operational benefits gained. |
| `reviewerType` | 🟢 High (100%) | String | `"Verified User"` or the verified full name of the author. |
| `role` | 🟡 Conditional (70%) | String | Reviewer's professional title (e.g., `"Software Engineer"`). |
| `industry` | 🟡 Conditional (45%) | String | Reviewer's company industry (e.g., `"Information Technology"`). |
| `companySize` | 🟡 Conditional (65%) | String | Employee headcount bracket (e.g., `"Mid-Market(51-1000 emp.)"`). |
| `date` | 🟢 High (100%) | String | ISO 8601 timestamp when the review was published. |
| `url` | 🟢 High (100%) | String | Direct canonical URL to the review on G2.com. |
| `scrapedAt` | 🟢 High (100%) | String | ISO 8601 UTC timestamp of data collection. |

***

### 📋 Example JSON outputs

#### 1. Positive review (5 stars)

```json
{
  "product": "slack",
  "reviewId": "9482103",
  "title": "Essential communication hub for fast-paced distributed teams",
  "rating": 5,
  "pros": "The huddle feature has essentially replaced unscheduled Zoom meetings for our engineering team. Channels keep project discussions organized, and integrations with Jira and GitHub allow us to receive deployment notifications seamlessly.",
  "cons": "Search functionality can occasionally feel sluggish when querying across channels from several years ago. Notification settings require fine-tuning to prevent notification fatigue.",
  "useCase": "We use Slack as our company-wide operating system across 3 global offices. It has reduced internal email volume by over 80% and improved response times on production incidents.",
  "reviewerType": "Verified User",
  "role": "VP of Engineering",
  "industry": "Computer Software",
  "companySize": "Mid-Market (51-1000 emp.)",
  "date": "2026-10-18T14:32:00.000Z",
  "url": "https://www.g2.com/products/slack/reviews#review-9482103",
  "scrapedAt": "2026-11-10T14:22:15.823Z"
}
```

#### 2. Critical review (1 star / competitor vulnerability)

```json
{
  "product": "salesforce-sales-cloud",
  "reviewId": "9120481",
  "title": "Overly complex setup that requires a full-time dedicated administrator",
  "rating": 1,
  "pros": "Extremely customizable and has every conceivable enterprise feature if you have a developer team to build it.",
  "cons": "The user interface is dated and cluttered with redundant fields. Reporting is counter-intuitive, and basic changes require consulting hours. Annual pricing escalation is aggressive.",
  "useCase": "We attempted to deploy Salesforce across our 40-person sales team, but adoption was abysmal due to system friction. We ended up migrating to a lightweight modern CRM.",
  "reviewerType": "Verified User",
  "role": "Director of Revenue Operations",
  "industry": "FinTech",
  "companySize": "Small-Business (50 or fewer emp.)",
  "date": "2026-09-04T10:15:00.000Z",
  "url": "https://www.g2.com/products/salesforce-sales-cloud/reviews#review-9120481",
  "scrapedAt": "2026-11-10T14:22:18.104Z"
}
```

***

### 💻 Programmatic usage examples

Call this Actor from your backend or data workflows using Apify's official client libraries.

#### Python integration

```python
from apify_client import ApifyClient

## Initialize the ApifyClient with your API token
client = ApifyClient("YOUR_APIFY_TOKEN")

## Prepare actor input (target negative reviews for churn analysis)
run_input = {
    "productUrls": ["slack", "microsoft-teams", "zoom"],
    "starFilters": ["1", "2"],
    "maxReviewsPerProduct": 50,
    "maxItems": 150
}

## Run the actor
run = client.actor("haketa/g2-reviews-scraper").call(run_input=run_input)

## Stream results into your sentiment analysis pipeline
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(f"[{item['product']}] {item['rating']} Stars: {item['title']}")
    print(f"Cons: {item['cons']}\n")
```

#### Node.js integration

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

const client = new ApifyClient({
    token: 'YOUR_APIFY_TOKEN',
});

const input = {
    productUrls: ['hubspot-marketing-hub', 'salesforce-sales-cloud'],
    starFilters: ['4', '5'],
    maxReviewsPerProduct: 50,
};

const run = await client.actor('haketa/g2-reviews-scraper').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

console.log(`Successfully scraped ${items.length} reviews from G2!`);
items.slice(0, 5).forEach(item => {
    console.log(`- ${item.product} (${item.rating}★): ${item.title}`);
});
```

***

### 🤖 Feeding G2 review data into AI & LLM workflows

G2 reviews are structured mini-case studies containing authentic customer language. This makes them ideal inputs for Generative AI and LLM workflows:

#### Automated competitor SWOT analysis prompt

```markdown
You are a senior product strategy director. Analyze the following 50 negative reviews (1-2 stars) and 50 positive reviews (5 stars) for our direct competitor:

Reviews Dataset:
{{g2_reviews_json}}

Deliver:
1. Top 3 recurring technical weaknesses customers complain about.
2. The primary churn catalysts leading customers to look for alternatives.
3. Feature gaps where we can position our solution as superior.
4. Two verbatim customer quotes to include in our competitive sales battlecards.
```

#### Voice of Customer (VoC) sentiment clustering

By passing the `pros`, `cons`, and `useCase` columns into an embedding pipeline (e.g. OpenAI `text-embedding-3-small`), you can cluster hundreds of reviews into quantitative thematic buckets:

- **Usability & UX friction**
- **Pricing & contract renewal frustration**
- **Customer support responsiveness**
- **Integration & API reliability**

***

### 🚀 How to use this actor

1. **Identify product slugs**: Find your target software product on G2. The slug is the segment immediately following `/products/` (e.g., `g2.com/products/hubspot/reviews` → `hubspot`).
2. **Paste products**: Enter one or more slugs or full URLs into the **G2 products** field.
3. **Filter star ratings**: Choose whether you need comprehensive 360-degree reviews (1–5 stars) or want to isolate negative feedback (1–2 stars).
4. **Set review ceilings**: Leave `maxReviewsPerProduct` and `maxItems` at `0` for complete coverage, or set specific numerical caps.
5. **Start extraction**: Click **Start**. The actor logs live progress showing products processed, valid reviews extracted, and running item counts.
6. **Download dataset**: Export your findings as CSV, Excel, or JSON, or query the Apify dataset directly via API.

***

### 💡 Best practices & optimization tips

- **Extracting 1,000+ reviews**: Because G2 caps its syndication feed at 25 reviews per star rating (~125 reviews per product), pass a list of 8–10 related products or set `maxItems: 1000` to automatically expand collection across industry category leaders.
- **Isolate negative reviews for sales**: To prepare competitive sales battlecards, set `starFilters: ["1", "2"]`. This strips out positive fluff and isolates real operational pain points.
- **Handling missing company size**: Note that `industry` and `companySize` are voluntarily provided by reviewers. In our validation runs, core review fields (rating, pros, cons, date) achieve ~100% coverage, while optional demographic metadata achieves 40–70% coverage.
- **Automate weekly monitoring**: Schedule this actor to run every Monday morning to capture newly posted reviews for your product and immediate rivals.

***

### ❓ Frequently Asked Questions (FAQ)

##### Do I need a G2 account or login credentials?

No. The scraper queries publicly syndicated feeds that require no login, username, or subscription.

##### Does this Actor require expensive residential proxies?

No. Because G2 serves its syndication feeds without Cloudflare or DataDome bot challenges, standard Apify datacenter proxies are more than sufficient.

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

G2's syndication endpoint returns 25 reviews per star rating tier, yielding up to ~125 unique reviews per product. To collect 1,000+ reviews, provide a list of multiple competitor products or leverage the Actor's automatic product expansion.

##### What happens if a product has changed its slug or redirects?

The scraper handles URL redirections gracefully. If a slug has changed (such as `zoom` transitioning to `zoom-workplace`), it resolves the canonical endpoint and continues scraping.

##### How can I export reviews directly to Google Sheets?

You can use Apify's native Google Sheets integration, connect via Zapier/Make webhooks, or import the dataset's direct CSV export link using Google Sheets `=IMPORTDATA()` function.

##### Can I filter by reviewer role or company size?

The feed returns the reviewer's role, industry, and company size as output columns. You can filter these downstream in pandas, Excel, or SQL to segment enterprise reviews from small-business reviews.

***

### 🔗 Related review & market intelligence scrapers

- [Trustpilot Reviews Scraper](https://apify.com/haketa/trustpilot-reviews-scraper) — Extract consumer product and service reviews.
- [RepVue Sales Compensation Scraper](https://apify.com/haketa/repvue-scraper) — Sales compensation, quotas, and culture metrics.
- [Google Trends Scraper](https://apify.com/haketa/google-trends-scraper) — Historical search interest and breakout query monitoring.
- [Wikidata Entity Resolver](https://apify.com/haketa/wikidata-resolver) — Ground company and brand entities for automated research.

***

### 📋 Changelog

#### Version 1.2 (2026-11)

- **Unlocked 1,000+ deep review collection**: Implemented automatic product list expansion across top software leaders when `maxItems > 125` is requested.
- **Accelerated prefill performance**: Optimized HTTP connection pooling to finish single-product prefill audits in under 15 seconds.
- **Refined Q\&A parsing engine**: Enhanced regular expression matching for nuanced G2 question formats ("What problems is it solving?").
- **Strict schema validation**: Updated schema specifications to 100% Apify CLI 2026 standards with full dataset view support.

#### Version 1.1 (2026-10)

- Added star rating filter support (`filters[nps_score][]={1-5}`).
- Implemented robust HTML entity decoding across pros, cons, and use case fields.
- Added reviewer role, industry, and company size extraction.

#### Version 1.0 (2026-10)

- Initial release featuring high-speed HTTP review syndication parsing.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/g2-reviews-scraper/changelog.md

# Actor input Schema

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

Software products to scrape reviews for. Paste the G2 product slug (e.g. `slack`) or any G2 product URL (e.g. `https://www.g2.com/products/zoom/reviews`) — one per line. The slug is the part after /products/.

## `starFilters` (type: `array`):

Which star ratings to pull (G2 serves one RSS feed per star level, 25 reviews each → up to 125 unique reviews per product). Keep all 5 for maximum coverage, or narrow to e.g. only 1-2 stars for negative reviews.

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

Cap the number of reviews collected per product. 0 = all available from the feeds (up to ~125).

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

Maximum number of reviews to save across all products. 0 = no limit.

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

How many products to process in parallel.

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

Optional. The G2 RSS feed is NOT behind Cloudflare, so no residential proxy is needed — Apify datacenter proxy (default) just spreads requests across IPs to avoid rate-limiting on large runs.

## Actor input object example

```json
{
  "productUrls": [
    "slack",
    "https://www.g2.com/products/zoom/reviews",
    "salesforce-sales-cloud"
  ],
  "starFilters": [
    "1",
    "2",
    "3",
    "4",
    "5"
  ],
  "maxReviewsPerProduct": 0,
  "maxItems": 0,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Software product reviews scraped from G2.com — rating, pros/cons, use case and reviewer profile.

# 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": [
        "slack"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/g2-reviews-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "productUrls": ["slack"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/g2-reviews-scraper").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 '{
  "productUrls": [
    "slack"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call haketa/g2-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

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/OQaI7PkV1mhFBMG6l/builds/9lQA9OgPb7fBXPK77/openapi.json