# Gartner Reviews Scraper (`solidcode/gartner-reviews-scraper`) Actor

\[💰 $0.85 / 1K] Extract verified B2B software reviews from Gartner Peer Insights — ratings, headlines, summaries, reviewer roles, industries, company sizes (USD revenue bands), and deployment regions. Filter by rating, company size, industry, job function, region, language, and date.

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

## Pricing

from $0.85 / 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.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Gartner Reviews Scraper

Pull verified B2B software reviews from Gartner Peer Insights at scale — star ratings, full headlines and summaries, reviewer job titles, industries, company revenue bands, deployment regions, and review dates for every product on the platform. Built for competitive intelligence teams, SaaS marketers, and enterprise sales analysts who need IT-decision-maker review data without copy-pasting one Gartner page at a time.

### Why This Scraper?

- **Three input modes, no URL hand-crafting** — paste full Gartner review URLs, drop in product slugs like `salesforce-sales-cloud`, or supply a vendor slug like `microsoft` to auto-discover every product that vendor ships on Peer Insights.
- **Vendor sweep in a single run** — point the actor at one vendor slug and it enumerates every product page under that vendor (Microsoft alone fans out to 170+ products) and harvests reviews across all of them.
- **Five company-size bands keyed to revenue, not headcount** — Gartner uniquely segments reviewers by USD revenue (`Under 50M`, `50M – 1B`, `1B – 10B`, `10B+`, `Gov't / Public Sector / Education`), so you can isolate enterprise buyers from SMB voice in one filter.
- **21 industry codes and 28 reviewer-function codes resolved by name** — type `Banking`, `Healthcare`, or `Engineering` and the actor maps the free text to Gartner's internal industry/function codes for you.
- **Four deployment regions with native server-side filtering** — North America, EMEA, Asia/Pacific, and Latin America are pushed straight to Gartner's API so you only pay for rows that match.
- **Partner-incentive isolation** — flip `Include Partner / Incentivized Reviews` to off and the actor sends `reviewerType: end-user` to Gartner, returning only organic, unincentivized voice of the buyer.
- **Five sort orders shipped exactly as Gartner ranks them** — Most recent, Most helpful, Highest rated, Lowest rated, and Oldest first, so you can reproduce any Gartner view from the input panel.
- **ISO 8601 dates plus original review language** — every row carries `date` in `YYYY-MM-DD` form and a `reviewLanguage` field across 10 supported languages (English through Chinese Simplified), ready for BI and locale-aware analysis.
- **Pre-translated content fields surfaced when Gartner provides them** — `preTranslatedHeadline` and `preTranslatedSummary` come through alongside the originals so multilingual datasets stay aligned.

### Use Cases

**Competitive Intelligence**
- Track sentiment shifts on a competitor's flagship product across quarters
- Compare your win/loss themes against verified buyer reviews of the competing vendor
- Detect new feature complaints surfacing in 1-star and 2-star reviews
- Benchmark net rating across an entire competitor catalog by sweeping a vendor slug

**SaaS Marketing & Demand Generation**
- Mine reviewer job titles and industries for verbatim quotes to use in ad creative
- Identify which enterprise revenue bands rate your product highest and target them in ABM
- Map reviewer roles (IT, Finance, Marketing, Operations) to refine ICP segmentation
- Pull headline-and-summary pairs for case-study lead lists

**Product & Customer Research**
- Categorize critical reviews by reviewer industry to spot vertical-specific gaps
- Tag complaints by company size to separate SMB friction from enterprise blockers
- Track headline themes for new feature launches by filtering on `dateFrom`
- Surface deployment-region-specific issues (EMEA vs. APAC adoption signals)

**Sales & Account Intelligence**
- Pre-call research: pull every Gartner review from a target account's industry and size band
- Identify advocate vs. detractor accounts among enterprise reviewers
- Build verified-buyer testimonial libraries grouped by vertical
- Surface objection themes that match a prospect's profile before a discovery call

**Investment & Market Research**
- Score vendor traction by review velocity and average rating over time
- Compare review distributions across categories to size emerging software markets
- Build sentiment time series for due diligence on private SaaS acquisitions

### Getting Started

#### Simplest Run

One product slug, default of 100 reviews:

```json
{
    "productSlugs": ["salesforce-sales-cloud"]
}
````

#### Filter to Enterprise IT Reviewers

Pull only 5-star, North-America-deployed reviews from large enterprises in IT Services:

```json
{
    "productSlugs": ["hubspot-marketing-hub"],
    "minRating": "5",
    "companySize": ["1b_10b", "10b_plus"],
    "industries": ["IT Services"],
    "regions": ["north_america"],
    "includePartnerReviews": false,
    "sortBy": "highest-rated",
    "maxResults": 50
}
```

#### Sweep an Entire Vendor Catalog

Discover every product Microsoft ships on Peer Insights and pull the 25 most-helpful reviews from each:

```json
{
    "vendorSlugs": ["microsoft"],
    "sortBy": "most-helpful",
    "maxResults": 25
}
```

#### Paste Gartner URLs Directly

Supports canonical category-and-vendor URLs and short product URLs. Filters embedded in the URL win for that URL:

```json
{
    "startUrls": [
        "https://www.gartner.com/reviews/market/sales-force-automation-platforms/vendor/salesforce/product/sales-cloud",
        "https://www.gartner.com/reviews/vendor/microsoft"
    ],
    "dateFrom": "2026-01-01",
    "maxResults": 200
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | Paste Gartner Peer Insights URLs — canonical review listing pages (with or without filters), short product URLs, or vendor URLs. Filters embedded in the URL take precedence for that URL. |
| `productSlugs` | string\[] | `[]` | Gartner product slugs like `salesforce-sales-cloud`. The actor builds the URL for you. |
| `vendorSlugs` | string\[] | `[]` | Gartner vendor slugs like `microsoft`. The actor enumerates every product page under the vendor and collects reviews across all of them. |
| `maxResults` | integer | `100` | Maximum reviews per input item (URL, product, or vendor). Set to `0` to fetch every available review. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `minRating` | select | `No filter` | Only include reviews with this overall rating or higher. Options: `No filter`, `1 star and above`, `2 stars and above`, `3 stars and above`, `4 stars and above`, `5 stars only`. |
| `companySize` | select\[] | `[]` | Reviewer's company revenue band: `Under 50M USD`, `50M – 1B USD`, `1B – 10B USD`, `10B+ USD`, `Gov't / Public Sector / Education`. Multi-select; empty = all. |
| `industries` | string\[] | `[]` | Free-text industry names (`Banking`, `Healthcare`, `Manufacturing`, `Retail`, `IT Services`). Matched case-insensitively against Gartner's 21 industry codes. |
| `roles` | string\[] | `[]` | Reviewer job functions (`IT`, `Finance`, `Marketing`, `Engineering`, `Operations`, `Sales`). Matched case-insensitively against Gartner's 28 function codes. |
| `regions` | select\[] | `[]` | Deployment regions: `North America`, `Europe, Middle East and Africa`, `Asia / Pacific`, `Latin America`. |
| `includePartnerReviews` | boolean | `true` | Include vendor-incentivized partner reviews. Turn off for organic, unincentivized reviews only. |
| `dateFrom` | date | `null` | Earliest review date to include (`YYYY-MM-DD`). |
| `dateTo` | date | `null` | Latest review date to include (`YYYY-MM-DD`). |

#### Advanced

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sortBy` | select | `Most recent` | How Gartner orders reviews before collection: `Most recent`, `Most helpful`, `Highest rated`, `Lowest rated`, `Oldest first`. |
| `language` | select | `Any language` | Keep only reviews originally written in this language. Options: `Any language`, `English`, `German`, `French`, `Spanish`, `Italian`, `Portuguese`, `Dutch`, `Japanese`, `Korean`, `Chinese (Simplified)`. |

### Output

One review per row. Empty values are dropped so every row stays clean.

```json
{
    "id": "6639926",
    "productName": "Salesforce Sales Cloud",
    "productSlug": "salesforce-sales-cloud",
    "rating": 4,
    "headline": "powerful and scalable CRM with strong analytics, but requires investment and expertise",
    "summary": "gives you a powerful and highly customizable CRM Platform that supports complex sales processes and large scale operations",
    "date": "2026-05-04",
    "jobTitle": "Data Analyst And Process Improvement",
    "industryName": "Retail",
    "companySize": "<50M USD",
    "reviewerType": "end-user",
    "regions": ["North America"],
    "incentiveCode": 1,
    "sourceCode": 2,
    "reviewLanguage": "en",
    "hasPreTranslatedContent": false,
    "url": "https://www.gartner.com/reviews/review/6639926"
}
```

#### Output Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Gartner review ID (primary key). |
| `productName` | string | Product reviewed, as displayed on Gartner. |
| `productSlug` | string | Gartner SEO slug for the product (e.g., `salesforce-sales-cloud`). |
| `marketSlug` | string | Gartner market slug when known (e.g., `sales-force-automation-platforms`). |
| `rating` | number | Overall rating, 1–5. |
| `headline` | string | Reviewer-supplied headline. |
| `summary` | string | Reviewer-supplied summary / overall comment. |
| `date` | string | Submission date in ISO 8601 `YYYY-MM-DD` form. |
| `jobTitle` | string | Reviewer's job title. |
| `industryName` | string | Reviewer's industry (e.g., `IT Services`, `Banking`). |
| `companySize` | string | Reviewer's company revenue band (e.g., `1B-10B USD`). |
| `reviewerType` | string | `end-user`, `partner`, or `both` — echoed from your `includePartnerReviews` filter so every row carries the cohort label. |
| `regions` | string\[] | Deployment regions you filtered to (or `["all"]` when no region filter is set), attached to every row for downstream grouping. |
| `incentiveCode` | integer | Gartner internal incentive code, raw. |
| `sourceCode` | integer | Gartner internal source code, raw. |
| `reviewLanguage` | string | Original language code (`en`, `de`, `fr`, `es`, `it`, `pt`, `nl`, `ja`, `ko`, `zh-CN`). |
| `hasPreTranslatedContent` | boolean | `true` when Gartner ships a Gartner-translated version alongside the original. |
| `preTranslatedHeadline` | string | Gartner's translated headline (present only when `hasPreTranslatedContent: true`). |
| `preTranslatedSummary` | string | Gartner's translated summary (present only when `hasPreTranslatedContent: true`). |
| `url` | string | Permalink to the review on Gartner Peer Insights. |

### Tips for Best Results

- **Use `vendorSlugs` for category sweeps.** One vendor slug fans out to every product the vendor sells on Peer Insights — that's the fastest way to build a competitor catalog without listing 170+ product slugs by hand.
- **Set `maxResults` per input, not globally.** The cap applies to each URL, product slug, or vendor slug individually, so a vendor sweep with `maxResults: 50` returns 50 reviews per product the vendor ships, not 50 total.
- **Filter at Gartner, not after.** `minRating`, `companySize`, `industries`, `roles`, `regions`, and `includePartnerReviews` are all sent server-side — you only pay for rows that match. Post-filtering in your warehouse wastes results.
- **Sort by `Most helpful` for ICP research.** Gartner's helpful-vote signal surfaces the reviews other IT decision-makers found most credible, which is closer to social proof than chronological order.
- **Pair `dateFrom` with `sortBy: most-recent` to track new launches.** Gartner only treats date-from cleanly as "last twelve months" — setting `dateFrom` to a date within the past year unlocks Gartner's native fast filter and significantly cuts run time.
- **Industries are matched case-insensitively by substring.** Typing `Health` will hit `Healthcare`; typing `IT` will hit `IT Services`. Use plain English instead of Gartner's numeric codes.
- **Use `language: en` to drop translated reviews from non-English markets.** Gartner returns the original language code on every row, so language-filtering early keeps your sentiment models from drifting on machine-translated text.

### Pricing

**$0.85 per 1,000 results** — undercuts the leading Gartner actor on the Apify store and bills one review = one result, no compute charges.

| Results | Estimated Cost |
|---------|----------------|
| 100 | $0.085 |
| 1,000 | $0.85 |
| 10,000 | $8.50 |
| 100,000 | $85.00 |

No compute charges — you only pay per result returned. A "result" is any review row in the output dataset. Platform fees (storage, transfer) depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate market research, competitive intelligence, and product analysis. Users are responsible for complying with applicable laws and Gartner Peer Insights' terms of service. Do not use extracted review content for spam, harassment, attribution-stripped republication, or any illegal purpose. Reviews are personal opinions of identified IT professionals — treat them accordingly when quoting in derivative work.

# Actor input Schema

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

Paste one or more Gartner Peer Insights URLs — canonical review listing pages (with or without filters in the URL), short product URLs, or vendor URLs. Examples: `https://www.gartner.com/reviews/market/crm-customer-engagement-center/vendor/salesforce/product/sales-cloud` or `https://www.gartner.com/reviews/vendor/microsoft`. Filters embedded in the URL take precedence over the Filters section below for that URL.

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

Alternative to URLs: paste Gartner product slugs (e.g., `salesforce-sales-cloud`, `hubspot-marketing-hub`). The actor builds the URL for you. Find the slug at the end of the product page URL on Gartner.

## `vendorSlugs` (type: `array`):

Paste Gartner vendor slugs (e.g., `salesforce`, `microsoft`) to collect reviews across every product the vendor sells on Peer Insights.

## `maxResults` (type: `integer`):

Maximum number of reviews to fetch per URL, product, or vendor. Set to 0 to fetch every available review.

## `minRating` (type: `string`):

Only include reviews with this overall rating or higher. Leave empty for no rating filter.

## `companySize` (type: `array`):

Only include reviews from companies in these revenue bands. Leave empty for all sizes. (Gartner uses USD revenue bands, not employee count.)

## `industries` (type: `array`):

Free-text industry names matched case-insensitively against Gartner's 21 industries. Supported: Banking, Construction, Consumer Goods, Education, Energy and Utilities, Finance (non-banking), Government, Hardware, Healthcare and Biotech, Insurance (except health), IT Services, Manufacturing, Media, Miscellaneous, Real Estate, Retail, Services (non-government), Software, Telecommunications, Transportation, Travel and Hospitality. Unknown names will surface a specific error listing every valid option.

## `roles` (type: `array`):

Reviewer job functions matched case-insensitively against Gartner's 28 functions. Common picks: IT, Sales, Marketing, Finance, Operations, Engineering, Customer Service and Support, Data and Analytics, Human Resources, Product Management. Leave empty for all roles. Unknown names will surface a specific error listing every valid option.

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

Only include reviews from deployments in these regions.

## `includePartnerReviews` (type: `boolean`):

Gartner marks some reviews as coming from vendor-incentivized partner programs. Disable to return only organic, unincentivized reviews.

## `dateFrom` (type: `string`):

Only include reviews submitted on or after this date (YYYY-MM-DD). When this date falls within the last 12 months, the actor automatically uses Gartner's `inLastTwelveMonths` fast filter — this can significantly speed up runs but cannot reach reviews older than 12 months.

## `dateTo` (type: `string`):

Only include reviews submitted on or before this date (YYYY-MM-DD).

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

How Gartner orders the reviews before we collect them.

## `language` (type: `string`):

Only keep reviews originally written in this language (e.g., `en`, `de`, `fr`, `es`). Leave as `Any language` to include all.

## Actor input object example

```json
{
  "startUrls": [
    "https://www.gartner.com/reviews/market/sales-force-automation-platforms/vendor/salesforce/product/sales-cloud"
  ],
  "productSlugs": [],
  "vendorSlugs": [],
  "maxResults": 100,
  "companySize": [],
  "industries": [],
  "roles": [],
  "regions": [],
  "includePartnerReviews": true,
  "sortBy": "most-recent",
  "language": "any"
}
```

# Actor output Schema

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

Table of reviews with rating, headline, reviewer profile, industry, company size, and region.

# 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 = {
    "startUrls": [
        "https://www.gartner.com/reviews/market/sales-force-automation-platforms/vendor/salesforce/product/sales-cloud"
    ],
    "productSlugs": [],
    "vendorSlugs": [],
    "maxResults": 100,
    "companySize": [],
    "industries": [],
    "roles": [],
    "regions": [],
    "includePartnerReviews": true,
    "sortBy": "most-recent",
    "language": "any"
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/gartner-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 = {
    "startUrls": ["https://www.gartner.com/reviews/market/sales-force-automation-platforms/vendor/salesforce/product/sales-cloud"],
    "productSlugs": [],
    "vendorSlugs": [],
    "maxResults": 100,
    "companySize": [],
    "industries": [],
    "roles": [],
    "regions": [],
    "includePartnerReviews": True,
    "sortBy": "most-recent",
    "language": "any",
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/gartner-reviews-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 '{
  "startUrls": [
    "https://www.gartner.com/reviews/market/sales-force-automation-platforms/vendor/salesforce/product/sales-cloud"
  ],
  "productSlugs": [],
  "vendorSlugs": [],
  "maxResults": 100,
  "companySize": [],
  "industries": [],
  "roles": [],
  "regions": [],
  "includePartnerReviews": true,
  "sortBy": "most-recent",
  "language": "any"
}' |
apify call solidcode/gartner-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gartner Reviews Scraper",
        "description": "[💰 $0.85 / 1K] Extract verified B2B software reviews from Gartner Peer Insights — ratings, headlines, summaries, reviewer roles, industries, company sizes (USD revenue bands), and deployment regions. Filter by rating, company size, industry, job function, region, language, and date.",
        "version": "0.1",
        "x-build-id": "dJlJqZ5la5nTX2aLd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~gartner-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-gartner-reviews-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/solidcode~gartner-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-gartner-reviews-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/solidcode~gartner-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-gartner-reviews-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": {
                    "startUrls": {
                        "title": "Gartner Review URLs",
                        "type": "array",
                        "description": "Paste one or more Gartner Peer Insights URLs — canonical review listing pages (with or without filters in the URL), short product URLs, or vendor URLs. Examples: `https://www.gartner.com/reviews/market/crm-customer-engagement-center/vendor/salesforce/product/sales-cloud` or `https://www.gartner.com/reviews/vendor/microsoft`. Filters embedded in the URL take precedence over the Filters section below for that URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "productSlugs": {
                        "title": "Product Slugs",
                        "type": "array",
                        "description": "Alternative to URLs: paste Gartner product slugs (e.g., `salesforce-sales-cloud`, `hubspot-marketing-hub`). The actor builds the URL for you. Find the slug at the end of the product page URL on Gartner.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "vendorSlugs": {
                        "title": "Vendor Slugs",
                        "type": "array",
                        "description": "Paste Gartner vendor slugs (e.g., `salesforce`, `microsoft`) to collect reviews across every product the vendor sells on Peer Insights.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResults": {
                        "title": "Maximum Reviews per Input",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of reviews to fetch per URL, product, or vendor. Set to 0 to fetch every available review.",
                        "default": 100
                    },
                    "minRating": {
                        "title": "Minimum Rating",
                        "enum": [
                            "",
                            "1",
                            "2",
                            "3",
                            "4",
                            "5"
                        ],
                        "type": "string",
                        "description": "Only include reviews with this overall rating or higher. Leave empty for no rating filter."
                    },
                    "companySize": {
                        "title": "Reviewer Company Size (USD revenue)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include reviews from companies in these revenue bands. Leave empty for all sizes. (Gartner uses USD revenue bands, not employee count.)",
                        "items": {
                            "type": "string",
                            "enum": [
                                "under_50m",
                                "50m_1b",
                                "1b_10b",
                                "10b_plus",
                                "gov_ps_ed"
                            ],
                            "enumTitles": [
                                "Under 50M USD",
                                "50M – 1B USD",
                                "1B – 10B USD",
                                "10B+ USD",
                                "Gov't / Public Sector / Education"
                            ]
                        },
                        "default": []
                    },
                    "industries": {
                        "title": "Reviewer Industries",
                        "type": "array",
                        "description": "Free-text industry names matched case-insensitively against Gartner's 21 industries. Supported: Banking, Construction, Consumer Goods, Education, Energy and Utilities, Finance (non-banking), Government, Hardware, Healthcare and Biotech, Insurance (except health), IT Services, Manufacturing, Media, Miscellaneous, Real Estate, Retail, Services (non-government), Software, Telecommunications, Transportation, Travel and Hospitality. Unknown names will surface a specific error listing every valid option.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "roles": {
                        "title": "Reviewer Job Functions",
                        "type": "array",
                        "description": "Reviewer job functions matched case-insensitively against Gartner's 28 functions. Common picks: IT, Sales, Marketing, Finance, Operations, Engineering, Customer Service and Support, Data and Analytics, Human Resources, Product Management. Leave empty for all roles. Unknown names will surface a specific error listing every valid option.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "regions": {
                        "title": "Deployment Regions",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Only include reviews from deployments in these regions.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "north_america",
                                "emea",
                                "apac",
                                "latam"
                            ],
                            "enumTitles": [
                                "North America",
                                "Europe, Middle East and Africa",
                                "Asia / Pacific",
                                "Latin America"
                            ]
                        },
                        "default": []
                    },
                    "includePartnerReviews": {
                        "title": "Include Partner / Incentivized Reviews",
                        "type": "boolean",
                        "description": "Gartner marks some reviews as coming from vendor-incentivized partner programs. Disable to return only organic, unincentivized reviews.",
                        "default": true
                    },
                    "dateFrom": {
                        "title": "Earliest Review Date",
                        "type": "string",
                        "description": "Only include reviews submitted on or after this date (YYYY-MM-DD). When this date falls within the last 12 months, the actor automatically uses Gartner's `inLastTwelveMonths` fast filter — this can significantly speed up runs but cannot reach reviews older than 12 months."
                    },
                    "dateTo": {
                        "title": "Latest Review Date",
                        "type": "string",
                        "description": "Only include reviews submitted on or before this date (YYYY-MM-DD)."
                    },
                    "sortBy": {
                        "title": "Sort Reviews By",
                        "enum": [
                            "most-recent",
                            "most-helpful",
                            "highest-rated",
                            "lowest-rated",
                            "least-recent"
                        ],
                        "type": "string",
                        "description": "How Gartner orders the reviews before we collect them.",
                        "default": "most-recent"
                    },
                    "language": {
                        "title": "Review Language",
                        "enum": [
                            "any",
                            "en",
                            "de",
                            "fr",
                            "es",
                            "it",
                            "pt",
                            "nl",
                            "ja",
                            "ko",
                            "zh-CN"
                        ],
                        "type": "string",
                        "description": "Only keep reviews originally written in this language (e.g., `en`, `de`, `fr`, `es`). Leave as `Any language` to include all.",
                        "default": "any"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
