# G2 Reviews Scraper (`silentflow/g2-review-intelligence`) Actor

Scrape G2.com reviews at scale with no compute costs. Get 35 fields per review: star ratings, NPS scores, dimension ratings, reviewer company size, industry and country, pros, cons, switching signals, and LLM-ready markdown. Search by product URL, name, or seller.

- **URL**: https://apify.com/silentflow/g2-review-intelligence.md
- **Developed by:** [SilentFlow](https://apify.com/silentflow) (community)
- **Categories:** AI, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.50 / 1,000 review extracteds

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

**Turn G2's 5 million reviews into structured, actionable data.** Ratings, NPS scores, pros/cons, reviewer demographics, and switching signals for any B2B software product. In seconds, not hours.

### How it works

![How G2 Reviews Scraper works, 3 steps from G2.com to structured data](https://api.apify.com/v2/key-value-stores/PHH4td3yHEGpTAcMU/records/how-it-works-v8.png)

### ✨ Why teams choose this over other G2 scrapers

Spending hours copying reviews from G2 tabs? Running scrapers that fail half the time? Missing the data that actually matters for your analysis?

- ⚡ **Get 1,000+ reviews per minute.** Other G2 scrapers take 30x longer. Paste a URL, get structured data back before your coffee gets cold.
- 📊 **35 fields per review, not 15.** Star ratings, NPS scores, dimension ratings (ease of use, setup, support), reviewer country, company size, industry, and switching data. The fields competitors skip are often the ones you need most.
- 🤖 **Ready for your LLM pipeline.** Every review includes a `markdownContent` field you can feed directly into ChatGPT, Claude, or any RAG system. No preprocessing needed.
- 🔍 **Search inside reviews.** Filter by keyword like "slow", "integration", or "support" to find exactly the feedback you're looking for across thousands of reviews.
- 🏢 **Scrape an entire vendor in one run.** Paste a seller URL like `/sellers/salesforce` and get reviews across all 72 of their products at once.
- 💰 **Pay per review, nothing else.** No compute costs, no proxy setup, no monthly fees. You only pay for data you actually receive.

### 🎯 What you can do with G2 review data

| Team | What they build |
|------|----------------|
| **Product** | Find the 3 features your competitor gets praised for that you don't have yet |
| **Sales** | Create battle cards with real quotes from verified G2 reviewers |
| **AI / LLM** | Feed thousands of structured reviews into your RAG pipeline or fine-tuning dataset |
| **Research** | Compare software adoption by company size and region across 220K+ products |
| **Customer Success** | Discover who switches away from your product and the exact reasons why |
| **VCs** | Run due diligence on any SaaS product using NPS trends and sentiment data |
| **Content** | Pull real testimonials and use cases mentioning specific keywords |

### 📥 Input parameters

#### Product or Seller URLs

| Parameter | Type | Description |
|-----------|------|-------------|
| `productUrls` | string[] | G2 product or seller URLs (e.g., `https://www.g2.com/products/slack/reviews` or `https://www.g2.com/sellers/salesforce`) |

#### Search by Name

| Parameter | Type | Description |
|-----------|------|-------------|
| `productNames` | string[] | Search for products by name (e.g., `Slack`, `Notion`, `Salesforce`) |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxReviews` | integer | 100 | Maximum reviews to scrape per product (up to 50,000) |

#### Sorting & Filtering

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `sort` | select | Most recent | Sort by: most recent, highest rated, or lowest rated |
| `starRatings` | integer[] | All | Filter by star rating (1-5). Leave empty for all ratings |
| `searchQuery` | string | | Filter reviews containing this keyword (e.g., "integration", "slow", "support") |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeSummary` | boolean | true | Add an analytics summary with rating distribution, avg NPS, top regions, and company segments |

#### Advanced

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `debugMode` | boolean | false | Enable detailed logging for troubleshooting |

### 📊 Output data

#### Review example

```json
{
    "reviewId": "12601006",
    "url": "https://www.g2.com/products/slack/reviews/12601006",
    "productName": "Slack",
    "productSlug": "slack",
    "productId": 3437,
    "reviewTitle": "Good tool for communication management",
    "pros": "Navigation is very easy, and I like having the option to organize different group chats.",
    "cons": "The only issue I have had was archiving old chats where there were people who already left.",
    "reviewText": "Communication with team Good tool for communication management",
    "markdownContent": "# Good tool for communication management\n\n**Rating:** 5/5 | **NPS:** 9/10...",
    "starRating": 5,
    "npsScore": 9,
    "easeOfUse": 10,
    "easeOfSetup": 8.5,
    "qualityOfSupport": 7.1,
    "meetsRequirements": 8.5,
    "reviewerName": "Elis L.",
    "country": "Estonia",
    "region": "EMEA",
    "companySegment": "Mid-Market",
    "industry": "Information Technology and Services",
    "submittedAt": "2026-04-08T06:38:48.161-05:00",
    "reviewSource": "g2",
    "switchedFrom": false,
    "responseType": "text",
    "dataType": "review"
}
````

#### Analytics summary example

```json
{
    "productName": "Slack",
    "productSlug": "slack",
    "totalReviews": 26954,
    "ratingDistribution": {"1": 40, "2": 91, "3": 457, "4": 3504, "5": 15387},
    "avgNps": 9.2,
    "avgEaseOfUse": 9.3,
    "avgEaseOfSetup": 9.3,
    "avgQualityOfSupport": 9.0,
    "avgMeetsRequirements": 9.3,
    "topRegions": {"Americas": 12470, "Asia Pacific": 4537, "EMEA": 2405},
    "topCompanySegments": {"Small-Business": 7886, "Mid-Market": 7849, "Enterprise": 3394},
    "topSources": {"g2": 13617, "organic": 3981, "vendor": 450},
    "dataType": "summary"
}
```

### 🗂️ Data fields

| Category | Fields |
|----------|--------|
| **Review** | `reviewId`, `reviewTitle`, `pros`, `cons`, `reviewText`, `markdownContent`, `submittedAt` |
| **Ratings** | `starRating` (1-5), `npsScore` (0-10), `easeOfUse`, `easeOfSetup`, `easeOfAdmin`, `qualityOfSupport`, `meetsRequirements` |
| **Reviewer** | `reviewerName`, `companySegment`, `industry`, `country`, `region` |
| **Product** | `productName`, `productSlug`, `productId`, `url` |
| **Competitive** | `switchedFrom`, `switchedReason`, `loveTheme`, `hateTheme` |
| **Metadata** | `reviewSource`, `sourceType`, `isIncentivized`, `helpfulCount`, `responseType` |
| **Summary** | `totalReviews`, `ratingDistribution`, `avgNps`, `avgEaseOfUse`, `topRegions`, `topCompanySegments`, `topSources` |

### 🚀 Examples

#### Get the latest Slack reviews

```json
{
    "productUrls": ["https://www.g2.com/products/slack/reviews"],
    "maxReviews": 100
}
```

#### Find reviews mentioning "integration"

```json
{
    "productUrls": ["https://www.g2.com/products/notion/reviews"],
    "maxReviews": 500,
    "searchQuery": "integration"
}
```

#### Pull only negative reviews for competitive analysis

```json
{
    "productUrls": ["https://www.g2.com/products/hubspot-sales-hub/reviews"],
    "maxReviews": 200,
    "sort": "lowest_rated",
    "starRatings": [1, 2]
}
```

#### Scrape all products from a vendor at once

```json
{
    "productUrls": ["https://www.g2.com/sellers/salesforce"],
    "maxReviews": 50
}
```

#### Compare multiple products by name

```json
{
    "productNames": ["Slack", "Notion", "Asana"],
    "maxReviews": 1000,
    "sort": "most_recent",
    "includeSummary": true
}
```

### 💻 Integrations

#### Python: Feed reviews into your LLM

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run_input = {
    "productUrls": ["https://www.g2.com/products/slack/reviews"],
    "maxReviews": 1000,
    "sort": "most_recent",
}

run = client.actor("silentflow/g2-review-intelligence").call(run_input=run_input)

reviews = []
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    if item["dataType"] == "review":
        reviews.append(item)
        print(f"{item['starRating']}⭐ {item['reviewTitle']}")
        print(f"  Pros: {item['pros'][:100]}...")
        print(f"  Cons: {item['cons'][:100]}...")
    elif item["dataType"] == "summary":
        print(f"\nSummary: {item['totalReviews']} reviews, avg NPS: {item['avgNps']}/10")

## Use markdownContent for RAG pipelines
for review in reviews:
    # Feed review["markdownContent"] to your LLM
    pass
```

#### JavaScript

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });

const run = await client.actor('silentflow/g2-review-intelligence').call({
    productUrls: ['https://www.g2.com/products/slack/reviews'],
    maxReviews: 1000,
    sort: 'most_recent',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();

const reviews = items.filter(i => i.dataType === 'review');
const summaries = items.filter(i => i.dataType === 'summary');

reviews.forEach(item => {
    console.log(`${item.starRating}⭐ ${item.reviewTitle}`);
});

summaries.forEach(s => {
    console.log(`${s.productName}: ${s.totalReviews} reviews, NPS ${s.avgNps}/10`);
});
```

### 📈 Performance

| Metric | Value |
|--------|-------|
| Speed | 1,000+ reviews per minute |
| Max reviews per product | 50,000 |
| Total reviews accessible | 5,300,000+ |
| Total products | 224,000+ |
| Memory usage | 256 MB (minimal) |

### 💡 Tips for best results

1. **Search inside reviews**: `searchQuery: "slow"` finds every review mentioning performance issues across thousands of reviews. Great for competitive analysis.
2. **Scrape entire vendors**: Paste a seller URL like `/sellers/salesforce` to get reviews across all of their products in one run.
3. **Filter by stars for sentiment analysis**: `starRatings: [1, 2]` for negative feedback, `[4, 5]` for testimonials.
4. **Use the summary**: The analytics summary gives you rating distribution, avg NPS, and reviewer demographics without processing individual reviews.
5. **Feed markdownContent to your LLM**: Each review includes a pre-formatted markdown version ready for ChatGPT, Claude, or your vector database.

### ❓ FAQ

**Q: Do I need a G2 account?**
A: No. The scraper extracts publicly available review data. No login, no API key, no cookies.

**Q: Why is this so much faster than other G2 scrapers?**
A: We use a direct data pipeline instead of browser-based scraping. No page rendering, no anti-bot workarounds, no retries.

**Q: What is the markdownContent field?**
A: A pre-formatted markdown version of each review with structured headers (pros, cons, comments) and metadata. Drop it straight into your LLM prompt or vector database.

**Q: Can I scrape all products from a single vendor?**
A: Yes. Paste a seller URL like `https://www.g2.com/sellers/salesforce` and the scraper finds and scrapes reviews from every product under that vendor.

**Q: What are the dimension ratings (easeOfUse, etc.)?**
A: G2 asks reviewers to rate products on specific dimensions (ease of use, setup, admin, support, meets requirements). We normalize these to a 0-10 scale.

**Q: How fresh is the data?**
A: Live data, every run. New reviews appear within minutes of being published on G2.

### 📬 Support

Need something this scraper doesn't do yet? We ship features fast.

- 💡 **Feature requests** go straight to our backlog
- ⚙️ **Enterprise needs?** We do custom integrations and high-volume setups

Response time: usually under 24 hours.

Check out our other scrapers: [SilentFlow on Apify](https://apify.com/silentflow)

# Actor input Schema

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

G2 product or seller URLs (e.g., https://www.g2.com/products/slack/reviews or https://www.g2.com/sellers/salesforce).

## `productNames` (type: `array`):

Search for products by name (e.g., 'Slack', 'HubSpot Sales Hub').

## `maxReviews` (type: `integer`):

Maximum number of reviews to scrape per product.

## `sort` (type: `string`):

Sort order for reviews.

## `starRatings` (type: `array`):

Only include reviews with these star ratings (leave empty for all).

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

Filter reviews containing this keyword (e.g., 'integration', 'slow', 'support'). Only reviews matching will be returned.

## `includeSummary` (type: `boolean`):

Add a summary item with rating distribution, top regions, company segments, and review sources.

## `debugMode` (type: `boolean`):

Enable detailed logging for troubleshooting.

## Actor input object example

```json
{
  "productUrls": [
    "https://www.g2.com/products/slack/reviews"
  ],
  "maxReviews": 100,
  "sort": "most_recent",
  "includeSummary": true,
  "debugMode": false
}
```

# Actor output Schema

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

Complete review data including: productName, reviewTitle, starRating, pros, cons, reviewText, reviewerName, submittedAt, and more.

## `resultsCSV` (type: `string`):

CSV format export for spreadsheet analysis

## `resultsExcel` (type: `string`):

Excel format export

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "productUrls": [
        "https://www.g2.com/products/slack/reviews"
    ],
    "maxReviews": 100,
    "sort": "most_recent"
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "productUrls": ["https://www.g2.com/products/slack/reviews"],
    "maxReviews": 100,
    "sort": "most_recent",
}

# Run the Actor and wait for it to finish
run = client.actor("silentflow/g2-review-intelligence").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "productUrls": [
    "https://www.g2.com/products/slack/reviews"
  ],
  "maxReviews": 100,
  "sort": "most_recent"
}' |
apify call silentflow/g2-review-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "G2 Reviews Scraper",
        "description": "Scrape G2.com reviews at scale with no compute costs. Get 35 fields per review: star ratings, NPS scores, dimension ratings, reviewer company size, industry and country, pros, cons, switching signals, and LLM-ready markdown. Search by product URL, name, or seller.",
        "version": "1.0",
        "x-build-id": "pAIVVrEWgGSEjGd3A"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/silentflow~g2-review-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-silentflow-g2-review-intelligence",
                "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/silentflow~g2-review-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-silentflow-g2-review-intelligence",
                "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/silentflow~g2-review-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-silentflow-g2-review-intelligence",
                "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": {
                    "productUrls": {
                        "title": "G2 Product or Seller URLs",
                        "type": "array",
                        "description": "G2 product or seller URLs (e.g., https://www.g2.com/products/slack/reviews or https://www.g2.com/sellers/salesforce).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "productNames": {
                        "title": "Product names",
                        "type": "array",
                        "description": "Search for products by name (e.g., 'Slack', 'HubSpot Sales Hub').",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Maximum reviews per product",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per product.",
                        "default": 100
                    },
                    "sort": {
                        "title": "Sort reviews by",
                        "enum": [
                            "most_recent",
                            "highest_rated",
                            "lowest_rated"
                        ],
                        "type": "string",
                        "description": "Sort order for reviews.",
                        "default": "most_recent"
                    },
                    "starRatings": {
                        "title": "Filter by star rating",
                        "type": "array",
                        "description": "Only include reviews with these star ratings (leave empty for all).",
                        "items": {
                            "type": "string",
                            "enum": [
                                "1",
                                "2",
                                "3",
                                "4",
                                "5"
                            ],
                            "enumTitles": [
                                "1 star",
                                "2 stars",
                                "3 stars",
                                "4 stars",
                                "5 stars"
                            ]
                        }
                    },
                    "searchQuery": {
                        "title": "Keyword search",
                        "type": "string",
                        "description": "Filter reviews containing this keyword (e.g., 'integration', 'slow', 'support'). Only reviews matching will be returned."
                    },
                    "includeSummary": {
                        "title": "Include review summary",
                        "type": "boolean",
                        "description": "Add a summary item with rating distribution, top regions, company segments, and review sources.",
                        "default": true
                    },
                    "debugMode": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "Enable detailed logging for troubleshooting.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
