# G2 Products Scraper (`maximedupre/g2-products-scraper`) Actor

Scrape G2 products from product URLs, slugs, search terms, category names, or G2 search URLs. Get product names, ratings, review counts, categories, pricing, alternatives, comparisons, and optional review rows or samples.

- **URL**: https://apify.com/maximedupre/g2-products-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Business, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.60 / 1,000 scraped products

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are 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

### 🔎 G2 products scraper for product and review data

G2 Products Scraper collects public product data from [G2](https://www.g2.com/) so you can turn product pages, product slugs, search terms, category names, and G2 search URLs into structured rows. Use it to export software product names, URLs, ratings, review counts, categories, vendor details, pricing signals, alternatives, comparisons, and optional G2 review rows or review samples.

It is built for market research, sales intelligence, product benchmarking, SaaS category tracking, and repeatable competitive analysis. You do not need a G2 login, cookies, or a G2 API key.

### 📦 What this Actor does

- Scrapes public G2 product profiles from product URLs or product slugs.
- Searches G2 by search term, category name, or pasted G2 search URL.
- Saves one product row per discovered product.
- Optionally adds a small review sample to product rows.
- Optionally saves G2 reviews as separate review rows.
- Lets you cap products per target, products across a run, reviews per product, and reviews across a run.
- Supports review sorting by newest, most helpful, highest rating, or lowest rating.
- Supports optional minimum and maximum review rating filters.

This Actor is focused on public G2 product and review data. It does not scrape private account data, buyer intent data, reviewer contact enrichment, or any data that requires a logged-in G2 account.

### 📊 Data you can collect

Product rows can include:

- `recordType`, `productId`, `slug`, `name`, and `description`
- `productUrl`, `websiteUrl`, `vendorName`, and `vendorUrl`
- `rating`, `reviewCount`, `categories`, and `imageUrl`
- `pricingPlans`, `alternatives`, `comparisons`, and `starDistribution` when visible
- `reviewSamples` when review samples are enabled
- `submittedTarget`, `targetType`, `sourceUrl`, `sourceRank`, and `scrapedAt`

Review rows can include:

- `recordType`, `reviewId`, `productId`, `productSlug`, and `productName`
- `productUrl`, `title`, `reviewText`, `starRating`, and `nps`
- `publishedDate`, `reviewerName`, `reviewerSegment`, `sourceUrl`, and `scrapedAt`

Some fields can be empty when G2 does not show them on the public page or listing being scraped.

### 🎯 Use cases

- Build a shortlist of tools in a G2 category such as CRM, help desk, project management, or analytics.
- Monitor competitor ratings, review counts, positioning, and visible alternatives.
- Export product pages into a spreadsheet, CRM, warehouse, or research workflow.
- Collect recent G2 review text for product marketing, sales enablement, or voice-of-customer analysis.
- Compare products found from multiple G2 searches without opening every page by hand.

### 🚀 How to run it

1. Open the Actor input.
2. Add one target per line in **G2 targets**.
3. Use a G2 product URL, product slug, search term, category name, or G2 search URL.
4. Set **Maximum products** and **Maximum products per target** to control product collection.
5. Keep **Review mode** set to **Products only** for product lists, or switch it on when you need review samples or separate review rows.
6. Start the Actor and open the dataset when the run finishes.

For a useful first export, keep the prefilled `https://www.g2.com/categories/crm` example and leave review mode off.

### ⚙️ Input

| Field | What to enter |
| --- | --- |
| `targets` | One G2 product URL, product slug, search term, category name, or G2 search URL per line. |
| `maxProducts` | Maximum product rows to collect across the whole run. |
| `maxProductsPerTarget` | Maximum product rows to collect for each target. |
| `reviewMode` | `none` for products only, `sample` for review samples on product rows, or `rows` for separate review rows. |
| `maxReviewsPerProduct` | Maximum reviews to collect for each product when review collection is enabled. |
| `maxTotalReviews` | Maximum review rows to collect across the whole run. |
| `reviewSort` | Review order: newest, most helpful, highest rating, or lowest rating. |
| `minReviewRating` | Optional minimum G2 review rating from 0 to 10. |
| `maxReviewRating` | Optional maximum G2 review rating from 0 to 10. |

Example input:

```json
{
	"targets": ["CRM", "slack", "https://www.g2.com/search/products?query=project%20management"],
	"maxProducts": 25,
	"maxProductsPerTarget": 10,
	"reviewMode": "rows",
	"maxReviewsPerProduct": 3,
	"maxTotalReviews": 25,
	"reviewSort": "newest"
}
````

### 🧾 Output example

Product row:

```json
{
	"recordType": "product",
	"productId": "slack",
	"slug": "slack",
	"name": "Slack",
	"description": "A messaging app for teams...",
	"productUrl": "https://www.g2.com/products/slack/reviews",
	"websiteUrl": "https://slack.com/",
	"vendorName": "Slack",
	"rating": 4.5,
	"reviewCount": 33000,
	"categories": ["Business Instant Messaging"],
	"pricingPlans": [],
	"alternatives": [],
	"comparisons": [],
	"submittedTarget": "slack",
	"targetType": "product",
	"sourceUrl": "https://www.g2.com/products/slack/reviews",
	"sourceRank": 1,
	"scrapedAt": "2026-06-13T00:00:00.000Z"
}
```

Review row:

```json
{
	"recordType": "review",
	"reviewId": "example-review-id",
	"productId": "slack",
	"productSlug": "slack",
	"productName": "Slack",
	"productUrl": "https://www.g2.com/products/slack/reviews",
	"title": "Easy team communication",
	"reviewText": "Slack helps our team keep project conversations organized.",
	"starRating": 9,
	"publishedDate": "2026-06-01",
	"reviewerName": "Verified User",
	"reviewerSegment": "Mid-Market",
	"sourceUrl": "https://www.g2.com/products/slack/reviews",
	"scrapedAt": "2026-06-13T00:00:00.000Z"
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing:

- Actor start: charged once when a run starts.
- Scraped product: charged for each G2 product collected.
- Scraped review: charged for each G2 review collected when review rows are enabled.

Use product and review limits to control the maximum number of charged items in a run.

### ⚠️ Limits and notes

- The Actor scrapes public G2 pages only.
- Review rows are optional. Keep review mode off when you only need product lists.
- Product URLs and slugs usually return richer product details than broad search or category listings.
- Pricing, alternatives, comparisons, star distribution, vendor details, images, and review metadata are included when visible on G2.
- Removed, private, blocked, or unresolved products may be skipped with a warning.
- Very broad searches and categories can return many products, so use limits for controlled first runs.

### ❓ FAQ

#### 🔐 Can I scrape G2 products without a G2 account?

Yes. Add public G2 product URLs, product slugs, search terms, category names, or G2 search URLs. You do not need to add G2 cookies, a G2 login, or a G2 API key.

#### 📝 Can I scrape G2 reviews?

Yes. Set `reviewMode` to `sample` when you want review snippets attached to product rows, or `rows` when you want each review saved as its own row.

#### 📭 Why are some fields empty?

G2 does not show every field on every page. Fields such as pricing, alternatives, comparisons, vendor URLs, reviewer segments, or star distribution can be empty when the public page does not expose them.

#### 🧩 Can I use search terms and category names together?

Yes. Put one target per line. The Actor can process mixed target types in the same run.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~g2-products-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Product Hunt Scraper ↗](https://apify.com/maximedupre/product-hunt-scraper) - Find startup products, launches, reviews, and website details.
- [LinkedIn Company Scraper ↗](https://apify.com/maximedupre/linkedin-company-scraper) - Export public company profile data for market research and lead lists.
- [App Store Ratings Scraper ↗](https://apify.com/maximedupre/app-store-ratings-scraper) - Monitor Google Play and Apple App Store ratings and app metadata.
- [AmbitionBox Reviews Scraper ↗](https://apify.com/maximedupre/ambitionbox-reviews-scraper) - Collect public employee reviews and company aggregates from AmbitionBox.
- [Reddit Scraper ↗](https://apify.com/maximedupre/reddit-scraper) - Search Reddit posts and comments for customer research and trend monitoring.

**Made with ❤️ by Maxime Dupré**

# Actor input Schema

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

Enter one G2 product URL, product slug, search term, category name, or G2 search URL per line.

## `maxProducts` (type: `integer`):

Maximum product rows to save across the whole run.

## `maxProductsPerTarget` (type: `integer`):

Maximum product rows to save from each search term, category, or search URL.

## `reviewMode` (type: `string`):

Choose whether to skip reviews, attach a small sample to product rows, or save reviews as separate rows.

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

Maximum reviews to collect for each product when reviews are selected.

## `maxTotalReviews` (type: `integer`):

Maximum review rows or sampled reviews to collect across the whole run.

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

Choose which reviews are collected first when reviews are selected.

## `minReviewRating` (type: `integer`):

Lowest NPS-style review rating to collect when reviews are selected.

## `maxReviewRating` (type: `integer`):

Highest NPS-style review rating to collect when reviews are selected.

## Actor input object example

```json
{
  "targets": [
    "https://www.g2.com/categories/crm"
  ],
  "maxProducts": 25,
  "maxProductsPerTarget": 25,
  "reviewMode": "none",
  "maxReviewsPerProduct": 3,
  "maxTotalReviews": 25,
  "reviewSort": "newest"
}
```

# Actor output Schema

## `results` (type: `string`):

Open the collected G2 products and optional reviews.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "targets": [
        "https://www.g2.com/categories/crm"
    ]
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = { "targets": ["https://www.g2.com/categories/crm"] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/g2-products-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "targets": [
    "https://www.g2.com/categories/crm"
  ]
}' |
apify call maximedupre/g2-products-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "G2 Products Scraper",
        "description": "Scrape G2 products from product URLs, slugs, search terms, category names, or G2 search URLs. Get product names, ratings, review counts, categories, pricing, alternatives, comparisons, and optional review rows or samples.",
        "version": "0.1",
        "x-build-id": "AxRpfGAAm8RIhx9lJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~g2-products-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-g2-products-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/maximedupre~g2-products-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-g2-products-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/maximedupre~g2-products-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-g2-products-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": [
                    "targets"
                ],
                "properties": {
                    "targets": {
                        "title": "G2 targets",
                        "type": "array",
                        "description": "Enter one G2 product URL, product slug, search term, category name, or G2 search URL per line.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxProducts": {
                        "title": "Maximum products",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum product rows to save across the whole run.",
                        "default": 25
                    },
                    "maxProductsPerTarget": {
                        "title": "Products per target",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum product rows to save from each search term, category, or search URL.",
                        "default": 25
                    },
                    "reviewMode": {
                        "title": "Review handling",
                        "enum": [
                            "none",
                            "sample",
                            "rows"
                        ],
                        "type": "string",
                        "description": "Choose whether to skip reviews, attach a small sample to product rows, or save reviews as separate rows.",
                        "default": "none"
                    },
                    "maxReviewsPerProduct": {
                        "title": "Reviews per product",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum reviews to collect for each product when reviews are selected.",
                        "default": 3
                    },
                    "maxTotalReviews": {
                        "title": "Maximum reviews",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum review rows or sampled reviews to collect across the whole run.",
                        "default": 25
                    },
                    "reviewSort": {
                        "title": "Review sort",
                        "enum": [
                            "newest",
                            "helpful",
                            "rating_high",
                            "rating_low"
                        ],
                        "type": "string",
                        "description": "Choose which reviews are collected first when reviews are selected.",
                        "default": "newest"
                    },
                    "minReviewRating": {
                        "title": "Minimum review rating",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Lowest NPS-style review rating to collect when reviews are selected."
                    },
                    "maxReviewRating": {
                        "title": "Maximum review rating",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Highest NPS-style review rating to collect when reviews are selected."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```