# G2 Reviews Scraper: Reliable, Pay Only for Results (`automation_craft/g2-reviews-scraper`) Actor

Collect G2 software reviews without the failed runs other scrapers hit - star ratings, pros & cons, problems solved, reviewer details, as clean JSON/CSV/Excel. Pay only for reviews you get; empty runs are free. Optional AI summaries with your own ChatGPT or Claude key. From $1/1,000.

- **URL**: https://apify.com/automation\_craft/g2-reviews-scraper.md
- **Developed by:** [Automation Craft](https://apify.com/automation_craft) (community)
- **Categories:** Business, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## G2 Reviews Scraper — Reliable, Pay Only for Results

Collect real customer reviews from **G2.com** — the biggest software review site — and get them back as clean, ready-to-use data. Star ratings, what reviewers like and dislike, the problems each product solves, who wrote the review, and more.

Most G2 scrapers fail often and charge you even when they return nothing. This one is built to **work every time** and to **only bill you for reviews you actually receive**.

### Why people choose this scraper

- ✅ **It doesn't fail.** Other G2 scrapers constantly get blocked by G2's anti-bot systems (that's why so many of them have 1–2 star ratings). This one collects reviews a different, reliable way, so your runs finish successfully.
- ✅ **You only pay for results.** If a product has no reviews, you get a short note explaining why — and you're **not charged** for it. You pay per review, nothing more.
- ✅ **Recent and older reviews.** Get the latest reviews plus older ones from a review archive, automatically combined and de-duplicated.
- ✅ **Rich, clean fields.** Separate "likes", "dislikes", and "problems solved", star rating, reviewer's role and company size, review date, a direct link to each review, and a ready-to-read text version for AI tools.
- ✅ **Optional AI summaries — with your own key.** Turn reviews into insights using your own ChatGPT or Claude account. Pick any provider and model you like. You're billed for AI usage by your provider, never by this scraper.

### What you get (per review)

| Field | What it is |
|---|---|
| Product name & rating | The software and its star rating (1–5) |
| Review title | The headline the reviewer wrote |
| Likes / Dislikes / Problems solved | The three questions G2 asks every reviewer, kept separate |
| Reviewer role & company size | E.g. "Project Manager", "Enterprise" |
| Date & review link | When it was posted and a direct link to it |
| Ready-to-read text | A tidy version of the review, perfect for feeding into AI tools |

Turn on **Product summary** and you also get one report per product: the **top complaints**, the **most-requested features**, **quick wins**, and the **competitors reviewers mention** — ideal for competitive research and win/loss analysis.

### How to use it

1. **Enter your products.** Paste G2 links, or just short product names like `slack` or `hubspot-marketing-hub`. Add as many as you want.
2. **Choose how many reviews and any filters** (for example, only 1-star reviews, or only reviews rated 4+).
3. **Run it.** Download your results as JSON, CSV, or Excel, or connect them to your other tools.

#### Example

```json
{
  "productUrls": ["slack", "https://www.g2.com/products/notion/reviews"],
  "source": "auto",
  "maxReviewsPerProduct": 100,
  "minRating": 1,
  "maxRating": 5
}
````

Want AI summaries too? Add your key:

```json
{
  "productUrls": ["notion"],
  "aiTasks": ["productSummary"],
  "aiProvider": "anthropic",
  "aiModel": "claude-haiku-4-5-20251001",
  "aiApiKey": "your-key-here"
}
```

### Pricing

- **$0.001 per review** — that's **$1 per 1,000 reviews**, and only for reviews you actually receive.
- **$0.01 per AI product summary** — this covers running the analysis; the AI usage itself is billed to your own key.
- **Empty or failed products: $0.** You're never charged for a product that returns nothing.

### What to expect (honest note)

This scraper is built for **reliability first**. It reliably returns up to about **125 recent reviews per product**, plus older reviews from the archive. It does **not** promise "every review ever written" and then fail — some tools make that claim but break on G2's defenses. This one returns solid, real data on every run, and only charges you for what it delivers.

### Great for

Competitive research · win/loss and "why customers switch" analysis · tracking what people say about your product and your rivals · market and product research · turning customer feedback into AI-ready datasets.

# Actor input Schema

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

The products you want reviews for. Paste a G2 link (like https://www.g2.com/products/slack/reviews), or just the product's short name from its G2 web address (like 'slack' or 'hubspot-marketing-hub'). Add as many as you want. If you're not sure of the exact name, we'll find the closest matching product for you.

## `source` (type: `string`):

'Latest reviews' (default) is the fastest and most reliable — it gets recent reviews straight from G2. 'Latest + archive' also pulls older reviews and extra details from a review archive (more reviews, a little slower). 'Archive only' focuses on older reviews.

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

The most reviews to collect for each product. You typically get up to ~125 recent reviews per product, plus older ones from the archive.

## `minRating` (type: `integer`):

Only keep reviews rated at least this many stars (1 to 5).

## `maxRating` (type: `integer`):

Only keep reviews rated at most this many stars (1 to 5). Tip: set both the lowest and highest to the same number to get just that rating — for example, set both to 1 to read only the 1-star complaints.

## `includeHistorical` (type: `boolean`):

When using 'Latest + archive', this also pulls older reviews and extra details from the archive. Turn it off for the fastest possible run.

## `historicalFromYear` (type: `integer`):

Optional. Only include archived reviews from this year onward (for example, 2024).

## `aiTasks` (type: `array`):

Add AI analysis using your own ChatGPT or Claude key. 'Review sentiment' tags each review as positive, negative, neutral, or mixed and pulls out key themes. 'Product summary' gives you one report per product with the top complaints, most-requested features, quick wins, and competitors that reviewers mention.

## `aiProvider` (type: `string`):

Which AI service your key is for — OpenAI (ChatGPT) or Anthropic (Claude). Only needed if you turned on AI analysis above.

## `aiModel` (type: `string`):

Which AI model to use. Leave blank for a fast, low-cost default. You can enter any model your key supports — for example gpt-4o-mini, claude-haiku-4-5, claude-sonnet-5, or claude-fable-5.

## `aiApiKey` (type: `string`):

Your own OpenAI (ChatGPT) or Anthropic (Claude) API key. It's used only for the AI analysis you selected. Your AI provider bills you directly for that usage — this scraper does not charge you for AI tokens. Your key is stored securely and never shared.

## `maxAiReviews` (type: `integer`):

Caps how many reviews per product get individual sentiment tagging, so your AI costs stay predictable. The product summary always reads up to 60 reviews in a single pass.

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

Advanced. The defaults work well — most people can leave this as-is.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.g2.com/products/slack/reviews",
    "notion",
    "hubspot-marketing-hub"
  ],
  "source": "rss",
  "maxReviewsPerProduct": 100,
  "minRating": 1,
  "maxRating": 5,
  "includeHistorical": true,
  "aiTasks": [],
  "aiProvider": "openai",
  "aiModel": "claude-haiku-4-5-20251001",
  "maxAiReviews": 40,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "BUYPROXIES94952"
    ]
  }
}
```

# Actor output Schema

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

All scraped G2 reviews as dataset items (JSON).

## `reviewsTable` (type: `string`):

The reviews in a readable table, showing product, rating, likes/dislikes, reviewer and date.

## `dataset` (type: `string`):

The run's dataset (download as JSON, CSV, or Excel).

# 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"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation_craft/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"] }

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "G2 Reviews Scraper: Reliable, Pay Only for Results",
        "description": "Collect G2 software reviews without the failed runs other scrapers hit - star ratings, pros & cons, problems solved, reviewer details, as clean JSON/CSV/Excel. Pay only for reviews you get; empty runs are free. Optional AI summaries with your own ChatGPT or Claude key. From $1/1,000.",
        "version": "0.1",
        "x-build-id": "EypohbZl4lX4mcUoA"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation_craft~g2-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation_craft-g2-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/automation_craft~g2-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation_craft-g2-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/automation_craft~g2-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation_craft-g2-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",
                "required": [
                    "productUrls"
                ],
                "properties": {
                    "productUrls": {
                        "title": "G2 products",
                        "type": "array",
                        "description": "The products you want reviews for. Paste a G2 link (like https://www.g2.com/products/slack/reviews), or just the product's short name from its G2 web address (like 'slack' or 'hubspot-marketing-hub'). Add as many as you want. If you're not sure of the exact name, we'll find the closest matching product for you.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "source": {
                        "title": "Which reviews to collect",
                        "enum": [
                            "rss",
                            "auto",
                            "historical"
                        ],
                        "type": "string",
                        "description": "'Latest reviews' (default) is the fastest and most reliable — it gets recent reviews straight from G2. 'Latest + archive' also pulls older reviews and extra details from a review archive (more reviews, a little slower). 'Archive only' focuses on older reviews.",
                        "default": "rss"
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per product",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "The most reviews to collect for each product. You typically get up to ~125 recent reviews per product, plus older ones from the archive.",
                        "default": 100
                    },
                    "minRating": {
                        "title": "Lowest star rating to keep",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only keep reviews rated at least this many stars (1 to 5).",
                        "default": 1
                    },
                    "maxRating": {
                        "title": "Highest star rating to keep",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only keep reviews rated at most this many stars (1 to 5). Tip: set both the lowest and highest to the same number to get just that rating — for example, set both to 1 to read only the 1-star complaints.",
                        "default": 5
                    },
                    "includeHistorical": {
                        "title": "Also include older reviews from the archive",
                        "type": "boolean",
                        "description": "When using 'Latest + archive', this also pulls older reviews and extra details from the archive. Turn it off for the fastest possible run.",
                        "default": true
                    },
                    "historicalFromYear": {
                        "title": "Archive: earliest year",
                        "minimum": 2012,
                        "maximum": 2030,
                        "type": "integer",
                        "description": "Optional. Only include archived reviews from this year onward (for example, 2024)."
                    },
                    "aiTasks": {
                        "title": "Optional AI analysis (uses your own key)",
                        "type": "array",
                        "description": "Add AI analysis using your own ChatGPT or Claude key. 'Review sentiment' tags each review as positive, negative, neutral, or mixed and pulls out key themes. 'Product summary' gives you one report per product with the top complaints, most-requested features, quick wins, and competitors that reviewers mention.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "sentiment",
                                "productSummary"
                            ],
                            "enumTitles": [
                                "Review sentiment (per review)",
                                "Product summary (per product)"
                            ]
                        },
                        "default": []
                    },
                    "aiProvider": {
                        "title": "AI service",
                        "enum": [
                            "openai",
                            "anthropic"
                        ],
                        "type": "string",
                        "description": "Which AI service your key is for — OpenAI (ChatGPT) or Anthropic (Claude). Only needed if you turned on AI analysis above.",
                        "default": "openai"
                    },
                    "aiModel": {
                        "title": "AI model",
                        "type": "string",
                        "description": "Which AI model to use. Leave blank for a fast, low-cost default. You can enter any model your key supports — for example gpt-4o-mini, claude-haiku-4-5, claude-sonnet-5, or claude-fable-5."
                    },
                    "aiApiKey": {
                        "title": "Your AI key",
                        "type": "string",
                        "description": "Your own OpenAI (ChatGPT) or Anthropic (Claude) API key. It's used only for the AI analysis you selected. Your AI provider bills you directly for that usage — this scraper does not charge you for AI tokens. Your key is stored securely and never shared."
                    },
                    "maxAiReviews": {
                        "title": "Max reviews to run sentiment on (per product)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Caps how many reviews per product get individual sentiment tagging, so your AI costs stay predictable. The product summary always reads up to 60 reviews in a single pass.",
                        "default": 40
                    },
                    "proxyConfiguration": {
                        "title": "Network settings",
                        "type": "object",
                        "description": "Advanced. The defaults work well — most people can leave this as-is.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "BUYPROXIES94952"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
