# G2 Reviews Scraper — Software Reviews & Product Data (`scrapepilot/g2-reviews-scraper----software-reviews-product-data`) Actor

Scrape G2 software reviews from any product page. Get review title, full text, pros & cons, star rating, reviewer name, job title, date, and helpful votes. Cloudflare bypass built-in. Multi-product batch. No login. $9.99/month. 2-hour free trial.

- **URL**: https://apify.com/scrapepilot/g2-reviews-scraper----software-reviews-product-data.md
- **Developed by:** [Scrape Pilot](https://apify.com/scrapepilot) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 3 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

$9.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

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

## 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 — Software Reviews & Product Intelligence

> **The most reliable G2 Reviews Scraper on Apify.** Extract verified customer reviews, star ratings, pros & cons, reviewer job titles, review dates, and complete product metadata from any G2 software listing — in bulk. No login. No API key. Cloudflare bypass built-in. Instant structured output.


---

### 📌 Table of Contents

- [What Is This Actor?](#what-is-this-actor)
- [Why Use This G2 Reviews Scraper?](#why-use-this-g2-reviews-scraper)
- [Use Cases](#use-cases)
- [Input Parameters](#input-parameters)
- [Output Fields](#output-fields)
- [Example Input & Output](#example-input--output)
- [Pricing & Free Trial](#pricing--free-trial)
- [Performance & Limits](#performance--limits)
- [FAQ](#faq)
- [Changelog](#changelog)
- [Legal & Terms of Use](#legal--terms-of-use)

---

### 🔍 What Is This Actor?

**G2 Reviews Scraper** is a production-ready Apify actor that extracts complete customer review data and product metadata from any public G2 software listing page.

Provide a product name, G2 slug, or full G2 URL — and receive back a clean, structured dataset of **G2 software reviews**: review title, full review body, star rating, pros, cons, reviewer name, reviewer job title, review date, and helpful vote count. Every record is enriched with product-level metadata including the product name, overall G2 rating, total review count, and direct G2 product URL.

Whether you are monitoring your own software reputation, benchmarking competitors, building a buyer's guide, or training an NLP model on SaaS feedback — this **G2 reviews scraper** delivers the most complete G2 software reviews dataset available on Apify.

---

### 🚀 Why Use This G2 Reviews Scraper?

| Feature | This Actor | Manual Export | Other Scrapers | G2 API |
|---|---|---|---|---|
| **G2 software reviews — bulk** | ✅ | ❌ Slow | ⚠️ Often blocked | ❌ Enterprise only |
| **Pros & cons separately extracted** | ✅ Both fields | ✅ | ❌ | ✅ |
| **Reviewer job title** | ✅ | ✅ | ❌ | ✅ |
| **Star rating per review** | ✅ | ✅ | ⚠️ | ✅ |
| **Review date** | ✅ | ✅ | ⚠️ | ✅ |
| **Helpful vote count** | ✅ | ❌ | ❌ | ⚠️ |
| **Product overall rating + total reviews** | ✅ Every record | ❌ | ⚠️ | ✅ |
| **Multi-product batch** | ✅ | ❌ | ❌ | ❌ |
| **Cloudflare bypass built-in** | ✅ | N/A | ❌ Often fails | N/A |
| **No login or API key** | ✅ | N/A | ✅ | ❌ Required |

> **Bottom line:** This **G2 reviews scraper** is the only actor that reliably bypasses G2's Cloudflare protection while extracting pros, cons, reviewer job titles, and helpful vote counts — alongside the standard review text and star rating — in a single structured run.

---

### 🎯 Use Cases

#### 🏆 Software Reputation Monitoring
- Scrape **G2 software reviews** for your own product to track sentiment trends over time
- Monitor incoming reviews for recurring praise themes and complaint patterns
- Track your G2 overall rating and total review count growth with scheduled runs

#### 🔍 Competitive Intelligence & Benchmarking
- Extract **G2 software reviews** from competitor products to analyze their customer satisfaction
- Compare overall ratings, review volumes, pros, and cons across competing SaaS tools
- Identify gaps in competitor products by analyzing recurring cons in their G2 review data

#### 🤖 NLP & Sentiment Analysis Datasets
- Build labeled sentiment datasets using G2 star ratings as ground truth for ML training
- Collect pros and cons fields separately for aspect-based sentiment analysis research
- Scrape multilingual **G2 software reviews** for cross-market NLP model training

#### 📊 Product & Market Research
- Aggregate G2 review data across an entire software category for market landscape research
- Study what features customers care most about in a specific SaaS vertical using review text
- Build structured datasets of G2 software reviews for industry analyst reports or buyer guides

#### 🛒 Buyer Guides & Comparison Platforms
- Populate software comparison sites with verified G2 review data — ratings, pros, cons, reviewer roles
- Build automated buyer guide content using G2 software reviews as primary source material
- Enrich product listings with real customer feedback from G2 for trust and conversion

#### 🎓 Academic & Business Research
- Collect G2 review datasets for research on enterprise software adoption and user satisfaction
- Study how reviewer job titles correlate with product ratings across software categories
- Analyze review helpfulness patterns across different SaaS product types

---

### ⚙️ Input Parameters

```json
{
  "products": [
    "notion",
    "salesforce",
    "https://www.g2.com/products/hubspot/reviews"
  ],
  "max_reviews": 20,
  "proxyConfiguration": {
    "useApifyProxy":    true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
````

| Parameter | Type | Default | Description |
|---|---|---|---|
| `products` | array or string | `[]` | Product names, G2 slugs, or full G2 review URLs — e.g. `"notion"`, `"slack"`, `"https://www.g2.com/products/notion/reviews"`. Newline-separated string also accepted |
| `max_reviews` | integer | `20` | Maximum number of G2 reviews to extract per product |
| `proxyConfiguration` | object | Optional | Apify proxy config — residential proxy recommended for reliable G2 access |

> **Tip:** You can enter products in three ways: a product name (`"notion"`), a G2 slug (`"notion-2"`), or a full G2 review URL. All three formats are handled automatically. Mix multiple products in the same run for batch extraction.

***

### 📋 Output Fields

Every record from this **G2 reviews scraper** includes both review-level and product-level data:

#### 📝 Review Fields

| Field | Type | Description | Example |
|---|---|---|---|
| `title` | string | Review headline | `"Best project management tool we've used"` |
| `review_body` | string | Full review text (max 2000 chars) | `"We switched from Asana last year and..."` |
| `rating` | string | Star rating for this review | `"5"` |
| `pros` | string | What the reviewer liked best | `"Incredibly flexible, great templates..."` |
| `cons` | string | What the reviewer disliked | `"Mobile app could be improved..."` |
| `review_date` | string | Review posting date | `"2024-03-10"` |
| `helpful_count` | integer | Number of helpful votes on this review | `14` |

#### 👤 Reviewer Fields

| Field | Type | Description | Example |
|---|---|---|---|
| `reviewer_name` | string | Reviewer display name | `"Sarah T."` |
| `reviewer_job` | string | Reviewer's job title | `"Product Manager"`, `"CTO"` |

#### 🏢 Product Fields *(included in every review record)*

| Field | Type | Description | Example |
|---|---|---|---|
| `product_name` | string | Software product name from G2 | `"Notion"` |
| `product_slug` | string | G2 URL slug identifier | `"notion"` |
| `overall_rating` | string | Product's overall G2 rating | `"4.7"` |
| `total_reviews` | string | Total number of G2 reviews for this product | `"5,842"` |
| `product_url` | string | Direct G2 review page URL | `"https://www.g2.com/products/notion/reviews"` |

***

### 📦 Example Input & Output

**Input:**

```json
{
  "products":    ["notion"],
  "max_reviews": 3
}
```

**Output (one record):**

```json
{
  "title":          "Best project management tool we have used",
  "review_body":    "We switched from Asana last year and the flexibility Notion offers is unmatched. Our entire team adopted it within two weeks.",
  "rating":         "5",
  "pros":           "Incredibly flexible, great template library, excellent for documentation and project tracking.",
  "cons":           "Mobile app could be improved — sometimes slow to load on older devices.",
  "reviewer_name":  "Sarah T.",
  "reviewer_job":   "Product Manager",
  "review_date":    "2024-03-10",
  "helpful_count":  14,
  "product_name":   "Notion",
  "product_slug":   "notion",
  "overall_rating": "4.7",
  "total_reviews":  "5,842",
  "product_url":    "https://www.g2.com/products/notion/reviews"
}
```

***

### 💰 Pricing & Free Trial

| Plan | Price | Includes |
|---|---|---|
| **Free Trial** | $0 | 2 hours full access — no credit card required |
| **Monthly** | $9.99 / month | Unlimited runs, any G2 product, multi-product batch |

#### Everything included in every plan:

- ✅ Full G2 software reviews — title, body, pros, cons, rating, date
- ✅ Reviewer name and job title per review
- ✅ Helpful vote count per review
- ✅ Product metadata in every record — name, overall rating, total reviews
- ✅ Multi-product batch — scrape multiple G2 products in one run
- ✅ Cloudflare bypass — built-in, no extra configuration needed
- ✅ Automatic pagination across multiple G2 review pages
- ✅ JSON + CSV + Excel export from Apify dataset
- ✅ Scheduled runs for automated reputation monitoring

> **Start your 2-hour free trial now** — no credit card needed. Click **Try for free** at the top of this page.

***

### ⚡ Performance & Limits

| Mode | Reviews | Estimated Time |
|---|---|---|
| Single product | 20 | ~2–4 minutes |
| Single product | 100 | ~8–15 minutes |
| Multi-product batch | 3 products × 20 | ~8–12 minutes |
| Large batch | 5 products × 50 | ~25–40 minutes |

- Results pushed to the Apify dataset in real time as each product page is processed
- Cloudflare challenge resolution is handled automatically — no manual steps needed
- Automatic pagination across multiple G2 review pages up to `max_reviews`
- Between products, automatic delays prevent rate limiting
- Residential proxy strongly recommended for consistent Cloudflare bypass at all volumes

***

### ❓ FAQ

**Q: How do I specify which G2 product to scrape?**
A: Enter the product in any of three formats in the `products` array: a product name (`"salesforce"`), a G2 slug (`"salesforce-crm"`), or a full G2 review URL (`"https://www.g2.com/products/salesforce-crm/reviews"`). All three are handled automatically.

**Q: Can I scrape multiple G2 products in one run?**
A: Yes. Add multiple product names, slugs, or URLs to the `products` array and the actor processes them all in sequence — with automatic delays between products to prevent rate limiting.

**Q: What is the difference between `review_body`, `pros`, and `cons`?**
A: G2 asks reviewers three separate questions. `pros` is the answer to "What do you like best?", `cons` is "What do you dislike?", and `review_body` contains the full combined review text. All three fields are extracted and returned separately.

**Q: Does this actor handle G2's Cloudflare protection?**
A: Yes. Cloudflare challenge resolution is built into the actor — no extra configuration needed. Residential proxy is recommended for the most reliable bypass at higher volumes.

**Q: Does every review record include the product's overall G2 rating?**
A: Yes. `product_name`, `overall_rating`, `total_reviews`, `product_slug`, and `product_url` are included in every single review record — so you can always identify which product a review belongs to, even in large multi-product exports.

**Q: Can I monitor a product's new reviews on a schedule?**
A: Yes. Set up an Apify scheduled task to run this **G2 reviews scraper** on a daily or weekly basis for any product. New reviews will appear in each run's output automatically.

**Q: Why is `reviewer_job` null for some reviews?**
A: Not all G2 reviewers fill in their job title when submitting a review. When the field is not present on the page, it returns `null`.

**Q: Can I export results to Excel or CSV?**
A: Yes. All results are pushed to the Apify dataset, which can be exported to JSON, CSV, Excel, and more directly from the Apify Console after each run.

***

### 📜 Changelog

#### v13.0.0 (Current)

- ✅ Full G2 software reviews extraction — title, body, pros, cons, rating, date
- ✅ Reviewer name and job title per review
- ✅ Helpful vote count per review
- ✅ Product metadata in every record — name, overall rating, total review count
- ✅ Cloudflare bypass — built-in, automatic
- ✅ Multi-product batch support — any number of products per run
- ✅ Automatic multi-page pagination up to `max_reviews`
- ✅ Accepts product name, G2 slug, or full G2 URL as input
- ✅ JSON-LD fallback extraction for maximum reliability
- ✅ Automatic delay between products to prevent rate limiting
- ✅ Real-time dataset push as each product is processed

#### v1.0.0

- Initial release with basic G2 review text and rating extraction

***

### 🏷️ Tags

`g2 reviews scraper` `g2 software reviews` `g2 scraper` `software review data` `g2 review extractor` `saas reviews` `g2 product data` `software reviews dataset` `g2 competitor analysis` `review monitoring` `g2 data extraction` `software feedback data`

***

### ⚖️ Legal & Terms of Use

This actor accesses publicly visible customer review data on G2.com in the same way a regular user browses the platform.

**Please note:**

- Use extracted **G2 software reviews** only for **lawful purposes** — reputation monitoring, market research, competitive analysis, NLP research, and academic study are common legitimate uses
- Do not use scraped G2 reviews to misrepresent, defame, or create misleading content about any software product or company
- G2 review content belongs to the original reviewers — do not republish reviews as your own content or without appropriate attribution
- Respect G2's Terms of Service — do not use this tool at volumes designed to overload platform infrastructure
- The actor developer is not responsible for how extracted review data is used

***

### 🤝 Support & Feedback

- **Bug report?** Contact us via the Apify actor page
- **Feature request?** Post in the Apify Community forum
- **Loving it?** Please leave a ⭐ review — it helps other users find this actor!

***

<p align="center">
  <strong>Built with ❤️ on Apify</strong><br/>
  <em>The most reliable G2 Reviews Scraper — full G2 software reviews, pros & cons, reviewer job titles</em><br/><br/>
  <strong>💰 $9.99/month · 🆓 2-hour free trial · No credit card required</strong>
</p>

# Actor input Schema

## `products` (type: `string`):

G2 product names or URLs — one per line. Example: salesforce, slack, notion

## `max_reviews` (type: `integer`):

Maximum number of reviews to scrape per product (1–100)

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

Optional. This actor uses curl\_cffi which bypasses Cloudflare without proxy. Only enable if you experience issues.

## Actor input object example

```json
{
  "products": "slack\nhubspot\nnotion",
  "max_reviews": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "products": `slack
hubspot
notion`,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapepilot/g2-reviews-scraper----software-reviews-product-data").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 = {
    "products": """slack
hubspot
notion""",
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("scrapepilot/g2-reviews-scraper----software-reviews-product-data").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 '{
  "products": "slack\\nhubspot\\nnotion",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call scrapepilot/g2-reviews-scraper----software-reviews-product-data --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "G2 Reviews Scraper — Software Reviews & Product Data",
        "description": "Scrape G2 software reviews from any product page. Get review title, full text, pros & cons, star rating, reviewer name, job title, date, and helpful votes. Cloudflare bypass built-in. Multi-product batch. No login. $9.99/month. 2-hour free trial.",
        "version": "0.0",
        "x-build-id": "boDH0ICd5Dtn0AsHb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapepilot~g2-reviews-scraper----software-reviews-product-data/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapepilot-g2-reviews-scraper----software-reviews-product-data",
                "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/scrapepilot~g2-reviews-scraper----software-reviews-product-data/runs": {
            "post": {
                "operationId": "runs-sync-scrapepilot-g2-reviews-scraper----software-reviews-product-data",
                "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/scrapepilot~g2-reviews-scraper----software-reviews-product-data/run-sync": {
            "post": {
                "operationId": "run-sync-scrapepilot-g2-reviews-scraper----software-reviews-product-data",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "products"
                ],
                "properties": {
                    "products": {
                        "title": "Products",
                        "type": "string",
                        "description": "G2 product names or URLs — one per line. Example: salesforce, slack, notion"
                    },
                    "max_reviews": {
                        "title": "Max Reviews Per Product",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per product (1–100)",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration (Optional)",
                        "type": "object",
                        "description": "Optional. This actor uses curl_cffi which bypasses Cloudflare without proxy. Only enable if you experience issues."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```