# G2 Products Reviews Scraper (`fetch_cat/g2-products-reviews-scraper`) Actor

Extract recent public G2 product reviews by product URL, RSS URL, or slug.

- **URL**: https://apify.com/fetch\_cat/g2-products-reviews-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Lead generation, SEO tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.52 / 1,000 review saveds

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/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 Products Reviews Scraper

Extract recent public G2 product reviews from G2's RSS feeds by product URL, RSS URL, or bare product slug.

Use this Actor to monitor buyer feedback, collect public review text for market research, and export structured G2 review rows to CSV, JSON, Excel, API, or automation workflows.

### At a glance

- **Primary job**: Collect recent public reviews for known G2 products.
- **Input**: G2 product review URLs, RSS URLs, or product slugs such as `slack` and `figma`.
- **Output**: One dataset row per review with product, reviewer, rating, pros, cons, problems solved, date, and review URL fields when available in the RSS feed.
- **Best for**: Review monitoring, competitive research, voice-of-customer analysis, and workflow automation.

### Important scope note

This V1 is focused on known G2 products and recent public reviews. It is intentionally not a full G2 product search, category browser, product metadata, or full-history scraper.

### Common workflows

- **Review monitoring**: Schedule repeat runs for your product slugs and compare new review IDs over time.
- **Competitive research**: Collect recent reviews for several competitors and analyze likes, dislikes, and problems solved.
- **Voice of customer**: Export pros/cons/problem fields into spreadsheets, BI tools, or LLM analysis pipelines.
- **Automation**: Trigger webhooks or API workflows when new reviews appear in the dataset.

### Input recipes

- **Small smoke test**: `productSlugs: ["slack"]`, `maxItems: 10`.
- **Mixed URL and slug run**: Use `startUrls` with a G2 review URL and `productSlugs` with one or more slugs.
- **Monitoring run**: Set `lookbackDays` to keep only reviews published in the last N days.

### What data can you extract?

| Field | Description |
| --- | --- |
| `productSlug` | G2 product slug used for the RSS feed. |
| `productName` | Product name from the RSS channel when available. |
| `reviewId` | Stable review identifier parsed from the review URL or GUID. |
| `reviewUrl` | Public G2 review URL. |
| `rssUrl` | Source RSS feed URL. |
| `title` | Review title. |
| `rating` / `ratingText` | Numeric rating and original rating phrase when available. |
| `reviewerName` | Reviewer name/snippet when exposed by the feed. |
| `reviewerRole` | Reviewer role when exposed by the feed. |
| `reviewerIndustry` | Reviewer industry when exposed by the feed. |
| `reviewerCompanySize` | Company size when exposed by the feed. |
| `likes` | Answer to what the reviewer likes. |
| `dislikes` | Answer to what the reviewer dislikes. |
| `problemsSolved` | Answer describing problems solved / benefits. |
| `publishedAt` | Review publication date in ISO format. |
| `guid` | RSS GUID. |
| `source` | Source marker, currently `g2_rss`. |

### Input configuration

| Setting | JSON key | Use it for | Example |
| --- | --- | --- | --- |
| Mode | `mode` | Choose `product_reviews`, `product_search`, or `category_browse`. | `product_reviews` |
| G2 product URLs | `startUrls` | Paste G2 product review URLs or feed URLs. | `https://www.g2.com/products/slack/reviews` |
| Product slugs | `productSlugs` | Enter bare G2 product slugs. | `slack` |
| Search queries | `searchQueries` | Find matching G2 products in product search mode. | `crm` |
| Category names | `categoryNames` | Browse products in matching G2 categories. | `CRM` |
| Maximum records | `maxItems` | Cap saved rows and control spend. | `50` |
| Lookback days | `lookbackDays` | Keep only recent reviews by publish date. | `30` |
| Skip failed products | `skipFailedProducts` | Continue when one product is invalid, missing, or blocked. | `true` |
| Use fallback source | `useRssFallback` | Try a simpler public review feed when richer review records are unavailable. | `true` |

### Example input

```json
{
  "productSlugs": ["slack", "figma"],
  "maxItems": 25,
  "skipFailedProducts": true
}
````

### Example output

```json
{
  "productSlug": "slack",
  "productName": "Slack",
  "reviewId": "abc123",
  "reviewUrl": "https://www.g2.com/products/slack/reviews/...",
  "rssUrl": "https://www.g2.com/products/slack/reviews/feed",
  "title": "Slack keeps our team aligned",
  "rating": 4.5,
  "ratingText": "4.5 out of 5 stars",
  "reviewerName": "Validated Reviewer",
  "reviewerRole": "Marketing Manager",
  "reviewerIndustry": "Computer Software",
  "reviewerCompanySize": "51-1000 employees",
  "likes": "Channels and searchable message history help our team collaborate.",
  "dislikes": "Notification settings can take time to tune.",
  "problemsSolved": "Centralizes team communication and reduces email threads.",
  "publishedAt": "2026-07-01T12:00:00.000Z",
  "guid": "https://www.g2.com/products/slack/reviews/...",
  "source": "g2_rss"
}
```

### Pricing

| Event | Free | Bronze | Silver | Gold | Platinum | Diamond | Charged when |
| --- | ---: | ---: | ---: | ---: | ---: | ---: | --- |
| Run start | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 | Once when the Actor starts. |
| Review saved | $0.001 | $0.00087 | $0.00068 | $0.00052 | $0.00035 | $0.00024 | Each review row saved to the dataset. |

### Tips for best results

- **Use known product slugs**: This Actor does not search G2 for product names.
- **Expect recent-feed coverage**: RSS feeds are for recent reviews and may not contain full historical review archives.
- **Start small**: Use `maxItems: 10` until output quality and pricing are verified.
- **Handle misses cleanly**: Keep `skipFailedProducts` enabled for multi-product runs.

### API usage

Node.js:

```js
import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("fetch_cat/g2-products-reviews-scraper").call({
  productSlugs: ["slack", "figma"],
  maxItems: 25
});
console.log(run.defaultDatasetId);
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("fetch_cat/g2-products-reviews-scraper").call(run_input={
    "productSlugs": ["slack", "figma"],
    "maxItems": 25,
})
print(run["defaultDatasetId"])
```

cURL:

```bash
curl -X POST "https://api.apify.com/v2/acts/fetch_cat~g2-products-reviews-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"productSlugs":["slack","figma"],"maxItems":25}'
```

### MCP and AI agents

Use this Actor from MCP-compatible tools through the official Apify MCP Server.

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=fetch_cat/g2-products-reviews-scraper"
```

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

Example prompt: "Run G2 Products Reviews Scraper for slack and figma, then summarize the top repeated likes and dislikes."

### Limits and caveats

- **Recent RSS only**: The Actor does not promise full G2 review history.
- **No product discovery**: Provide exact G2 product slugs or product URLs.
- **Public data only**: The Actor does not accept G2 logins, cookies, or private credentials.
- **Source variability**: G2 can change RSS content, fields, or availability.

### Legality and responsible use

Process only data that you are allowed to access. Follow website terms, Apify's terms, and applicable laws.

### Related actors

- [Trustpilot Reviews Scraper](https://apify.com/fetch_cat/trustpilot-reviews-scraper)
- [Google Maps Reviews Scraper](https://apify.com/fetch_cat/google-maps-reviews-scraper)

### FAQ

#### Can this scrape every historical G2 review?

No. This Actor is best suited for recent public review monitoring.

#### Why are some reviewer fields empty?

RSS items do not expose every field for every review. The Actor leaves unavailable fields empty instead of guessing.

#### Can I export results?

Yes. Apify datasets support JSON, CSV, Excel, XML, RSS, and API access.

### Support

Open an issue from the Actor page if a run fails or output looks wrong. Include the run ID or run URL, input JSON, expected output, actual output, and one reproducible public URL such as `https://www.g2.com/products/slack/reviews`.

# Actor input Schema

## `mode` (type: `string`):

Choose whether to export public reviews for known products, search products by keyword, or browse products by category name.

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

G2 product review pages or RSS URLs, for example https://www.g2.com/products/slack/reviews or https://www.g2.com/products/slack/reviews.rss.

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

Bare G2 product slugs. Example: slack, figma, postman.

## `searchQueries` (type: `array`):

Keywords for product\_search mode, for example crm, project management, or help desk.

## `categoryNames` (type: `array`):

G2 category names for category\_browse mode, for example CRM, Project Management, or Business Instant Messaging.

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

Maximum review or product records to save across all inputs. Each public search request is capped at 100 records.

## `lookbackDays` (type: `integer`):

For product\_reviews mode, only save reviews submitted in the last N days. Leave empty to keep all matched reviews up to maxItems.

## `skipFailedProducts` (type: `boolean`):

Continue with other products when one product cannot be resolved. Kept for backward compatibility.

## `useRssFallback` (type: `boolean`):

If public search returns no review rows for product\_reviews mode, try the public G2 reviews RSS feed.

## Actor input object example

```json
{
  "mode": "product_reviews",
  "startUrls": [
    {
      "url": "https://www.g2.com/products/slack/reviews"
    }
  ],
  "productSlugs": [
    "slack"
  ],
  "searchQueries": [
    "crm"
  ],
  "categoryNames": [
    "CRM"
  ],
  "maxItems": 10,
  "skipFailedProducts": true,
  "useRssFallback": true
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.g2.com/products/slack/reviews"
        }
    ],
    "productSlugs": [
        "slack"
    ],
    "searchQueries": [
        "crm"
    ],
    "categoryNames": [
        "CRM"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/g2-products-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": [{ "url": "https://www.g2.com/products/slack/reviews" }],
    "productSlugs": ["slack"],
    "searchQueries": ["crm"],
    "categoryNames": ["CRM"],
}

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "G2 Products Reviews Scraper",
        "description": "Extract recent public G2 product reviews by product URL, RSS URL, or slug.",
        "version": "0.1",
        "x-build-id": "NvJ5jsVBrWqzdwYDm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~g2-products-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-g2-products-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/fetch_cat~g2-products-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-g2-products-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/fetch_cat~g2-products-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-g2-products-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "product_reviews",
                            "product_search",
                            "category_browse"
                        ],
                        "type": "string",
                        "description": "Choose whether to export public reviews for known products, search products by keyword, or browse products by category name.",
                        "default": "product_reviews"
                    },
                    "startUrls": {
                        "title": "G2 product URLs or RSS URLs",
                        "type": "array",
                        "description": "G2 product review pages or RSS URLs, for example https://www.g2.com/products/slack/reviews or https://www.g2.com/products/slack/reviews.rss.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "productSlugs": {
                        "title": "Product slugs",
                        "type": "array",
                        "description": "Bare G2 product slugs. Example: slack, figma, postman.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Keywords for product_search mode, for example crm, project management, or help desk.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "categoryNames": {
                        "title": "Category names",
                        "type": "array",
                        "description": "G2 category names for category_browse mode, for example CRM, Project Management, or Business Instant Messaging.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum review or product records to save across all inputs. Each public search request is capped at 100 records.",
                        "default": 10
                    },
                    "lookbackDays": {
                        "title": "Lookback days",
                        "minimum": 1,
                        "maximum": 3650,
                        "type": "integer",
                        "description": "For product_reviews mode, only save reviews submitted in the last N days. Leave empty to keep all matched reviews up to maxItems."
                    },
                    "skipFailedProducts": {
                        "title": "Skip failed products",
                        "type": "boolean",
                        "description": "Continue with other products when one product cannot be resolved. Kept for backward compatibility.",
                        "default": true
                    },
                    "useRssFallback": {
                        "title": "Use RSS fallback",
                        "type": "boolean",
                        "description": "If public search returns no review rows for product_reviews mode, try the public G2 reviews RSS feed.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
