# G2 & Capterra Reviews Scraper — Software Reviews API (`bikram07/capterra-g2-reviews`) Actor

Scrape software product reviews from Capterra. Filter by product URL, sort order, minimum star rating and max review count. Alert mode outputs only reviews not seen in previous runs — perfect for scheduled reputation monitoring. Pay-per-event: $1 per 1,000 review records.

- **URL**: https://apify.com/bikram07/capterra-g2-reviews.md
- **Developed by:** [Bikram](https://apify.com/bikram07) (community)
- **Categories:** Marketing, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

## 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 & Capterra Reviews Scraper — Software Reviews API

Extract software product reviews from **Capterra** without maintaining a scraper, building an auth flow, or paying for a third-party reviews API. This Actor fetches review cards directly from Capterra's HTML (via requests + BeautifulSoup), normalizes each review into a flat JSON record, and streams results to the Apify dataset — ready for spreadsheets, CRMs, dashboards, or AI agents.

Turn on **alert mode** and run it on an Apify Schedule to monitor any product for new reviews automatically — reputation monitoring and competitive intelligence without a SaaS subscription.

### Features

- **Flat, normalized output** — every review is one clean JSON record with stable field names: reviewer name, job title, company size, star rating, pros, cons, date, verified status, and helpful votes.
- **Multi-product bulk scraping** — pass a list of product URLs to scrape several products in a single run.
- **Sort control** — fetch by most recent or most helpful, so you always see the freshest signal first.
- **Star rating filter** — set `minRating: 4` to collect only positive reviews, or `minRating: 1` with `maxReviews: 5` to sample the harshest critics.
- **Review alerts (dedupe built in)** — alert mode remembers which review IDs it already output for each product and emits only new ones on subsequent runs.
- **Fair pay-per-event pricing** — $1 per 1,000 reviews. Skipped duplicates (alert mode) and filtered-out reviews are never charged.
- **MCP-ready** — callable as a tool from Claude, Cursor, or any MCP client via Apify's MCP server.

### Input parameters

```json
{
    "productUrl": "https://www.capterra.com/p/7866/Zendesk/",
    "maxReviews": 100,
    "sortBy": "most_recent",
    "minRating": 3,
    "alertMode": false
}
````

| Field | Type | Default | Description |
|---|---|---|---|
| `productUrl` | string | — | Capterra product URL. Accepted formats: `https://www.capterra.com/p/7866/Zendesk/` or `/reviews/7866/Zendesk`. Either this or `productUrls` is required. |
| `productUrls` | array | — | List of Capterra product URLs for bulk scraping. Combined with `productUrl` if both supplied. |
| `maxReviews` | integer | `100` | Maximum reviews to collect per product (1–5,000). |
| `sortBy` | string | `most_recent` | Review sort order: `most_recent` or `most_helpful`. |
| `minRating` | integer | — | Only output reviews with an overall rating ≥ this value (1–5). |
| `alertMode` | boolean | `false` | Output only reviews not seen in previous runs for each product. |

Finding the right product URL: open any software listing on Capterra (e.g. `capterra.com/p/7866/Zendesk/`) and paste the URL directly into `productUrl`. The Actor resolves both the legacy `/p/<id>/` format and the newer `/reviews/<id>/` format.

### Output example

Each review becomes one dataset item. Fields not available on the Capterra page for a given review are `null` — never guessed.

```json
{
    "reviewId": "capterra-2345678",
    "source": "capterra",
    "productName": "Zendesk",
    "productUrl": "https://www.capterra.com/p/7866/Zendesk/reviews/",
    "reviewerName": "Sarah M.",
    "reviewerTitle": "Customer Support Manager",
    "reviewerCompanySize": "51-200 employees",
    "rating": 4.5,
    "reviewTitle": "Scales well once you learn the configuration quirks",
    "pros": "Ticket routing and macro system are genuinely powerful once set up. The reporting dashboard gives our team clear visibility into SLA compliance without custom work.",
    "cons": "Onboarding took longer than expected. Some integrations require workarounds that feel like they should be native. Support tier pricing adds up fast at mid-size.",
    "overallSummary": "Strong platform for growing support teams willing to invest setup time. Would recommend with an implementation partner for teams over 30 agents.",
    "date": "2026-04-22",
    "verifiedPurchase": true,
    "helpfulCount": 14,
    "url": "https://www.capterra.com/p/7866/Zendesk/reviews/"
}
```

Field notes:

- `reviewId` is a stable Capterra review identifier prefixed with `capterra-`. Use it as a deduplication key in your own pipelines.
- `rating` is the reviewer's overall star rating (1.0–5.0). Sub-ratings (ease-of-use, customer service, etc.) are not included in the current version.
- `verifiedPurchase` is `true` when Capterra marks the reviewer as a verified product user.
- `helpfulCount` is the number of "helpful" votes the review received; `null` when Capterra does not display this count.
- `pros`, `cons`, and `overallSummary` are the reviewer's own words from the corresponding sections of the Capterra review form. Fields absent from the review are `null`.

### Review alerts: alert mode + Apify Schedules

1. Set `productUrl` (or `productUrls`) and `alertMode: true`.
2. Create an [Apify Schedule](https://docs.apify.com/platform/schedules) that runs the Actor daily or weekly.
3. Each run outputs **only reviews that previous runs have not yet output** — the dataset of every run is purely "what's new since last time".
4. Add an integration (email, Slack, webhook, Make/Zapier) on the Actor run to route new reviews to wherever your team works.

How it works: seen review IDs are stored in a named key-value store (`capterra-seen-<hash>`), one per product. Changing `maxReviews` or `sortBy` does not reset the history; only the product URL matters. IDs are remembered for 400 days. A run that finds no new reviews still succeeds — a normal alert outcome — and charges nothing.

### Pricing — $1 per 1,000 reviews

This Actor uses Apify's **pay-per-event** model with one simple event:

| Event | Price | When it's charged |
|---|---|---|
| `review-record` | $0.001 | Once per review record written to the dataset |

That is **$1 per 1,000 reviews**. You are never charged for a record that wasn't written: alert-mode duplicates are skipped for free, and reviews filtered by `minRating` are never charged. You can set a maximum cost per run in Apify Console; the Actor stops gracefully when the limit is reached without marking unpushed reviews as seen, so they appear in the next run.

### Proxy note

Capterra is protected by Cloudflare. The Actor uses Apify's built-in proxy infrastructure (residential or datacenter proxies) to bypass Cloudflare automatically when run via Apify Console. If you run the Actor locally without a configured proxy, requests will be blocked and the Actor will exit with a clear error message explaining the cause. No records are charged and no silent empty results are returned.

### Use from Claude, Cursor & other AI agents (MCP)

This Actor works as a tool over the [Model Context Protocol](https://mcp.apify.com). Add Apify's MCP server to your client and your agent can pull software reviews on demand:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/sse?actors=bikram07/capterra-g2-reviews",
            "headers": {
                "Authorization": "Bearer YOUR_APIFY_TOKEN"
            }
        }
    }
}
```

Then ask your agent things like: *"Pull the 50 most recent Zendesk reviews from Capterra, summarize the top three complaints, and compare them with HubSpot's most recent 50 reviews"* — the agent calls this Actor twice (once per product), gets normalized records back, and analyses them directly.

You can also call it from code via the [Apify API](https://docs.apify.com/api/v2):

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/bikram07~capterra-g2-reviews/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "productUrl": "https://www.capterra.com/p/7866/Zendesk/",
    "maxReviews": 50,
    "sortBy": "most_recent"
  }'
```

### Use cases

**Competitive intelligence**
Monitor a competitor's Capterra page weekly. Alert mode delivers a diff of new reviews every run — pipe them into a Slack channel or a shared doc to keep your product and sales teams current without manually refreshing browser tabs.

**Product research & buyer enablement**
Pull all 4-star and above reviews for shortlisted tools before a procurement decision. Export to CSV and let your team read actual user language rather than vendor-curated case studies.

**Reputation monitoring**
Track your own product's reviews in real time. When a new negative review appears, alert mode surfaces it within 24 hours so support or product can respond before it compounds. Pipe new reviews into a CRM or Zendesk ticket automatically via Make or Zapier.

**Voice-of-customer (VoC) analysis**
Collect the pros and cons sections across 500+ reviews and run them through an LLM to extract recurring themes, feature requests, and friction points — structured product intelligence from unstructured review text.

**Sales enablement**
Build objection-handling content by analysing what buyers say is missing in competitor reviews. The `cons` field across a competitor's recent reviews is a direct signal of unmet needs your product can address.

### FAQ

**Can I scrape multiple products at once?**
Yes. Pass a list of URLs to `productUrls`. The Actor processes each product in sequence and combines all reviews into one dataset. Alert mode tracks seen IDs independently per product, so histories never bleed across products.

**What fields are available in the output?**
`reviewId`, `source`, `productName`, `productUrl`, `reviewerName`, `reviewerTitle`, `reviewerCompanySize`, `rating`, `reviewTitle`, `pros`, `cons`, `overallSummary`, `date`, `verifiedPurchase`, `helpfulCount`, `url`. Fields not present on a given review card are `null` — never filled with guesses.

**How fresh is the data?**
The Actor fetches reviews live from Capterra's HTML at run time — there is no cache or database in between. For monitoring purposes a daily schedule with `alertMode: true` and `sortBy: most_recent` delivers new reviews within ~24 hours of when they appear on Capterra.

**What is the maximum number of reviews I can collect?**
Up to 5,000 reviews per product per run. For most products Capterra shows hundreds to a few thousand reviews; `maxReviews: 5000` will collect everything available.

**Does it require a Capterra account or API key?**
No. The Actor reads publicly visible review pages — the same pages any visitor sees — without authentication.

**What happens if Capterra changes its HTML structure?**
The parser tries multiple CSS selector strategies in order of specificity. If all fail, the Actor logs a clear warning ("0 review cards found on page 1") and exits without pushing empty results or charging. Open a support request with the affected product URL and the issue will be diagnosed and fixed.

**Why does it need a proxy to run?**
Capterra uses Cloudflare to block requests that originate from datacenter IP ranges. Apify's residential proxy pool routes requests through real residential IPs that pass Cloudflare's checks. The proxy cost is included in Apify's platform fees — it is not an additional line item on your bill.

### Related searches

g2 reviews scraper · capterra reviews api · software reviews data · capterra scraper · competitive intelligence tool · review monitoring · b2b software reviews · saas reviews data · product review aggregator · capterra api alternative

***

Built with [requests](https://docs.python-requests.org/) and [BeautifulSoup4](https://www.crummy.com/software/BeautifulSoup/). Not affiliated with or endorsed by Capterra or Gartner Digital Markets. Review data belongs to the respective reviewers and Capterra; reuse is subject to Capterra's terms of service.

# Actor input Schema

## `productUrl` (type: `string`):

Capterra product URL or slug. Accepted formats:<br><b>https://www.capterra.com/p/7866/Zendesk/</b><br><b>https://www.capterra.com/reviews/7866/Zendesk</b><br><b>zendesk</b> (slug, used in search — actor resolves it to a product ID)<br><br>Either this field or <b>productUrls</b> is required.

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

List of Capterra product URLs for bulk scraping. Same format as <b>productUrl</b> — full URLs or slugs. Reviews for all listed products are combined into a single dataset.

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

Maximum number of reviews to scrape per product URL. Hard limit: 5,000.

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

Order in which reviews are fetched from Capterra.

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

Only output reviews with an overall rating equal to or above this value (1–5). Leave empty to include all ratings.

## `alertMode` (type: `boolean`):

When enabled, the Actor remembers which review IDs it has already output for each product URL (in a named key-value store) and outputs <b>only reviews it has not seen before</b>. Run it on an Apify Schedule to get a feed of new reviews over time. Only new reviews are charged.

## Actor input object example

```json
{
  "productUrl": "https://www.capterra.com/p/7866/Zendesk/",
  "maxReviews": 100,
  "sortBy": "most_recent",
  "alertMode": 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 = {
    "productUrl": "https://www.capterra.com/p/7866/Zendesk/"
};

// Run the Actor and wait for it to finish
const run = await client.actor("bikram07/capterra-g2-reviews").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 = { "productUrl": "https://www.capterra.com/p/7866/Zendesk/" }

# Run the Actor and wait for it to finish
run = client.actor("bikram07/capterra-g2-reviews").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 '{
  "productUrl": "https://www.capterra.com/p/7866/Zendesk/"
}' |
apify call bikram07/capterra-g2-reviews --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "G2 & Capterra Reviews Scraper — Software Reviews API",
        "description": "Scrape software product reviews from Capterra. Filter by product URL, sort order, minimum star rating and max review count. Alert mode outputs only reviews not seen in previous runs — perfect for scheduled reputation monitoring. Pay-per-event: $1 per 1,000 review records.",
        "version": "0.1",
        "x-build-id": "vtqlb2pW4BBUPxsfd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bikram07~capterra-g2-reviews/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bikram07-capterra-g2-reviews",
                "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/bikram07~capterra-g2-reviews/runs": {
            "post": {
                "operationId": "runs-sync-bikram07-capterra-g2-reviews",
                "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/bikram07~capterra-g2-reviews/run-sync": {
            "post": {
                "operationId": "run-sync-bikram07-capterra-g2-reviews",
                "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": {
                    "productUrl": {
                        "title": "Product URL or slug",
                        "type": "string",
                        "description": "Capterra product URL or slug. Accepted formats:<br><b>https://www.capterra.com/p/7866/Zendesk/</b><br><b>https://www.capterra.com/reviews/7866/Zendesk</b><br><b>zendesk</b> (slug, used in search — actor resolves it to a product ID)<br><br>Either this field or <b>productUrls</b> is required."
                    },
                    "productUrls": {
                        "title": "Product URLs (bulk)",
                        "type": "array",
                        "description": "List of Capterra product URLs for bulk scraping. Same format as <b>productUrl</b> — full URLs or slugs. Reviews for all listed products are combined into a single dataset.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxReviews": {
                        "title": "Max reviews per product",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of reviews to scrape per product URL. Hard limit: 5,000.",
                        "default": 100
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "most_recent",
                            "most_helpful"
                        ],
                        "type": "string",
                        "description": "Order in which reviews are fetched from Capterra.",
                        "default": "most_recent"
                    },
                    "minRating": {
                        "title": "Minimum star rating",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only output reviews with an overall rating equal to or above this value (1–5). Leave empty to include all ratings."
                    },
                    "alertMode": {
                        "title": "Alert mode (only new reviews)",
                        "type": "boolean",
                        "description": "When enabled, the Actor remembers which review IDs it has already output for each product URL (in a named key-value store) and outputs <b>only reviews it has not seen before</b>. Run it on an Apify Schedule to get a feed of new reviews over time. Only new reviews are charged.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```