# Content Intelligence Bundle (`runtime/content-intelligence-bundle`) Actor

Discover product launch monitoring signals, competitors, Reddit discussions, YouTube videos, content opportunities, and market signals, then save scored AI-ready intelligence records.

- **URL**: https://apify.com/runtime/content-intelligence-bundle.md
- **Developed by:** [scraping automation](https://apify.com/runtime) (community)
- **Categories:** Lead generation, Business, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Content Intelligence Bundle

Discover launches, competitors, community discussions, videos, and market signals from multiple public sources.

### Who this is for
- Content strategists
- SEO teams
- Product marketers
- AI research workflows

### What it helps you do
- Research a topic across search, Product Hunt, Reddit, and YouTube-style sources
- Collect market signals and content opportunities
- Prepare prioritized records for briefs or dashboards

### Inputs you can use
- Topic or keyword
- Market or location context
- Maximum records

### Data you get
- source
- title
- URL
- summary
- topic
- opportunity score
- evidence

### How to get better results
- Start with a narrow, specific query or a small list of source URLs.
- Use realistic limits for the first run, then increase the volume once the output looks right.
- Keep source URLs, dates, and location context when you need repeatable market monitoring.
- Review a few sample records before connecting the dataset to a larger workflow.

### Notes
- Results depend on what the public source exposes at run time.
- Some pages may hide, delay, rename, or remove fields, so individual records can have partial data.
- Use the built-in output table to inspect results before exporting to spreadsheets, dashboards, or automation tools.

### Support
If a run returns unexpected data, open an issue from the Actor page with the input used, the run ID, and the result you expected.

# Actor input Schema

## `workflow` (type: `string`):

Business workflow label stored on each output item.
## `searchQuery` (type: `string`):

Single search query. Used when Search queries is empty.
## `searchQueries` (type: `array`):

Batch queries, one per line. When non-empty, this overrides Search query.
## `includeDuckDuckGo` (type: `boolean`):

Run direct DuckDuckGo discovery inside this bundle Actor. This does not call the standalone DuckDuckGo Actor.
## `searchMode` (type: `string`):

DuckDuckGo vertical to query.
## `maxResults` (type: `integer`):

Maximum normalized records saved by the bundle.
## `maxResultsPerSource` (type: `integer`):

Maximum raw records collected from each enabled source before normalization.
## `maxSearchPages` (type: `integer`):

Maximum DuckDuckGo pages per query.
## `extractEmails` (type: `boolean`):

Extract emails from titles and snippets when available.
## `includeProductHunt` (type: `boolean`):

Run direct Product Hunt leaderboard discovery inside this bundle Actor. This does not call the standalone Product Hunt Actor.
## `productHuntStartUrls` (type: `string`):

Optional Product Hunt daily leaderboard URLs, one per line. If empty, Product Hunt date is used; if both are empty, yesterday's leaderboard is used.
## `productHuntDate` (type: `string`):

Daily Product Hunt leaderboard date in YYYY-MM-DD format. Used when no Product Hunt leaderboard URLs are provided.
## `includeReddit` (type: `boolean`):

Run direct Reddit search/subreddit discovery inside this bundle Actor. Uses Reddit JSON with RSS fallback and does not call the standalone Reddit Actor.
## `redditSearchQuery` (type: `string`):

Single Reddit search query. Used when Reddit search queries is empty. Defaults to the main search query.
## `redditSearchQueries` (type: `array`):

Batch Reddit queries, one per line. When non-empty, this overrides Reddit search query.
## `redditSubreddits` (type: `array`):

Optional subreddit names or URLs. When set with a Reddit search query, search is restricted to each subreddit. When no query is set, the bundle collects subreddit listings.
## `redditSort` (type: `string`):

Sort order for Reddit search.
## `redditTime` (type: `string`):

Time window for Reddit search/top listings.
## `includeYouTube` (type: `boolean`):

Run direct YouTube lightweight discovery inside this bundle Actor. Supports YouTube search pages and channel RSS feeds without calling the standalone YouTube Actors.
## `youtubeSearchQuery` (type: `string`):

Single YouTube search query. Leave empty to skip YouTube search unless YouTube channels are provided.
## `youtubeSearchQueries` (type: `array`):

Batch YouTube queries, one per line. When non-empty, this overrides YouTube search query.
## `youtubeChannel` (type: `string`):

Single YouTube channel URL, @handle, or channel ID for RSS-based latest video discovery.
## `youtubeChannels` (type: `array`):

Batch YouTube channels, one per line. Supports channel URLs, @handles, and channel IDs.
## `sourceItems` (type: `array`):

Optional raw items from Product Hunt, YouTube, Reddit, DuckDuckGo, or another source to normalize into bundle records.
## `mockMode` (type: `boolean`):

Generate sample source items without network access. Useful for smoke tests and schema checks.
## `failOnNoResults` (type: `boolean`):

Fail the run if no normalized records are produced.
## `useApifyProxy` (type: `boolean`):

Enable Apify Proxy for direct web discovery. Keep this enabled when Reddit is included; direct Reddit JSON/RSS commonly blocks cloud runs and the DuckDuckGo fallback is more reliable through proxy.
## `proxyConfiguration` (type: `object`):

Advanced Apify Proxy or custom proxy settings for direct web discovery.

## Actor input object example

```json
{
  "workflow": "source-discovery",
  "searchQuery": "AI startup launch",
  "searchQueries": [],
  "includeDuckDuckGo": true,
  "searchMode": "default",
  "maxResults": 25,
  "maxResultsPerSource": 10,
  "maxSearchPages": 1,
  "extractEmails": false,
  "includeProductHunt": true,
  "productHuntStartUrls": "https://www.producthunt.com/leaderboard/daily/2025/1/15/all",
  "productHuntDate": "2026-06-23",
  "includeReddit": true,
  "redditSearchQuery": "AI startup launch",
  "redditSearchQueries": [],
  "redditSubreddits": [
    "startups",
    "SaaS"
  ],
  "redditSort": "relevance",
  "redditTime": "month",
  "includeYouTube": false,
  "youtubeSearchQuery": "AI startup launch",
  "youtubeSearchQueries": [],
  "youtubeChannel": "https://www.youtube.com/@ProductHunt",
  "youtubeChannels": [],
  "sourceItems": [],
  "mockMode": false,
  "failOnNoResults": true,
  "useApifyProxy": true,
  "proxyConfiguration": {}
}
````

# Actor output Schema

## `source` (type: `string`):

Normalized source type

## `workflow` (type: `string`):

Workflow that produced the record

## `query` (type: `string`):

Search or source query

## `title` (type: `string`):

Record title

## `url` (type: `string`):

Primary URL

## `canonicalUrl` (type: `string`):

Canonical URL without tracking parameters when possible

## `snippet` (type: `string`):

Short description or source snippet

## `author` (type: `string`):

Author, channel, maker, or community

## `publishedAt` (type: `string`):

Published timestamp when available

## `rank` (type: `string`):

Listing rank when available

## `position` (type: `string`):

Position in the source listing

## `metrics` (type: `string`):

Normalized engagement and source metrics

## `emails` (type: `string`):

Emails found in source text

## `leadScore` (type: `string`):

0-100 lead value score

## `trendScore` (type: `string`):

0-100 trend/traction score

## `qualityScore` (type: `string`):

0-100 extraction quality score

## `qualityWarnings` (type: `string`):

Warnings for missing or partial fields

## `sourceData` (type: `string`):

Source-specific fields preserved after normalization, such as Product Hunt categories, launch metadata, YouTube channel details, or Reddit community fields

## `sourceInput` (type: `string`):

Original input that produced this item

## `listingUrl` (type: `string`):

Listing URL where the item was found

## `scrapedAt` (type: `string`):

ISO timestamp when the record was created

# 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 = {
    "searchQuery": "AI startup launch",
    "redditSearchQuery": "AI startup launch",
    "youtubeSearchQuery": "AI startup launch",
    "youtubeChannel": "https://www.youtube.com/@ProductHunt"
};

// Run the Actor and wait for it to finish
const run = await client.actor("runtime/content-intelligence-bundle").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 = {
    "searchQuery": "AI startup launch",
    "redditSearchQuery": "AI startup launch",
    "youtubeSearchQuery": "AI startup launch",
    "youtubeChannel": "https://www.youtube.com/@ProductHunt",
}

# Run the Actor and wait for it to finish
run = client.actor("runtime/content-intelligence-bundle").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 '{
  "searchQuery": "AI startup launch",
  "redditSearchQuery": "AI startup launch",
  "youtubeSearchQuery": "AI startup launch",
  "youtubeChannel": "https://www.youtube.com/@ProductHunt"
}' |
apify call runtime/content-intelligence-bundle --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=runtime/content-intelligence-bundle",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Content Intelligence Bundle",
        "description": "Discover product launch monitoring signals, competitors, Reddit discussions, YouTube videos, content opportunities, and market signals, then save scored AI-ready intelligence records.",
        "version": "0.3",
        "x-build-id": "VixMcKYad8h5Gydrf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/runtime~content-intelligence-bundle/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-runtime-content-intelligence-bundle",
                "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/runtime~content-intelligence-bundle/runs": {
            "post": {
                "operationId": "runs-sync-runtime-content-intelligence-bundle",
                "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/runtime~content-intelligence-bundle/run-sync": {
            "post": {
                "operationId": "run-sync-runtime-content-intelligence-bundle",
                "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": {
                    "workflow": {
                        "title": "Workflow",
                        "enum": [
                            "source-discovery",
                            "startup-lead-radar",
                            "youtube-trend-watch",
                            "competitor-content-monitor",
                            "custom"
                        ],
                        "type": "string",
                        "description": "Business workflow label stored on each output item.",
                        "default": "source-discovery"
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Single search query. Used when Search queries is empty.",
                        "default": "AI startup launch"
                    },
                    "searchQueries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Batch queries, one per line. When non-empty, this overrides Search query.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "includeDuckDuckGo": {
                        "title": "Include web discovery",
                        "type": "boolean",
                        "description": "Run direct DuckDuckGo discovery inside this bundle Actor. This does not call the standalone DuckDuckGo Actor.",
                        "default": true
                    },
                    "searchMode": {
                        "title": "Search mode",
                        "enum": [
                            "default",
                            "news",
                            "videos"
                        ],
                        "type": "string",
                        "description": "DuckDuckGo vertical to query.",
                        "default": "default"
                    },
                    "maxResults": {
                        "title": "Max output records",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum normalized records saved by the bundle.",
                        "default": 25
                    },
                    "maxResultsPerSource": {
                        "title": "Max records per source",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum raw records collected from each enabled source before normalization.",
                        "default": 10
                    },
                    "maxSearchPages": {
                        "title": "Max search pages",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Maximum DuckDuckGo pages per query.",
                        "default": 1
                    },
                    "extractEmails": {
                        "title": "Extract emails",
                        "type": "boolean",
                        "description": "Extract emails from titles and snippets when available.",
                        "default": false
                    },
                    "includeProductHunt": {
                        "title": "Include Product Hunt",
                        "type": "boolean",
                        "description": "Run direct Product Hunt leaderboard discovery inside this bundle Actor. This does not call the standalone Product Hunt Actor.",
                        "default": true
                    },
                    "productHuntStartUrls": {
                        "title": "Product Hunt leaderboard URLs",
                        "type": "string",
                        "description": "Optional Product Hunt daily leaderboard URLs, one per line. If empty, Product Hunt date is used; if both are empty, yesterday's leaderboard is used.",
                        "default": ""
                    },
                    "productHuntDate": {
                        "title": "Product Hunt date",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
                        "type": "string",
                        "description": "Daily Product Hunt leaderboard date in YYYY-MM-DD format. Used when no Product Hunt leaderboard URLs are provided."
                    },
                    "includeReddit": {
                        "title": "Include Reddit",
                        "type": "boolean",
                        "description": "Run direct Reddit search/subreddit discovery inside this bundle Actor. Uses Reddit JSON with RSS fallback and does not call the standalone Reddit Actor.",
                        "default": true
                    },
                    "redditSearchQuery": {
                        "title": "Reddit search query",
                        "type": "string",
                        "description": "Single Reddit search query. Used when Reddit search queries is empty. Defaults to the main search query.",
                        "default": ""
                    },
                    "redditSearchQueries": {
                        "title": "Reddit search queries",
                        "type": "array",
                        "description": "Batch Reddit queries, one per line. When non-empty, this overrides Reddit search query.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "redditSubreddits": {
                        "title": "Reddit subreddits",
                        "type": "array",
                        "description": "Optional subreddit names or URLs. When set with a Reddit search query, search is restricted to each subreddit. When no query is set, the bundle collects subreddit listings.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "redditSort": {
                        "title": "Reddit search sort",
                        "enum": [
                            "relevance",
                            "hot",
                            "top",
                            "new",
                            "comments"
                        ],
                        "type": "string",
                        "description": "Sort order for Reddit search.",
                        "default": "relevance"
                    },
                    "redditTime": {
                        "title": "Reddit time window",
                        "enum": [
                            "hour",
                            "day",
                            "week",
                            "month",
                            "year",
                            "all"
                        ],
                        "type": "string",
                        "description": "Time window for Reddit search/top listings.",
                        "default": "month"
                    },
                    "includeYouTube": {
                        "title": "Include YouTube",
                        "type": "boolean",
                        "description": "Run direct YouTube lightweight discovery inside this bundle Actor. Supports YouTube search pages and channel RSS feeds without calling the standalone YouTube Actors.",
                        "default": false
                    },
                    "youtubeSearchQuery": {
                        "title": "YouTube search query",
                        "type": "string",
                        "description": "Single YouTube search query. Leave empty to skip YouTube search unless YouTube channels are provided.",
                        "default": ""
                    },
                    "youtubeSearchQueries": {
                        "title": "YouTube search queries",
                        "type": "array",
                        "description": "Batch YouTube queries, one per line. When non-empty, this overrides YouTube search query.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "youtubeChannel": {
                        "title": "YouTube channel",
                        "type": "string",
                        "description": "Single YouTube channel URL, @handle, or channel ID for RSS-based latest video discovery.",
                        "default": ""
                    },
                    "youtubeChannels": {
                        "title": "YouTube channels",
                        "type": "array",
                        "description": "Batch YouTube channels, one per line. Supports channel URLs, @handles, and channel IDs.",
                        "items": {
                            "type": "string"
                        },
                        "default": []
                    },
                    "sourceItems": {
                        "title": "Source items",
                        "type": "array",
                        "description": "Optional raw items from Product Hunt, YouTube, Reddit, DuckDuckGo, or another source to normalize into bundle records.",
                        "items": {
                            "type": "object"
                        },
                        "default": []
                    },
                    "mockMode": {
                        "title": "Mock mode",
                        "type": "boolean",
                        "description": "Generate sample source items without network access. Useful for smoke tests and schema checks.",
                        "default": false
                    },
                    "failOnNoResults": {
                        "title": "Fail on no results",
                        "type": "boolean",
                        "description": "Fail the run if no normalized records are produced.",
                        "default": true
                    },
                    "useApifyProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Enable Apify Proxy for direct web discovery. Keep this enabled when Reddit is included; direct Reddit JSON/RSS commonly blocks cloud runs and the DuckDuckGo fallback is more reliable through proxy.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Advanced Apify Proxy or custom proxy settings for direct web discovery.",
                        "default": {}
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
