# G2 Software Categories Scraper (`automation-lab/g2-software-categories-scraper`) Actor

Extract G2 software category names, URLs, parent categories, IDs, and hierarchy depth for SaaS market maps and competitor research.

- **URL**: https://apify.com/automation-lab/g2-software-categories-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## G2 Software Categories Scraper

Map the public G2 software category directory into clean dataset rows for SaaS market research, competitor mapping, sales planning, and category monitoring.

### What does G2 Software Categories Scraper do?

G2 Software Categories Scraper extracts structured records from public G2 category pages.

It is designed for the public directory at `https://www.g2.com/categories`.

The actor returns category names, category URLs, parent categories, hierarchy depth, G2 category IDs, source URL, and scrape timestamp.

When a supplied category listing page exposes product links in server-rendered HTML, the actor also emits best-effort product rows.

### Who is it for?

#### SaaS founders and product leaders

Use the scraper to map where your product category sits on G2, identify adjacent software markets, and find category pages that describe buyer intent in your niche.

#### Sales and revenue teams

Use category URLs as seed lists for account research, territory planning, partner discovery, and outbound segmentation by software market.

#### Marketing, SEO, and competitive intelligence teams

Monitor G2 category names, parent categories, and emerging software segments so your landing pages, comparison pages, and campaign language match how buyers research tools.

#### Analysts and data teams

Create repeatable software taxonomy snapshots that can be joined with CRM, vendor, keyword, product, or BI datasets without manually copying from G2.

### Why use this actor?

G2 categories change over time.

Manual copying is slow and error-prone.

This actor produces repeatable JSON, CSV, Excel, and API-ready data.

It is lightweight because it uses HTTP and HTML parsing for the public directory.

It avoids browser overhead for category-map jobs.

### What data can you extract?

| Field | Description |
| --- | --- |
| `recordType` | `category`, `popular_category`, or `product` |
| `categoryName` | Public G2 category name |
| `categorySlug` | URL slug from the G2 category URL |
| `categoryUrl` | Absolute G2 category URL |
| `parentCategory` | Parent category shown by G2 |
| `hierarchyLevel` | Directory nesting depth |
| `categoryId` | G2 category ID when present in page metadata |
| `isNested` | Whether the row is nested below another category |
| `productName` | Product name for best-effort product rows |
| `productUrl` | Product profile URL for best-effort product rows |
| `matchedSearchTerm` | Keyword that matched a filtered run |
| `sourceUrl` | Page that produced the record |
| `scrapedAt` | ISO scrape timestamp |

### How much does it cost to scrape G2 software categories?

This actor uses pay-per-event pricing with one small run-start fee and one low per-record charge for each saved dataset item.

Current pricing:

| Event | What it means | Price |
| --- | --- | --- |
| Run started | Charged once per run | $0.005 |
| Item extracted | Charged for each category, popular category, or product row | from $0.000024512 per item on BRONZE; lower on higher tiers |

Cost examples:

- 100 records: about $0.0075 on BRONZE, including the start event.
- 500 records: about $0.0173 on BRONZE, including the start event.
- 1,000 records: about $0.0295 on BRONZE, including the start event.

Use `maxItems` to cap costs during testing. A typical public directory run can produce hundreds or thousands of category rows, so start with 100 records before scheduling larger market maps.

### Quick start

1. Open the actor on Apify.
2. Keep the default start URL: `https://www.g2.com/categories`.
3. Set `maxItems` to a small value such as 100 for the first run.
4. Optionally add filters such as `CRM`, `AI`, `Security`, or `HR`.
5. Run the actor.
6. Export the dataset as JSON, CSV, Excel, XML, or via API.

### Input configuration

#### startUrls

Use one or more G2 category URLs.

The recommended default is the full directory URL.

```json
[{ "url": "https://www.g2.com/categories" }]
````

#### searchTerms

Use search terms to narrow the output.

For example, `CRM` matches categories and parent categories containing CRM.

```json
["CRM", "Sales"]
```

#### maxItems

Set the maximum number of records to save.

Use 20 for smoke tests.

Use 100 or more for full category maps.

#### includePopularCategories

Enable this option to include featured category cards from the top of the page.

Disable it if you only want canonical table rows.

#### proxyConfiguration

Proxy use is optional.

The public directory often works without proxy.

Enable Apify Proxy only if G2 throttles your environment.

### Example input

```json
{
  "startUrls": [{ "url": "https://www.g2.com/categories" }],
  "searchTerms": ["CRM", "AI"],
  "maxItems": 20,
  "includePopularCategories": true,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

### Example output

```json
{
  "recordType": "category",
  "categoryName": "CRM Software",
  "categorySlug": "crm",
  "categoryUrl": "https://www.g2.com/categories/crm",
  "parentCategory": "Sales Tools",
  "hierarchyLevel": 0,
  "categoryId": "179",
  "isNested": false,
  "productName": null,
  "productUrl": null,
  "rating": null,
  "reviewCount": null,
  "productDescription": null,
  "matchedSearchTerm": "CRM",
  "sourceUrl": "https://www.g2.com/categories",
  "sourcePageTitle": "All Categories | G2",
  "scrapedAt": "2026-06-26T00:00:00.000Z"
}
```

### Category mapping workflows

Export all category rows to CSV.

Load them into a spreadsheet or BI tool.

Group by `parentCategory`.

Use `hierarchyLevel` to understand nested categories.

Join the results with your own vendor, keyword, or CRM data.

### Lead generation workflows

Use category URLs as seed lists.

Prioritize categories that match your ICP.

Send selected category URLs to downstream enrichment or product-profile scrapers.

Track new category names that indicate emerging buyer intent.

### Market research workflows

Run the actor on a schedule.

Compare category snapshots over time.

Detect newly added AI, security, finance, HR, or vertical software categories.

Use parent-category groupings to size adjacent markets.

### Integrations

Send results to Google Sheets for analyst review.

Send category URLs to a CRM enrichment pipeline.

Use Apify webhooks to trigger downstream processing after each run.

Export JSON to a data warehouse.

Feed category names into keyword research tools.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/g2-software-categories-scraper').call({
  startUrls: [{ url: 'https://www.g2.com/categories' }],
  searchTerms: ['CRM'],
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/g2-software-categories-scraper').call(run_input={
    'startUrls': [{'url': 'https://www.g2.com/categories'}],
    'searchTerms': ['AI'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~g2-software-categories-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.g2.com/categories"}],"maxItems":100}'
```

### MCP usage

Use this actor from Apify MCP with Claude Code or Claude Desktop.

MCP URL:

`https://mcp.apify.com/?tools=automation-lab/g2-software-categories-scraper`

Claude Code setup:

```bash
claude mcp add apify-g2-categories --transport http https://mcp.apify.com/?tools=automation-lab/g2-software-categories-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-g2-categories": {
      "url": "https://mcp.apify.com/?tools=automation-lab/g2-software-categories-scraper"
    }
  }
}
```

Example prompts:

- "Run the G2 Software Categories Scraper for CRM categories and summarize parent categories."
- "Get 200 G2 category rows and list AI-related category names."
- "Export G2 category URLs I can use for SaaS competitor research."

### Tips for best results

Start with the public directory.

Keep `maxItems` low during the first run.

Use filters when you only need one market.

Disable popular category cards when you need only canonical directory rows.

Avoid aggressive repeated runs against G2.

### Troubleshooting

#### Why did a category page produce no product rows?

G2 may not serve product listings in static HTML for that page or may throttle category listing pages.

The actor still works for the public directory category map.

#### Why did I get fewer rows than expected?

Check `maxItems` and `searchTerms`.

A restrictive filter can intentionally return a small dataset.

#### Should I enable proxy?

Only enable proxy if your run is throttled.

For the public directory, no proxy is usually cheaper and sufficient.

### Data freshness

Each run fetches live public pages.

The actor does not use a cached G2 category database.

Schedule recurring runs if you need change detection.

### Limitations

The actor does not log in to G2.

It does not bypass paywalls, private dashboards, or account-only data.

Product detail extraction is best effort and depends on what G2 serves in the initial HTML.

Review text scraping is out of scope for this category-directory MVP.

### Legality

This actor extracts publicly available web pages.

Use the data responsibly.

Respect G2 terms, robots guidance, privacy laws, and your own compliance requirements.

Do not use scraped data for spam or unlawful profiling.

### Related scrapers

Explore other Automation Lab actors for SaaS, review, and lead-generation workflows:

- [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder) — enrich local and B2B prospect lists after you define target markets.
- [Website Contact Finder](https://apify.com/automation-lab/website-contact-finder) — find emails and contact pages from company websites.
- [Trustpilot Reviews Scraper](https://apify.com/automation-lab/trustpilot-reviews-scraper) — collect public review data for brand and competitor analysis.
- [Capterra Scraper](https://apify.com/automation-lab/capterra-scraper) — compare G2 category maps with another software directory.

### FAQ

#### Can I scrape all G2 categories?

Yes. Use the default directory URL and set `maxItems` high enough.

#### Can I scrape only AI categories?

Yes. Add `AI` to `searchTerms`.

#### Can I scrape only CRM categories?

Yes. Add `CRM` to `searchTerms`.

#### Does it use a browser?

No. It uses HTTP and Cheerio for a lighter, cheaper category-directory workflow.

#### Does it scrape reviews?

No. This actor focuses on the category taxonomy and category URLs.

#### Can I use the output as seeds for another scraper?

Yes. The `categoryUrl` field is designed for downstream workflows.

### Changelog

Initial version extracts the public G2 category directory, featured category cards, hierarchy metadata, and source audit fields.

# Actor input Schema

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

Start with https://www.g2.com/categories for the full public directory. Category listing URLs can be added for best-effort product link extraction when G2 serves them in HTML.

## `searchTerms` (type: `array`):

Optional case-insensitive keywords. Only categories whose name or parent category contains one of these terms will be saved.

## `maxItems` (type: `integer`):

Maximum number of category/product records to save. Use a low value for test runs and 100+ for production category maps.

## `includePopularCategories` (type: `boolean`):

Also save featured/popular category links from the top directory cards when available.

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

Optional Apify Proxy settings. Leave disabled for the public category directory; enable only if G2 throttles your run.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.g2.com/categories"
    }
  ],
  "searchTerms": [
    "CRM",
    "AI"
  ],
  "maxItems": 20,
  "includePopularCategories": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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.g2.com/categories"
        }
    ],
    "searchTerms": [
        "CRM",
        "AI"
    ],
    "maxItems": 20,
    "includePopularCategories": true,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/g2-software-categories-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.g2.com/categories" }],
    "searchTerms": [
        "CRM",
        "AI",
    ],
    "maxItems": 20,
    "includePopularCategories": True,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/g2-software-categories-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.g2.com/categories"
    }
  ],
  "searchTerms": [
    "CRM",
    "AI"
  ],
  "maxItems": 20,
  "includePopularCategories": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call automation-lab/g2-software-categories-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "G2 Software Categories Scraper",
        "description": "Extract G2 software category names, URLs, parent categories, IDs, and hierarchy depth for SaaS market maps and competitor research.",
        "version": "0.1",
        "x-build-id": "TCINMzDTsubpnETgZ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~g2-software-categories-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-g2-software-categories-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/automation-lab~g2-software-categories-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-g2-software-categories-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/automation-lab~g2-software-categories-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-g2-software-categories-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": "🔗 G2 category directory or category URLs",
                        "type": "array",
                        "description": "Start with https://www.g2.com/categories for the full public directory. Category listing URLs can be added for best-effort product link extraction when G2 serves them in HTML.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchTerms": {
                        "title": "Filter by category keywords",
                        "type": "array",
                        "description": "Optional case-insensitive keywords. Only categories whose name or parent category contains one of these terms will be saved.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of category/product records to save. Use a low value for test runs and 100+ for production category maps.",
                        "default": 20
                    },
                    "includePopularCategories": {
                        "title": "Include popular category cards",
                        "type": "boolean",
                        "description": "Also save featured/popular category links from the top directory cards when available.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Leave disabled for the public category directory; enable only if G2 throttles your run."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
