# SaaSHub Software Alternatives Scraper (`automation-lab/saashub-software-alternatives-scraper`) Actor

Extract ranked SaaSHub alternatives, features, votes, badges, vendor links, and comparisons for repeatable software competitive intelligence.

- **URL**: https://apify.com/automation-lab/saashub-software-alternatives-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business
- **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

## SaaSHub Software Alternatives Scraper

Turn public SaaSHub alternatives pages into clean, ranked software-competitor datasets.

Track how SaaSHub positions competing products, refresh “alternatives to” content, populate recommendation systems, or compare software categories without copying pages by hand.

The Actor accepts SaaSHub product slugs and full alternatives-page URLs. It returns one row per ranked or verified alternative with names, URLs, descriptions, features, votes, badges, comparison links, and provenance.

### What does SaaSHub Software Alternatives Scraper do?

- Extracts ranked alternatives from public SaaSHub pages.
- Preserves the rank shown for each seed product.
- Captures product descriptions and key-feature lists.
- Returns SaaSHub profile URLs and vendor website URLs.
- Captures logos, pricing/model tags, and vote values.
- Distinguishes ranked and verified placements.
- Flags featured or sponsored wording when it appears.
- Collects popular comparison URLs.
- Processes several seed products in one run.
- Exports JSON, CSV, Excel, XML, RSS, or HTML through Apify datasets.

### Who is it for?

#### Competitive-intelligence teams

Monitor which alternatives are associated with your product and how those competitors are described.

#### SEO and content teams

Build evidence-based comparison briefs and refresh “best alternatives” pages from a structured source.

#### Affiliate and directory operators

Maintain software catalogs with consistent product links, logos, descriptions, and feature labels.

#### Product researchers

Compare positioning and category adjacency across many software products.

#### RAG and recommendation builders

Feed ranked software relationships into retrieval systems, knowledge graphs, and recommendation pipelines.

### Why use this Actor?

Manual competitor research is slow and difficult to refresh.

This Actor produces repeatable records with source URLs and timestamps, making changes easier to audit.

It uses public server-rendered HTML and does not require a SaaSHub API key or user account.

Verified placements remain labeled, so paid or self-identified competitors are not silently mixed with organic rankings.

### Data you can extract

| Field | Meaning |
|---|---|
| `seedProduct` | Product whose alternatives page was requested |
| `seedSlug` | Normalized SaaSHub product slug |
| `rank` | Rank on the page, or null for verified sidebar entries |
| `productName` | Alternative product name |
| `productUrl` | SaaSHub alternatives/profile URL |
| `websiteUrl` | Vendor website when shown |
| `logoUrl` | Product logo URL |
| `description` | SaaSHub product positioning text |
| `keyFeatures` | Feature labels shown in the product card |
| `tags` | Pricing, licensing, or category labels |
| `rating` | Vote/rating number displayed in context |
| `section` | `ranked` or `verified` |
| `isVerified` | Whether the record came from a verified placement |
| `isFeatured` | Whether featured/sponsored wording was detected |
| `comparisonUrls` | Relevant SaaSHub comparison pages |
| `sourceUrl` | Alternatives page used |
| `scrapedAt` | UTC extraction timestamp |

### How to scrape SaaSHub software alternatives

1. Open the Actor input form.
2. Add one or more product slugs, such as `slack` or `notion`.
3. Optionally add complete URLs such as `https://www.saashub.com/trello-alternatives`.
4. Choose the maximum number of alternatives per seed.
5. Enable or disable verified entries and comparisons.
6. Start the run.
7. Open the Dataset tab to preview or export results.

### Input

```json
{
  "productSlugs": ["slack", "notion", "trello"],
  "maxAlternatives": 25,
  "includeVerified": true,
  "includeComparisons": true
}
````

`productSlugs` and `productUrls` may be combined.

If neither is supplied, the Actor uses `slack` as a safe sample.

Duplicate slugs are removed automatically.

The maximum is applied separately to each seed product.

### Output example

```json
{
  "seedProduct": "Notion",
  "seedSlug": "notion",
  "rank": 2,
  "productName": "Asana",
  "productUrl": "https://www.saashub.com/asana-alternatives",
  "websiteUrl": "https://asana.com/",
  "description": "Asana project management...",
  "keyFeatures": ["Task Management", "Collaboration"],
  "tags": ["freemium"],
  "rating": 195,
  "section": "ranked",
  "isVerified": false,
  "isFeatured": false,
  "sourceUrl": "https://www.saashub.com/notion-alternatives",
  "scrapedAt": "2026-07-13T02:58:16.860Z"
}
```

Optional fields use `null` or empty arrays rather than invented values.

### How much does it cost to scrape SaaSHub alternatives?

The Actor uses pay-per-event pricing.

A small start fee covers run setup, followed by a charge for each dataset row produced.

Subscription tiers receive automatic volume discounts.

Before a large batch, run one representative seed and use the Console estimate to forecast the total.

You pay for results produced, not a monthly software license for this Actor.

### Tips for reliable monitoring

- Store the `sourceUrl` with every downstream record.
- Use `seedSlug` and `productUrl` as stable join keys.
- Compare runs by rank rather than dataset order alone.
- Keep `section` in exports to separate verified placements.
- Schedule weekly or monthly runs for trend monitoring.
- Start with 25 alternatives before increasing volume.
- Treat SaaSHub descriptions as source text, not your own claims.

### Integrations

#### Google Sheets

Send dataset rows to a sheet for editorial review and competitor tracking.

#### Slack and email

Use an Apify webhook to notify a channel when a scheduled run completes.

#### Zapier and Make

Trigger workflows that enrich newly discovered competitor domains.

#### Data warehouses

Load JSON or CSV exports into BigQuery, Snowflake, or PostgreSQL.

#### AI and RAG pipelines

Index product relationships, features, and source URLs for grounded recommendations.

### API usage

Use the Apify client libraries or REST API to start runs and retrieve the default dataset. The following JavaScript, Python, and cURL examples all target `automation-lab/saashub-software-alternatives-scraper`.

### JavaScript API example

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/saashub-software-alternatives-scraper').call({
  productSlugs: ['slack', 'notion'],
  maxAlternatives: 25,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/saashub-software-alternatives-scraper').call(
    run_input={'productSlugs': ['slack'], 'maxAlternatives': 25}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~saashub-software-alternatives-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"productSlugs":["slack"],"maxAlternatives":25}'
```

Fetch results from the run's `defaultDatasetId` after it succeeds.

### Use with Apify MCP

The Actor is available through this scoped MCP endpoint:

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

Set `APIFY_TOKEN` in your environment, then add it to Claude Code:

```bash
claude mcp add --transport http apify-saashub \
  "https://mcp.apify.com?tools=automation-lab/saashub-software-alternatives-scraper" \
  --header "Authorization: Bearer $APIFY_TOKEN"
```

For Claude Desktop or Cursor, add this block to the client's MCP JSON configuration and replace `<APIFY_TOKEN>` with your token:

```json
{
  "mcpServers": {
    "apify-saashub": {
      "url": "https://mcp.apify.com?tools=automation-lab/saashub-software-alternatives-scraper",
      "headers": {
        "Authorization": "Bearer <APIFY_TOKEN>"
      }
    }
  }
}
```

For VS Code, save the following as `.vscode/mcp.json`:

```json
{
  "servers": {
    "apify-saashub": {
      "type": "http",
      "url": "https://mcp.apify.com?tools=automation-lab/saashub-software-alternatives-scraper",
      "headers": {
        "Authorization": "Bearer ${input:apify-token}"
      }
    }
  },
  "inputs": [
    {
      "id": "apify-token",
      "type": "promptString",
      "description": "Apify API token",
      "password": true
    }
  ]
}
```

Restart the desktop client or VS Code after saving its configuration.

Example prompts:

- “Find the top alternatives to Slack on SaaSHub.”
- “Compare Notion and Trello alternative sets.”
- “Return verified placements separately from ranked products.”
- “Prepare a competitor brief from these SaaSHub records.”

### Scheduling and change detection

Create an Apify schedule to run the Actor at a chosen interval.

Use the same seed list on each run.

Export results to a named database or compare datasets downstream.

Useful changes include new products, rank movement, description changes, and new verified placements.

A webhook can start a follow-up workflow after every successful refresh.

### Error handling

Invalid or missing pages are logged and skipped when SaaSHub returns HTTP 404.

Unexpected response codes fail the run instead of returning misleading empty data.

If a valid page yields no cards, the Actor fails with a selector-drift message.

Transient network errors are retried with bounded retries.

### Limitations

The Actor reads the public SaaSHub HTML surface, not the private keyed API.

Available fields vary by product card.

Vote values are source-provided context and may not represent conventional star ratings.

SaaSHub can change markup, rankings, badges, or descriptions at any time.

The Actor does not scrape user reviews or bypass login-only pages.

### Legality

#### Is it legal to scrape SaaSHub?

This Actor extracts publicly accessible information.

Your use must comply with applicable laws, SaaSHub terms, intellectual-property rights, and data-protection obligations.

Avoid excessive request rates and do not republish source text without checking your rights to do so.

You are responsible for the purpose, retention, and distribution of collected data.

### Troubleshooting

#### Why did a product return no rows?

Confirm the slug exists and that its public URL ends in `-alternatives`.

#### Why is rank null?

Verified sidebar products are not assigned an organic list position, so their rank is intentionally null.

#### Why are some feature arrays empty?

SaaSHub does not show feature labels for every product.

#### Why is a comparison list empty?

Disable neither comparisons nor use a page that does not expose popular comparisons.

#### How can I reduce run size?

Lower `maxAlternatives` or submit fewer seed products.

### FAQ

#### Does this Actor need a SaaSHub API key?

No. It reads anonymously available public pages.

#### Can I submit full URLs?

Yes. Use `productUrls`, `productSlugs`, or both.

#### Can it process many products?

Yes. Submit several slugs in one run; begin with a small representative batch.

#### Are verified alternatives organic rankings?

No. They are labeled with `section: verified`, `isVerified: true`, and a null rank.

#### Can I export to Excel?

Yes. Apify datasets support Excel, CSV, JSON, XML, RSS, and HTML exports.

### Related scrapers

Combine this Actor with other Automation Lab software-intelligence tools:

- [G2 Scraper](https://apify.com/automation-lab/g2-scraper) for software directory and review intelligence.
- [Chrome Web Store Extension Scraper](https://apify.com/automation-lab/chrome-web-store-extension-scraper) for browser-extension profiles.
- [Shopify App Store Reviews Scraper](https://apify.com/automation-lab/shopify-app-store-reviews-scraper) for ecommerce app feedback.

Use each source according to its own terms and data scope.

### Support

If a valid public SaaSHub alternatives page stops producing records, open an Actor issue with:

- the input used,
- the run URL,
- the expected product,
- and a short description of the missing data.

Those details make selector changes faster to diagnose.

# Actor input Schema

## `productSlugs` (type: `array`):

Product names as they appear in SaaSHub URLs, for example slack or notion.

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

Optional full SaaSHub alternatives URLs. URLs and slugs can be combined.

## `maxAlternatives` (type: `integer`):

Maximum ranked and verified alternative rows saved for each seed product.

## `includeVerified` (type: `boolean`):

Include unique products from SaaSHub's Verified Alternatives section after ranked results.

## `includeComparisons` (type: `boolean`):

Attach relevant SaaSHub comparison page URLs when available.

## Actor input object example

```json
{
  "productSlugs": [
    "slack",
    "notion"
  ],
  "productUrls": [],
  "maxAlternatives": 20,
  "includeVerified": true,
  "includeComparisons": true
}
```

# 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 = {
    "productSlugs": [
        "slack",
        "notion"
    ],
    "productUrls": [],
    "maxAlternatives": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/saashub-software-alternatives-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 = {
    "productSlugs": [
        "slack",
        "notion",
    ],
    "productUrls": [],
    "maxAlternatives": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/saashub-software-alternatives-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 '{
  "productSlugs": [
    "slack",
    "notion"
  ],
  "productUrls": [],
  "maxAlternatives": 20
}' |
apify call automation-lab/saashub-software-alternatives-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SaaSHub Software Alternatives Scraper",
        "description": "Extract ranked SaaSHub alternatives, features, votes, badges, vendor links, and comparisons for repeatable software competitive intelligence.",
        "version": "0.1",
        "x-build-id": "ROboVrlZD77urQHg3"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~saashub-software-alternatives-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-saashub-software-alternatives-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~saashub-software-alternatives-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-saashub-software-alternatives-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~saashub-software-alternatives-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-saashub-software-alternatives-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": {
                    "productSlugs": {
                        "title": "🔎 SaaSHub product slugs",
                        "type": "array",
                        "description": "Product names as they appear in SaaSHub URLs, for example slack or notion.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "productUrls": {
                        "title": "🔗 SaaSHub alternatives page URLs",
                        "type": "array",
                        "description": "Optional full SaaSHub alternatives URLs. URLs and slugs can be combined.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxAlternatives": {
                        "title": "📊 Maximum alternatives per product",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Maximum ranked and verified alternative rows saved for each seed product.",
                        "default": 20
                    },
                    "includeVerified": {
                        "title": "✅ Include verified alternatives",
                        "type": "boolean",
                        "description": "Include unique products from SaaSHub's Verified Alternatives section after ranked results.",
                        "default": true
                    },
                    "includeComparisons": {
                        "title": "↔️ Include comparison URLs",
                        "type": "boolean",
                        "description": "Attach relevant SaaSHub comparison page URLs when available.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
