# G2 Reviews Scraper (`happitap/g2-reviews-scraper`) Actor

Extract product reviews and customer feedback from G2.com including ratings, reviewer details, company information, and detailed review content. Download G2 reviews in JSON, CSV, or Excel format.

- **URL**: https://apify.com/happitap/g2-reviews-scraper.md
- **Developed by:** [HappiTap](https://apify.com/happitap) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

**Extract product reviews and customer feedback from G2.com including ratings, reviewer details, company information, and detailed review content. Download G2 reviews in JSON, CSV, or Excel format.**

The G2 Reviews Scraper is your **G2 API alternative** that lets you extract unlimited software reviews with complete details. Perfect for competitive analysis, product research, customer sentiment analysis, and market intelligence.

### What can G2 Reviews Scraper do?

- ✅ **Extract complete reviews** - review content, ratings, titles, and publish dates
- ✅ **Get reviewer information** - names, job titles, company sizes, and profile links
- ✅ **Detailed Q&A data** - question-answer pairs from G2's review questionnaire
- ✅ **Multiple products** - scrape reviews from multiple software products at once
- ✅ **Filter by rating** - extract only reviews with minimum star ratings
- ✅ **Sort options** - most recent, highest rated, lowest rated, or most helpful
- ✅ **Video reviews** - extract links to video reviews when available
- ✅ **Export in any format** - JSON, CSV, Excel, HTML, or RSS feed
- ✅ **API access** - integrate scraped data into your applications
- ✅ **No coding required** - simple point-and-click interface

### Why scrape G2 reviews?

[G2.com](https://www.g2.com) contains millions of software reviews with valuable insights for:

- 🎯 **Competitive analysis** - Understand what customers say about competitors
- 📊 **Product research** - Analyze feature requests and pain points
- 💬 **Sentiment analysis** - Track customer satisfaction trends over time
- 🔍 **Market intelligence** - Identify market gaps and opportunities
- 📈 **Sales enablement** - Use customer testimonials in marketing materials
- 🏆 **Product improvement** - Learn from user feedback and reviews
- 📝 **Content creation** - Generate case studies and success stories

### What data can you extract from G2 reviews?

The scraper extracts comprehensive review information:

| Data Field | Description | Example |
|------------|-------------|---------|
| **Product Name** | Software product name | "Slack" |
| **Review Title** | Review headline | "Great team collaboration tool" |
| **Review Content** | Full review text | "We've been using Slack for 2 years..." |
| **Review Rating** | Star rating (1-5) | 4.5 |
| **Publish Date** | When review was posted | "2024-01-15" |
| **Reviewer Name** | Name of reviewer | "John Smith" |
| **Job Title** | Reviewer's position | "Product Manager" |
| **Company Size** | Size of reviewer's company | "51-200 employees" |
| **Reviewer Link** | Link to reviewer profile | G2 profile URL |
| **Question Answers** | Q&A pairs from review | Array of questions and answers |
| **Video Link** | Video review URL (if any) | YouTube/Vimeo link |
| **Review Link** | Direct link to review | Full G2 review URL |

### How to scrape G2 reviews

1. **Click "Try for free"** to start using the scraper
2. **Enter product information** - Paste G2 product URLs or enter product names (e.g., "slack", "hubspot")
3. **Configure options** - Set max reviews, rating filters, and sort preferences
4. **Start the scraper** - Click "Start" and let it run
5. **Download results** - Export your data as JSON, CSV, Excel, or via API

The scraper automatically extracts all available review data from each product's review page.

### Input

The scraper has a simple input interface. Click on the **Input** tab above to see all available options.

**Key settings:**

- **Product URLs** - List of G2 product review URLs to scrape
- **Product Names** - Alternative: Enter product names/slugs (e.g., "slack", "salesforce")
- **Max Reviews Per Product** - Limit number of reviews to extract (default: 200, max: 1000)
- **Minimum Rating** - Filter reviews by minimum star rating (1-5)
- **Include Question Answers** - Extract detailed Q&A pairs (default: yes)
- **Sort By** - Order reviews: most recent, highest rated, lowest rated, most helpful
- **Proxy Configuration** - Use residential proxies for best results

All fields have helpful tooltips. For advanced options, check the Input tab.

### Output

You can download your scraped data in multiple formats:

- **JSON** - For developers and API integrations
- **CSV** - For Excel and data analysis
- **Excel** - Ready-to-use spreadsheet
- **HTML** - For viewing in browser
- **RSS** - For feed readers

#### Output example

Here's what the data looks like for a single review:

```json
{
  "productName": "slack",
  "productUrl": "https://www.g2.com/products/slack/reviews",
  "reviewId": "review-123456",
  "reviewTitle": "Excellent team collaboration platform",
  "reviewContent": "We've been using Slack for 2 years and it has transformed our team communication. The integrations are fantastic and the search functionality is powerful.",
  "reviewRating": 4.5,
  "publishDate": "2024-01-15",
  "reviewerName": "John Smith",
  "reviewerJobTitle": "Product Manager",
  "reviewerLink": "https://www.g2.com/users/john-smith",
  "reviewerCompanySize": "51-200 employees",
  "reviewQuestionAnswers": [
    {
      "question": "What do you like best about Slack?",
      "answer": "The ease of use and extensive integrations with other tools."
    },
    {
      "question": "What do you dislike about Slack?",
      "answer": "Can get overwhelming with too many channels."
    }
  ],
  "videoLink": null,
  "reviewLink": "https://www.g2.com/products/slack/reviews/review-123456",
  "scrapedAt": "2024-01-25T12:00:00.000Z"
}
````

### How much does it cost to scrape G2 reviews?

G2 review scraping on Apify uses a **pay-per-result** model. You only pay for reviews you successfully extract.

**Free tier**: New Apify users get **$5 in free credits** - enough to scrape approximately **2,500 G2 reviews** for free!

**Cost estimates**:

- **Per review**: $0.002 ($2 per 1,000 reviews)
- **100 reviews** = $0.20
- **500 reviews** = $1.00
- **1,000 reviews** = $2.00
- **10,000 reviews** = $20.00

**Pricing breakdown:**

- Actor start: $0.00005 (one-time per run)
- Per review: $0.002 ($2 per 1,000 reviews)

**Tips to reduce costs:**

- Set `maxReviewsPerProduct` to limit results
- Use `minRating` filter to get only high-quality reviews
- Disable `includeQuestionAnswers` if not needed
- Process multiple products in one run

The scraper is highly optimized and uses minimal compute resources, making it one of the most cost-effective G2 scrapers available.

### Is it legal to scrape G2 reviews?

Yes, scraping publicly available data from G2 is legal in most jurisdictions. This scraper only extracts **publicly visible information** that anyone can see without logging in - product reviews, ratings, and reviewer information.

**What we extract:**

- ✅ Public product reviews
- ✅ Star ratings and review content
- ✅ Reviewer names and job titles (publicly listed)
- ✅ Company information from reviews
- ✅ Public Q\&A responses

**What we DON'T extract:**

- ❌ Private user data
- ❌ Login-required information
- ❌ Personal data not publicly displayed

**Best practices:**

- Use scraped data ethically and responsibly
- Respect G2's rate limits (use appropriate concurrency)
- Don't use data for spam or harassment
- Review G2's Terms of Service for your specific use case

For commercial use at scale, you may want to review G2's official API options. However, the API has strict rate limits and can be expensive for large datasets. This scraper provides a cost-effective alternative for research and analysis purposes.

Learn more about the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### Troubleshooting

#### No results or empty dataset?

- Verify that your URLs are valid G2 product review pages (should contain `/products/[name]/reviews`)
- Check that the product has reviews on G2
- Look for "✅ SAVED" messages in the log to confirm data is being extracted
- Enable `debugMode` to save HTML for inspection

#### Getting blocked or rate limited?

- Use **residential proxies** in proxy configuration (recommended)
- Reduce `maxConcurrency` to 3-5 for safer scraping
- G2 may block datacenter IPs - residential proxies work best
- Add delays between requests

#### Missing data fields?

- Some reviews may not have all fields (e.g., no video link, no job title)
- Older reviews may have limited data
- Question-answer pairs depend on review format
- Check the `includeQuestionAnswers` setting

#### Scraper running slow?

- Reduce `maxReviewsPerProduct` for faster runs
- Disable `includeQuestionAnswers` (reduces processing time)
- Increase `maxConcurrency` to 10-15 (if not getting blocked)
- Use faster proxy groups

#### Reviews not matching filters?

- Verify `minRating` is set correctly (1-5)
- Check that `sortBy` option is working as expected
- Some filters may not be available for all products

### Use cases

#### Competitive Intelligence

Extract competitor reviews to understand their strengths and weaknesses. Analyze customer complaints, feature requests, and satisfaction levels to inform your product strategy.

#### Product Research & Development

Identify common pain points and feature requests from real users. Use review data to prioritize your product roadmap and validate new feature ideas.

#### Customer Sentiment Analysis

Track sentiment trends over time by regularly scraping reviews. Build dashboards to monitor customer satisfaction and identify emerging issues.

#### Sales & Marketing

Collect positive reviews and testimonials for marketing materials. Understand buyer personas and decision-making criteria from reviewer profiles.

#### Market Intelligence

Analyze review patterns across multiple products in your category. Identify market gaps, emerging trends, and customer preferences.

#### Content Creation

Generate case studies and success stories from detailed reviews. Use customer quotes and feedback in blog posts and whitepapers.

### G2 API alternative

The official G2 API has significant limitations:

**G2 API limitations:**

- ❌ **Strict rate limits** - Limited requests per day
- ❌ **Expensive** - Costly for large datasets
- ❌ **Limited data** - Not all review fields available
- ❌ **Application required** - Must apply and get approved
- ❌ **Commercial restrictions** - Usage limitations

**This scraper offers:**

- ✅ **Unlimited reviews** - No API quotas or limits
- ✅ **Cost-effective** - $2 per 1,000 reviews
- ✅ **Complete data** - All publicly visible information
- ✅ **Immediate access** - No application or approval needed
- ✅ **Flexible** - Scrape any product, anytime
- ✅ **Easy to use** - No API keys or complex setup

### Integrations

Connect your scraped G2 data with 1000+ apps:

- **Google Sheets** - Auto-update spreadsheets with new reviews
- **Slack** - Get notifications when scraping completes
- **Webhooks** - Send data to your own applications
- **Make/Zapier** - Automate workflows with scraped data
- **API** - Access data programmatically via REST API
- **Airtable** - Build review databases
- **Excel** - Export directly to Excel format
- **Tableau** - Create review analytics dashboards

Learn more about [Apify integrations](https://apify.com/integrations).

### Support and feedback

- 📧 **Issues?** Use the **Issues** tab above to report bugs
- 💬 **Questions?** Check the troubleshooting section first
- 🔧 **Custom solution?** Contact us for tailored scraping needs
- ⭐ **Feedback?** We're always improving - let us know what you need!
- 📚 **Documentation** - [Apify Documentation](https://docs.apify.com)

### Related Actors

Looking for more review scraping tools? Check out these Actors:

- **Trustpilot Reviews Scraper** - Extract reviews from Trustpilot
- **Capterra Reviews Scraper** - Scrape software reviews from Capterra
- **Yelp Reviews Scraper** - Extract business reviews from Yelp
- **Amazon Reviews Scraper** - Scrape product reviews from Amazon
- **Google Reviews Scraper** - Extract Google Business reviews

Browse all [Review Scrapers](https://apify.com/store?category=reviews).

***

**License**: Apache-2.0 | **Version**: 1.0.0 | **Last updated**: January 2024

**Disclaimer**: This scraper is for educational and research purposes. Always review and comply with G2's Terms of Service and applicable laws in your jurisdiction.

# Actor input Schema

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

List of G2 product URLs to scrape reviews from (e.g., https://www.g2.com/products/slack/reviews)

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

Alternative: List of product names/slugs (e.g., 'slack', 'hubspot', 'salesforce'). Will be converted to URLs.

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

Maximum number of reviews to scrape per product

## `minRating` (type: `integer`):

Filter reviews by minimum rating (1-5 stars). Leave empty for all ratings.

## `includeQuestionAnswers` (type: `boolean`):

Extract detailed question-answer pairs from reviews

## `sortBy` (type: `string`):

How to sort the reviews

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

Proxy settings for requests. Residential proxies recommended.

## `maxConcurrency` (type: `integer`):

Maximum number of concurrent requests

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

Enable debug logging and save HTML for troubleshooting

## Actor input object example

```json
{
  "productUrls": [
    {
      "url": "https://www.g2.com/products/slack/reviews"
    }
  ],
  "productNames": [
    "slack"
  ],
  "maxReviewsPerProduct": 200,
  "includeQuestionAnswers": true,
  "sortBy": "most_recent",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 5,
  "debugMode": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset containing extracted G2 product reviews

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "productUrls": [
        {
            "url": "https://www.g2.com/products/slack/reviews"
        }
    ],
    "productNames": [
        "slack"
    ],
    "maxReviewsPerProduct": 200,
    "includeQuestionAnswers": true,
    "sortBy": "most_recent",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    },
    "maxConcurrency": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("happitap/g2-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 = {
    "productUrls": [{ "url": "https://www.g2.com/products/slack/reviews" }],
    "productNames": ["slack"],
    "maxReviewsPerProduct": 200,
    "includeQuestionAnswers": True,
    "sortBy": "most_recent",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
    "maxConcurrency": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("happitap/g2-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 '{
  "productUrls": [
    {
      "url": "https://www.g2.com/products/slack/reviews"
    }
  ],
  "productNames": [
    "slack"
  ],
  "maxReviewsPerProduct": 200,
  "includeQuestionAnswers": true,
  "sortBy": "most_recent",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 5
}' |
apify call happitap/g2-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "G2 Reviews Scraper",
        "description": "Extract product reviews and customer feedback from G2.com including ratings, reviewer details, company information, and detailed review content. Download G2 reviews in JSON, CSV, or Excel format.",
        "version": "0.0",
        "x-build-id": "s4W9lj1dPOsNlL7NH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/happitap~g2-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-happitap-g2-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/happitap~g2-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-happitap-g2-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/happitap~g2-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-happitap-g2-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": {
                    "productUrls": {
                        "title": "Product URLs",
                        "type": "array",
                        "description": "List of G2 product URLs to scrape reviews from (e.g., https://www.g2.com/products/slack/reviews)",
                        "default": [],
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "productNames": {
                        "title": "Product Names",
                        "type": "array",
                        "description": "Alternative: List of product names/slugs (e.g., 'slack', 'hubspot', 'salesforce'). Will be converted to URLs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max Reviews Per Product",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per product",
                        "default": 200
                    },
                    "minRating": {
                        "title": "Minimum Rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Filter reviews by minimum rating (1-5 stars). Leave empty for all ratings."
                    },
                    "includeQuestionAnswers": {
                        "title": "Include Question Answers",
                        "type": "boolean",
                        "description": "Extract detailed question-answer pairs from reviews",
                        "default": true
                    },
                    "sortBy": {
                        "title": "Sort Reviews By",
                        "enum": [
                            "most_recent",
                            "highest_rated",
                            "lowest_rated",
                            "most_helpful"
                        ],
                        "type": "string",
                        "description": "How to sort the reviews",
                        "default": "most_recent"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings for requests. Residential proxies recommended.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "maxConcurrency": {
                        "title": "Max Concurrency",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum number of concurrent requests",
                        "default": 5
                    },
                    "debugMode": {
                        "title": "Debug Mode",
                        "type": "boolean",
                        "description": "Enable debug logging and save HTML 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
