# Capterra Reviews Scraper (`khadinakbar/capterra-reviews-scraper`) Actor

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

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

## Pricing

from $5.00 / 1,000 review scrapeds

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

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Capterra Reviews Scraper

Scrape **Capterra software reviews** and product metadata at scale — star ratings, full review text, pros, cons, reviewer firmographics, and vendor responses — by pasting a Capterra product URL or searching by product name. Browser-rendered to get past Capterra's enterprise Cloudflare protection. Built for AI agents and data teams: clean, flat JSON, MCP-ready.

### What you get

One dataset row per review (plus a product summary row per product):

| Field | Description |
|---|---|
| `productName` | Software product name |
| `productRating` | Aggregate product star rating (0–5) |
| `productReviewCount` | Total reviews Capterra reports |
| `vendor` / `category` | Vendor brand and Capterra application category |
| `rating` | This review's star rating (0–5) |
| `reviewTitle` | Review headline |
| `reviewBody` | Full review text |
| `pros` / `cons` | Reviewer-listed pros and cons |
| `subRatings` | Ease of use, customer support, value for money, features, likelihood to recommend |
| `reviewer` | Name, job title, company name, company size, industry, verified flag |
| `reviewDate` | Review publish date (ISO 8601) |
| `reviewUrl` | Direct link to the review when available |
| `helpfulCount` | How many users marked the review helpful |
| `vendorResponse` | Vendor's public reply, if any |

### When to use it

- **Competitive intelligence** — track how a competitor's product is rated, and what users praise or complain about.
- **Sales enablement** — pull objection themes and switching triggers before a call.
- **Product & market research** — mine pros/cons and sub-ratings across a category.
- **AI agents** — a single tool call returns structured Capterra sentiment for a named product.

Do **not** use this for G2, TrustRadius, SoftwareAdvice, or GetApp — for cross-platform coverage use the [Software Reviews All-in-One Scraper](https://apify.com/khadinakbar/software-reviews-all-in-one-scraper).

### Pricing (Pay Per Event)

| Event | Price |
|---|---|
| Actor start | $0.005 (scaled by GB of memory) |
| Review scraped | **$0.005 per review** |
| Product found (search mode) | $0.01 per product |

A run that scrapes 50 reviews of one product costs roughly **$0.27**. Pay-Per-Usage (compute + proxy) is also available — pick whichever is cheaper for your job at run time.

### Input

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

#### URL mode

```json
{
  "startUrls": [
    { "url": "https://www.capterra.com/p/135003/Slack/reviews/" }
  ],
  "maxReviewsPerProduct": 50,
  "sortReviewsBy": "newest"
}
````

#### Search mode

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

| Input | Type | Default | Notes |
|---|---|---|---|
| `startUrls` | array of `{url}` | — | Capterra product/reviews URLs |
| `searchQuery` | string | — | Product name or keyword |
| `maxReviewsPerProduct` | integer | 50 | 1–5000, per product |
| `maxProductsPerSearch` | integer | 5 | 1–100, search mode only |
| `includeReviews` | boolean | true | search mode: scrape reviews vs cards only |
| `sortReviewsBy` | enum | `newest` | `newest` or `helpful` |
| `proxyConfiguration` | object | Residential US | residential required |
| `debug` | boolean | false | write extraction diagnostics to KV |

### Output sample

```json
{
  "platform": "capterra",
  "recordType": "review",
  "productName": "Slack",
  "productRating": 4.7,
  "rating": 5,
  "reviewTitle": "Best team chat we've used",
  "reviewBody": "Channels keep our remote team organized...",
  "pros": ["Easy to onboard", "Great integrations"],
  "cons": ["Notifications can get noisy"],
  "reviewer": {
    "name": "Jane D.",
    "title": "Operations Manager",
    "companyName": "Acme Co",
    "companySize": "11-50 employees",
    "industry": "Marketing"
  },
  "reviewDate": "2025-04-01T00:00:00.000Z",
  "reviewUrl": "https://www.capterra.com/p/135003/Slack/reviews/",
  "scrapedAt": "2026-06-14T10:00:00.000Z"
}
```

### How to use

1. Open the Actor in Apify Console.
2. Paste one or more Capterra product URLs, or type a search query.
3. Set how many reviews per product you want.
4. Run. Download results as JSON, CSV, or Excel, or pull them via the Apify API.

#### API example

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

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("khadinakbar/capterra-reviews-scraper").call(run_input={
    "startUrls": [{"url": "https://www.capterra.com/p/135003/Slack/reviews/"}],
    "maxReviewsPerProduct": 50,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["rating"], item.get("reviewTitle"))
```

### MCP / AI agents

This Actor is MCP-ready. Connect via `https://mcp.apify.com` and call it as a tool: give it a Capterra product URL or a product name, get structured reviews back. Flat keys and a per-item token budget keep responses small enough to reason over.

### FAQ

**Why is it browser-based and not pure HTTP?** Capterra runs enterprise Cloudflare bot management. Plain HTTP requests return `403` from every datacenter and residential IP. Rendering in Firefox with a consistent fingerprint and residential proxy is the reliable path.

**Some reviews have no `reviewDate`.** Capterra renders per-review dates inconsistently across card layouts. The Actor extracts dates where present (JSON-LD or visible "Reviewed Month Year" text) and leaves the field absent otherwise rather than guessing.

**Can I get every review for a product?** Set `maxReviewsPerProduct` high (up to 5000). The Actor paginates until it reaches your cap or runs out of reviews.

**What if Capterra blocks the run?** If every request is blocked and zero records come back, the run fails honestly with a clear message — it never reports a silent empty success. Retry, or switch `proxyConfiguration.apifyProxyCountry`.

**International Capterra sites?** `capterra.co.uk`, `capterra.com.au`, etc. URLs are accepted in URL mode.

### Legal

This Actor collects only publicly available information from Capterra and is intended for lawful uses such as market research and competitive analysis. You are responsible for how you use the data, including compliance with Capterra's Terms of Use, applicable laws (e.g. GDPR/CCPA), and any rights in the content. Do not use scraped personal data for spam or unlawful profiling. Not affiliated with or endorsed by Capterra or Gartner.

# Actor input Schema

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

Capterra product or reviews URLs to scrape, one record per review returned. Each must look like https://www.capterra.com/p/{id}/{slug}/reviews/ (e.g. https://www.capterra.com/p/135003/Slack/reviews/); the /reviews/ suffix is optional and added automatically. Defaults to none — provide this OR searchQuery. NOT a Capterra category, search, or comparison URL.

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

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

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

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

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

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

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

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

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

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

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

Proxy used to reach Capterra. Residential proxies are required — Capterra runs enterprise Cloudflare and blocks datacenter IPs. Defaults to Apify Residential, US. Change the country if you target a regional Capterra TLD (e.g. capterra.co.uk).

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

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

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.capterra.com/p/135003/Slack/reviews/"
    }
  ],
  "searchQuery": "project management software",
  "maxReviewsPerProduct": 50,
  "maxProductsPerSearch": 5,
  "includeReviews": true,
  "sortReviewsBy": "newest",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  },
  "debug": false
}
```

# Actor output Schema

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

All scraped rows as JSON.

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

All scraped rows as CSV.

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

Console dataset view.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://www.capterra.com/p/135003/Slack/reviews/"
        }
    ],
    "maxReviewsPerProduct": 50,
    "maxProductsPerSearch": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/capterra-reviews-scraper").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://www.capterra.com/p/135003/Slack/reviews/" }],
    "maxReviewsPerProduct": 50,
    "maxProductsPerSearch": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/capterra-reviews-scraper").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://www.capterra.com/p/135003/Slack/reviews/"
    }
  ],
  "maxReviewsPerProduct": 50,
  "maxProductsPerSearch": 5
}' |
apify call khadinakbar/capterra-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Capterra Reviews Scraper",
        "description": "Scrape Capterra software reviews and product metadata: star ratings, written reviews, pros, cons, and reviewer firmographics. Paste a product URL or search by name. MCP-ready.",
        "version": "1.0",
        "x-build-id": "DHuVN0FL4OxvUlYn7"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~capterra-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-capterra-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/khadinakbar~capterra-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-capterra-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/khadinakbar~capterra-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-capterra-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "Capterra product URLs",
                        "type": "array",
                        "description": "Capterra product or reviews URLs to scrape, one record per review returned. Each must look like https://www.capterra.com/p/{id}/{slug}/reviews/ (e.g. https://www.capterra.com/p/135003/Slack/reviews/); the /reviews/ suffix is optional and added automatically. Defaults to none — provide this OR searchQuery. NOT a Capterra category, search, or comparison URL.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Product name or keyword to search on Capterra, then scrape the matching products' reviews. Free text, e.g. 'project management software' or 'Slack'. Defaults to empty — provide this OR startUrls. NOT a URL; paste URLs into startUrls instead."
                    },
                    "maxReviewsPerProduct": {
                        "title": "Max reviews per product",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Upper bound on how many reviews to extract for each product, newest or most-helpful first. Accepts 1–5000. Defaults to 50. This is per product, not a run-wide total — total cost scales with this times the number of products."
                    },
                    "maxProductsPerSearch": {
                        "title": "Max products per search",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "In search mode, how many matching products to take from the Capterra search results. Accepts 1–100. Defaults to 5. Ignored when you pass startUrls instead of a searchQuery."
                    },
                    "includeReviews": {
                        "title": "Scrape reviews in search mode",
                        "type": "boolean",
                        "description": "When true (default), search mode visits each matched product and scrapes its reviews. When false, search mode returns only product summary cards (name, rating, review count, URL) — cheaper for discovery. Has no effect in URL mode, which always scrapes reviews.",
                        "default": true
                    },
                    "sortReviewsBy": {
                        "title": "Sort reviews by",
                        "enum": [
                            "newest",
                            "helpful"
                        ],
                        "type": "string",
                        "description": "Order in which Capterra returns reviews before the per-product cap is applied. 'newest' fetches the most recent reviews first; 'helpful' fetches the most-upvoted first. Defaults to 'newest'. Affects which reviews you get when maxReviewsPerProduct is smaller than the total.",
                        "default": "newest"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy used to reach Capterra. Residential proxies are required — Capterra runs enterprise Cloudflare and blocks datacenter IPs. Defaults to Apify Residential, US. Change the country if you target a regional Capterra TLD (e.g. capterra.co.uk).",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    },
                    "debug": {
                        "title": "Debug mode",
                        "type": "boolean",
                        "description": "When true, writes a per-product diagnostic dump (JSON-LD nodes, selector hits, HTML head) to the key-value store for troubleshooting extraction. Defaults to false. Leave off for normal runs — it adds no review data and slightly slows the run.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```