# Zoho Marketplace Apps Scraper (`automation-lab/zoho-marketplace-apps-scraper`) Actor

Extract Zoho Marketplace apps, vendors, categories, pricing labels, ratings, install links, and policy URLs for ecosystem research.

- **URL**: https://apify.com/automation-lab/zoho-marketplace-apps-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

## Zoho Marketplace Apps Scraper

Extract public Zoho Marketplace app listings for CRM, Desk, Books, Projects, Recruit, and other Zoho products. The actor collects app names, vendor names, categories, pricing labels, ratings, install links, support policy URLs, and source timestamps from public Marketplace endpoints.

Use it to monitor the Zoho ecosystem, build partner lead lists, compare integration categories, and track new apps without manually clicking through marketplace pages.

### What does Zoho Marketplace Apps Scraper do?

Zoho Marketplace Apps Scraper turns public Zoho Marketplace product and search pages into structured datasets. Give it product keys such as `crm`, `desk`, or `books`, or paste Marketplace URLs like `https://marketplace.zoho.com/app/crm`, and it saves one row per app.

The actor is HTTP-first. It uses public Marketplace data endpoints that power Zoho's own pages, so runs are lightweight and do not require a browser, Zoho account, login cookie, or API key.

### Who is it for?

- 🧩 **SaaS partnership teams** that need lists of vendors building integrations for Zoho products.
- 🏢 **Zoho consultants and agencies** that monitor app categories, install paths, and pricing signals.
- 📊 **Competitive intelligence teams** tracking ecosystem depth across CRM, Desk, Books, Projects, Recruit, and adjacent products.
- 🛠️ **RevOps and marketplace teams** researching integration gaps and vendor opportunities.
- 🔎 **Data teams** that need repeatable exports instead of manual marketplace browsing.

### Why use this actor?

Manual marketplace research is slow and inconsistent. This scraper creates a reproducible export with URLs, vendor metadata, category labels, pricing labels, ratings, policy links, and timestamps. You can rerun the same input weekly or monthly to detect new apps, category changes, and vendors entering the Zoho ecosystem.

### Data you can extract

| Field | Description |
| --- | --- |
| `appName` | Marketplace app or extension name |
| `appUrl` | Public app detail page |
| `product` | Zoho product key such as `crm` or `desk` |
| `productName` | Human-readable product name |
| `category` | Marketplace category |
| `vendor` | App publisher or company name |
| `tagline` | Short Marketplace description |
| `pricing` | Public pricing label such as Free or Paid |
| `rating` | Average rating when available |
| `reviewCount` | Number of ratings/reviews when available |
| `installUrl` | Install or external onboarding URL |
| `privacyUrl` | Privacy policy URL |
| `termsUrl` | Terms of service URL |
| `publishedDate` | Marketplace published date when present |
| `sourceUrl` | Listing/search endpoint used for the row |
| `scrapedAt` | ISO timestamp of extraction |

### How much does it cost to scrape Zoho Marketplace apps?

The actor uses pay-per-event pricing: a small start event plus a per-app event for each saved dataset row. You control spend with `maxItems`. Start with the default 100 apps, then increase the limit for full product scans after confirming the output matches your workflow.

### Input options

- `products` — product keys such as `crm`, `desk`, `books`, `projects`, `recruit`, `creator`, or `inventory`.
- `startUrls` — public Zoho Marketplace `/app/<product>` URLs.
- `searchTerms` — Marketplace searches such as `email validation`, `SMS`, or `accounting`.
- `maxItems` — maximum rows saved across all sources.
- `pricing` — `All`, `Free`, or `Paid`.
- `minRating` — minimum rating filter from 0 to 5.
- `categoryId` — optional Zoho category UUID from prior runs.
- `deployment` — optional Zoho deployment value.
- `fetchDetails` — fetch each app page for meta-description enrichment.

### Example input

```json
{
  "products": ["crm", "desk"],
  "maxItems": 100,
  "pricing": "All",
  "minRating": 0,
  "fetchDetails": false
}
````

### Search example

```json
{
  "products": ["crm"],
  "searchTerms": ["email validation", "SMS"],
  "maxItems": 50
}
```

Search terms run first. If the search returns fewer rows than `maxItems`, the actor can continue with listing pages for the selected product and deduplicate app URLs.

### Start URL example

```json
{
  "startUrls": [{ "url": "https://marketplace.zoho.com/app/books" }],
  "pricing": "Paid",
  "maxItems": 100
}
```

Use start URLs when your workflow begins from browser bookmarks or spreadsheets of Marketplace product pages.

### Output example

```json
{
  "appName": "Easify SMS for Zoho CRM",
  "appUrl": "https://marketplace.zoho.com/app/crm/easify-sms-for-zoho-crm",
  "product": "crm",
  "productName": "CRM",
  "category": "Marketing",
  "vendor": "EasifySMS",
  "tagline": "Bulk SMS sending made easy.",
  "pricing": "Free",
  "deploymentType": "Zoho platform",
  "rating": 5,
  "reviewCount": 1,
  "installUrl": "https://crm.zoho.com/market/installPlugin.do?...",
  "privacyUrl": "https://easify.app/privacy-policy",
  "termsUrl": "https://easify.app/terms-of-service",
  "publishedDate": "May 31, 2026",
  "sourceType": "listing",
  "scrapedAt": "2026-07-01T02:49:12.270Z"
}
```

### Tips for best results

- Start with one product and a modest `maxItems` limit.
- Use `pricing` and `minRating` filters to narrow competitive research exports.
- Enable `fetchDetails` only when you need enriched meta descriptions.
- Rerun the same input on a schedule to monitor new vendors and apps.
- Export to CSV for quick review or JSON for downstream enrichment.

### Common Zoho product keys

- `crm`
- `desk`
- `books`
- `projects`
- `recruit`
- `creator`
- `inventory`
- `people`
- `cliq`
- `bigin`

### Integrations and workflows

- 📈 Send results to Google Sheets for marketplace monitoring dashboards.
- 🧭 Load app URLs into a CRM as partner or competitor accounts.
- 🧪 Compare category coverage between Zoho products.
- 🔔 Schedule recurring runs and diff app URLs to detect new listings.
- 🧰 Combine with enrichment actors to add domains, emails, or company profiles.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/zoho-marketplace-apps-scraper').call({
  products: ['crm'],
  maxItems: 100,
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/zoho-marketplace-apps-scraper').call(run_input={
    'products': ['desk'],
    'maxItems': 100,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~zoho-marketplace-apps-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"products":["crm"],"maxItems":100}'
```

### MCP usage

Use the Apify MCP server with this actor when you want Claude or another MCP client to run Zoho Marketplace research.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/zoho-marketplace-apps-scraper
```

Claude Code setup:

```bash
claude mcp add apify-zoho-marketplace "https://mcp.apify.com/?tools=automation-lab/zoho-marketplace-apps-scraper"
```

MCP JSON configuration:

```json
{
  "mcpServers": {
    "apify-zoho-marketplace": {
      "url": "https://mcp.apify.com/?tools=automation-lab/zoho-marketplace-apps-scraper"
    }
  }
}
```

Example prompts:

- "Scrape 100 Zoho CRM Marketplace apps and summarize the top vendor categories."
- "Find paid Zoho Desk Marketplace apps and group them by category."
- "Monitor Zoho Books Marketplace apps and list newly seen vendors."

### Scheduling

Create an Apify schedule with the same input to monitor the Marketplace over time. Weekly or monthly schedules work well for ecosystem monitoring because app catalogs do not usually change minute by minute.

### Data freshness

Each row includes `scrapedAt` and `sourceUrl`. Zoho Marketplace controls source data freshness; this actor records what the public Marketplace endpoints returned during the run.

### Limitations

- The actor extracts public Marketplace metadata only.
- It does not install apps or access private Zoho accounts.
- Some external vendor websites may be missing or set to placeholder values by Zoho.
- Review text is not part of the current MVP; the actor captures rating and review count when available.

### FAQ

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

The selected product, search term, pricing filter, or rating filter may have fewer matching apps than `maxItems`. Remove filters or add more products.

#### Why is `websiteUrl` empty?

Zoho does not expose a vendor website for every listing. The actor preserves install, privacy, and terms URLs when they are available.

### Legality

This actor extracts publicly available information from Zoho Marketplace. You are responsible for using the data in compliance with applicable laws, Zoho's terms, and your own data policies. Do not use exported data for spam or prohibited outreach.

### Related scrapers

Explore related automation-lab actors for SaaS and marketplace research:

- https://apify.com/automation-lab/atlassian-marketplace-scraper
- https://apify.com/automation-lab/google-workspace-marketplace-scraper
- https://apify.com/automation-lab/zoom-marketplace-scraper
- https://apify.com/automation-lab/miro-marketplace-scraper

### Changelog

- Initial private build: HTTP-first Zoho Marketplace listings and search extraction.

### Support

If a public Zoho Marketplace page stops returning data, include your run input and run ID when opening an issue. The most useful details are product keys, search terms, filters, and the approximate time of the run.

# Actor input Schema

## `products` (type: `array`):

Zoho Marketplace product paths to scrape, such as crm, desk, books, projects, recruit, creator, inventory, or people.

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

Optional /app/<product> URLs. Product keys are extracted from URLs such as https://marketplace.zoho.com/app/crm.

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

Optional marketplace searches. Combine with a product key to search within that Zoho product.

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

Maximum number of app records to save across all products and search terms.

## `pricing` (type: `string`):

Filter listings by Zoho Marketplace pricing label.

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

Minimum rating filter sent to Zoho Marketplace. Use 0 to include all apps.

## `categoryId` (type: `string`):

Optional Zoho category UUID from a previous run. Leave blank for all categories.

## `deployment` (type: `integer`):

Optional Zoho deployment numeric value. 0 means all deployments.

## `fetchDetails` (type: `boolean`):

Open each public app page to enrich records with the meta description. Slower but useful for competitive intelligence datasets.

## Actor input object example

```json
{
  "products": [
    "crm"
  ],
  "startUrls": [
    {
      "url": "https://marketplace.zoho.com/app/crm"
    }
  ],
  "searchTerms": [
    "email validation"
  ],
  "maxItems": 20,
  "pricing": "All",
  "minRating": 0,
  "deployment": 0,
  "fetchDetails": 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 = {
    "products": [
        "crm"
    ],
    "startUrls": [
        {
            "url": "https://marketplace.zoho.com/app/crm"
        }
    ],
    "searchTerms": [
        "email validation"
    ],
    "maxItems": 20,
    "pricing": "All",
    "minRating": 0,
    "deployment": 0,
    "fetchDetails": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/zoho-marketplace-apps-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 = {
    "products": ["crm"],
    "startUrls": [{ "url": "https://marketplace.zoho.com/app/crm" }],
    "searchTerms": ["email validation"],
    "maxItems": 20,
    "pricing": "All",
    "minRating": 0,
    "deployment": 0,
    "fetchDetails": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/zoho-marketplace-apps-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 '{
  "products": [
    "crm"
  ],
  "startUrls": [
    {
      "url": "https://marketplace.zoho.com/app/crm"
    }
  ],
  "searchTerms": [
    "email validation"
  ],
  "maxItems": 20,
  "pricing": "All",
  "minRating": 0,
  "deployment": 0,
  "fetchDetails": false
}' |
apify call automation-lab/zoho-marketplace-apps-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Zoho Marketplace Apps Scraper",
        "description": "Extract Zoho Marketplace apps, vendors, categories, pricing labels, ratings, install links, and policy URLs for ecosystem research.",
        "version": "0.1",
        "x-build-id": "xwTWSh0xln7ipVpTr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~zoho-marketplace-apps-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-zoho-marketplace-apps-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~zoho-marketplace-apps-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-zoho-marketplace-apps-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~zoho-marketplace-apps-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-zoho-marketplace-apps-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": {
                    "products": {
                        "title": "Zoho product keys",
                        "type": "array",
                        "description": "Zoho Marketplace product paths to scrape, such as crm, desk, books, projects, recruit, creator, inventory, or people.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Zoho Marketplace product URLs",
                        "type": "array",
                        "description": "Optional /app/<product> URLs. Product keys are extracted from URLs such as https://marketplace.zoho.com/app/crm.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "array",
                        "description": "Optional marketplace searches. Combine with a product key to search within that Zoho product.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum apps",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of app records to save across all products and search terms.",
                        "default": 20
                    },
                    "pricing": {
                        "title": "Pricing filter",
                        "enum": [
                            "All",
                            "Free",
                            "Paid"
                        ],
                        "type": "string",
                        "description": "Filter listings by Zoho Marketplace pricing label.",
                        "default": "All"
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Minimum rating filter sent to Zoho Marketplace. Use 0 to include all apps.",
                        "default": 0
                    },
                    "categoryId": {
                        "title": "Category UUID",
                        "type": "string",
                        "description": "Optional Zoho category UUID from a previous run. Leave blank for all categories."
                    },
                    "deployment": {
                        "title": "Deployment value",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Optional Zoho deployment numeric value. 0 means all deployments.",
                        "default": 0
                    },
                    "fetchDetails": {
                        "title": "Fetch app detail pages",
                        "type": "boolean",
                        "description": "Open each public app page to enrich records with the meta description. Slower but useful for competitive intelligence datasets.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
