# G2 Reviews Scraper — Ratings, Pros & Cons (`khadinakbar/g2-product-reviews-scraper`) Actor

Scrape G2 product reviews and metadata: star ratings, written reviews, pros, cons, sub-ratings, and reviewer firmographics. Paste a product URL or search by name. MCP-ready.

- **URL**: https://apify.com/khadinakbar/g2-product-reviews-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** AI, MCP servers, Lead generation
- **Stats:** 1 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.00 / 1,000 review scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Reviews Scraper — Ratings, Pros & Cons

Scrape **G2 product reviews and metadata** at scale: star ratings, full review text, pros, cons, and reviewer firmographics (job title, company size, verified status). Paste a G2 product URL or search by name — the actor auto-detects which mode to use. **MCP-ready** for AI agents.

G2 runs enterprise Cloudflare. This actor renders every page in a real **Firefox** browser through residential proxies to bypass the bot wall, then extracts structured data from the page's microdata and JSON-LD.

### What you get

| Field | Description |
|---|---|
| `productName` | Software product name on G2 |
| `productRating` | Aggregate star rating (0–5) |
| `productReviewCount` | Total reviews G2 reports |
| `vendor` / `category` | Vendor brand and G2 application category |
| `rating` | This review's star rating (0–5) |
| `reviewTitle` | Review headline |
| `reviewBody` | Full review text (general commentary) |
| `pros` | Reviewer's "What do you like best?" answers |
| `cons` | Reviewer's "What do you dislike?" answers |
| `subRatings` | Per-aspect scores (ease of use, support, value, features) when G2 shows them on the review |
| `reviewer` | name, title, companyName, companySize, industry, verified |
| `reviewDate` | Publish date (ISO 8601 UTC) |
| `reviewUrl` | Direct link to the review |
| `scrapedAt` | Scrape timestamp (ISO 8601 UTC) |

One row per review. In search mode you also get one `recordType: "product"` summary row per matched product.

### When to use it

- **Competitive intelligence** — track what real users praise and complain about in rival products.
- **Sales enablement** — arm reps with objection-handling data straight from buyer reviews.
- **Product & market research** — quantify sentiment, surface feature gaps, watch sub-rating trends.
- **AI agents** — pull structured G2 sentiment for any named product as a single tool call.

Do **not** use this for G2 *vendor profiles*, *compare* pages, or *category* index pages — paste a product reviews URL or use search.

### Pricing (Pay-Per-Event)

| Event | Price |
|---|---|
| Actor start | $0.005 (per GB RAM, once per run) |
| Review scraped | **$0.007** per review |
| Product found (search mode) | $0.01 per product card |

A 50-review run costs about **$0.36**. The actor prints an upfront cost cap in the log and status before it charges anything, and never charges past your `maxReviewsPerProduct` cap.

### Input

Provide **either** `startUrls` **or** `searchQuery`.

#### URL mode
```json
{
  "startUrls": [{ "url": "https://www.g2.com/products/slack/reviews" }],
  "maxReviewsPerProduct": 50,
  "sortReviewsBy": "newest"
}
````

#### Search mode

```json
{
  "searchQuery": "project management software",
  "maxProductsPerSearch": 5,
  "maxReviewsPerProduct": 30,
  "includeReviews": true
}
```

| Input | Default | Notes |
|---|---|---|
| `startUrls` | — | G2 product/reviews URLs. `/reviews` suffix optional. |
| `searchQuery` | — | Product name or keyword. |
| `maxReviewsPerProduct` | 50 | 1–5000, per product. |
| `maxProductsPerSearch` | 5 | 1–100, search mode only. |
| `includeReviews` | true | Search mode: scrape each product's reviews, or just return product cards. |
| `sortReviewsBy` | newest | `newest` or `helpful`. |
| `proxyConfiguration` | Residential US | Residential required (Cloudflare). |
| `debug` | false | Dump per-product extraction diagnostics to the KV store. |

### Output sample

```json
{
  "platform": "g2",
  "recordType": "review",
  "productName": "Slack",
  "productRating": 4.5,
  "productReviewCount": 23400,
  "rating": 5,
  "reviewTitle": "Best team chat we've used",
  "reviewBody": "Solving async coordination across three timezones...",
  "pros": ["Channels keep conversations organized", "Huge integration library"],
  "cons": ["Search on the free plan is limited"],
  "subRatings": { "easeOfUse": 9.2, "customerSupport": 8.7 },
  "reviewer": { "name": "Jordan M.", "title": "Engineering Manager", "companySize": "201-500 employees", "industry": "Computer Software", "verified": true },
  "reviewDate": "2026-04-18T00:00:00.000Z",
  "reviewUrl": "https://www.g2.com/products/slack/reviews/slack-review-12345678",
  "scrapedAt": "2026-06-19T12:00:00.000Z"
}
```

### Use from the API

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~g2-product-reviews-scraper/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://www.g2.com/products/slack/reviews"}],"maxReviewsPerProduct":50}'
```

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('khadinakbar/g2-product-reviews-scraper').call({
  startUrls: [{ url: 'https://www.g2.com/products/slack/reviews' }],
  maxReviewsPerProduct: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

### FAQ

**Why do I need residential proxies?** G2 sits behind enterprise Cloudflare bot management that blocks datacenter IPs instantly. Residential IPs plus a real Firefox fingerprint are what get through.

**A run returned 0 reviews — why?** Either the product URL is wrong/stale (the actor exits cleanly and tells you), or G2's Cloudflare blocked every attempt (the actor fails honestly with a "blocked" message rather than pretending success). Retry with a different proxy country, or try again later.

**Can it get every review on a product?** It paginates newest- or most-helpful-first up to `maxReviewsPerProduct`. Very large products (tens of thousands of reviews) are capped by what you set.

**Does it handle regional G2 content?** Set `proxyConfiguration.apifyProxyCountry` to target the region you want.

### Legal

This actor collects only publicly available information from G2.com. It does not log in, bypass paywalls, or access private data. You are responsible for using the output in compliance with G2's Terms of Service, applicable law (including GDPR/CCPA where relevant), and any contractual obligations. Use scraped review data for analysis and research, not republication that infringes G2's or reviewers' rights. This actor is not affiliated with or endorsed by G2.com.

# Actor input Schema

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

G2 product or reviews URLs to scrape, one record per review returned. Each must look like https://www.g2.com/products/{slug}/reviews (e.g. https://www.g2.com/products/slack/reviews); the /reviews suffix is optional and added automatically. Defaults to none — provide this OR searchQuery. NOT a G2 category, compare, or vendor-profile URL.

## `searchQuery` (type: `string`):

Product name or keyword to search on G2, then scrape the matching products' reviews. Free text, e.g. 'project management software' or 'Salesforce'. Defaults to empty — provide this OR startUrls. NOT a URL; paste URLs into startUrls instead.

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

Upper bound on how many reviews to extract for each product, newest or most-helpful first. Accepts 1–5000. Defaults to 50. This is per product, not a run-wide total — total cost scales with this times the number of products.

## `maxProductsPerSearch` (type: `integer`):

In search mode, how many matching products to take from the G2 search results. Accepts 1–100. Defaults to 5. Ignored when you pass startUrls instead of a searchQuery.

## `includeReviews` (type: `boolean`):

When true (default), search mode visits each matched product and scrapes its reviews. When false, search mode returns only product summary cards (name, URL) — cheaper for discovery. Has no effect in URL mode, which always scrapes reviews.

## `sortReviewsBy` (type: `string`):

Order in which G2 returns reviews before the per-product cap is applied. 'newest' fetches the most recent reviews first; 'helpful' fetches the most-helpful first. Defaults to 'newest'. Affects which reviews you get when maxReviewsPerProduct is smaller than the total.

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

Proxy used to reach G2, which runs enterprise Cloudflare. Defaults to Apify Proxy; the actor automatically retries Cloudflare-blocked requests through a residential fallback, so it works out of the box. For a residential-only path, select the Residential group here (recommended if you have residential access).

## `debug` (type: `boolean`):

When true, writes a per-product diagnostic dump (JSON-LD nodes, selector hits, HTML head) to the key-value store for troubleshooting extraction. Defaults to false. Leave off for normal runs — it adds no review data and slightly slows the run.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.g2.com/products/slack/reviews"
    }
  ],
  "searchQuery": "project management software",
  "maxReviewsPerProduct": 50,
  "maxProductsPerSearch": 5,
  "includeReviews": true,
  "sortReviewsBy": "newest",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "debug": false
}
```

# Actor output Schema

## `datasetItemsJson` (type: `string`):

All scraped rows as JSON.

## `datasetItemsCsv` (type: `string`):

All scraped rows as CSV.

## `datasetUrl` (type: `string`):

Console dataset view.

# 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"
        }
    ],
    "maxReviewsPerProduct": 50,
    "maxProductsPerSearch": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/g2-product-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" }],
    "maxReviewsPerProduct": 50,
    "maxProductsPerSearch": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/g2-product-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"
    }
  ],
  "maxReviewsPerProduct": 50,
  "maxProductsPerSearch": 5
}' |
apify call khadinakbar/g2-product-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "G2 Reviews Scraper — Ratings, Pros & Cons",
        "description": "Scrape G2 product reviews and metadata: star ratings, written reviews, pros, cons, sub-ratings, and reviewer firmographics. Paste a product URL or search by name. MCP-ready.",
        "version": "1.0",
        "x-build-id": "6AnSATKmUH5gpGPDV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~g2-product-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-g2-product-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/khadinakbar~g2-product-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-g2-product-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/khadinakbar~g2-product-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-g2-product-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "G2 product URLs",
                        "type": "array",
                        "description": "G2 product or reviews URLs to scrape, one record per review returned. Each must look like https://www.g2.com/products/{slug}/reviews (e.g. https://www.g2.com/products/slack/reviews); the /reviews suffix is optional and added automatically. Defaults to none — provide this OR searchQuery. NOT a G2 category, compare, or vendor-profile URL.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Product name or keyword to search on G2, then scrape the matching products' reviews. Free text, e.g. 'project management software' or 'Salesforce'. Defaults to empty — provide this OR startUrls. NOT a URL; paste URLs into startUrls instead."
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per product",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Upper bound on how many reviews to extract for each product, newest or most-helpful first. Accepts 1–5000. Defaults to 50. This is per product, not a run-wide total — total cost scales with this times the number of products."
                    },
                    "maxProductsPerSearch": {
                        "title": "Max products per search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "In search mode, how many matching products to take from the G2 search results. Accepts 1–100. Defaults to 5. Ignored when you pass startUrls instead of a searchQuery."
                    },
                    "includeReviews": {
                        "title": "Scrape reviews in search mode",
                        "type": "boolean",
                        "description": "When true (default), search mode visits each matched product and scrapes its reviews. When false, search mode returns only product summary cards (name, URL) — cheaper for discovery. Has no effect in URL mode, which always scrapes reviews.",
                        "default": true
                    },
                    "sortReviewsBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "newest",
                            "helpful"
                        ],
                        "type": "string",
                        "description": "Order in which G2 returns reviews before the per-product cap is applied. 'newest' fetches the most recent reviews first; 'helpful' fetches the most-helpful first. Defaults to 'newest'. Affects which reviews you get when maxReviewsPerProduct is smaller than the total.",
                        "default": "newest"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used to reach G2, which runs enterprise Cloudflare. Defaults to Apify Proxy; the actor automatically retries Cloudflare-blocked requests through a residential fallback, so it works out of the box. For a residential-only path, select the Residential group here (recommended if you have residential access).",
                        "default": {
                            "useApifyProxy": true
                        }
                    },
                    "debug": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "When true, writes a per-product diagnostic dump (JSON-LD nodes, selector hits, HTML head) to the key-value store for troubleshooting extraction. Defaults to false. Leave off for normal runs — it adds no review data and slightly slows the run.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```