# AI Shovel Radar - AI Gold Rush Opportunity Finder (`datarummage/ai-shovel-radar`) Actor

Find shovel-ready AI business ideas, service offers, APIs, and automation angles from public conversation and marketplace signals.

- **URL**: https://apify.com/datarummage/ai-shovel-radar.md
- **Developed by:** [Data Rummage](https://apify.com/datarummage) (community)
- **Categories:** Developer tools, Marketing, Lead generation
- **Stats:** 2 total users, 1 monthly users, 83.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$50.00 / 1,000 ai shovel cards

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## AI Shovel Radar

AI Shovel Radar finds monetizable opportunity signals in the AI gold rush.

It is built for people who want to make money with AI but do not want another vague list of "10 side hustles." The Actor scans public conversations, extracts recurring pain and ambition, then turns that into practical shovel ideas: services, APIs, automation offers, template packs, niche reports, and small tools people can test.

It does not promise income. It shows you where to dig.

This is a separate product from HN Opportunity Finder. HN Opportunity Finder is for developer pain and technical leads. AI Shovel Radar is for ambitious AI-money seekers who may not know or care what Hacker News is; Hacker News is only one optional signal source under the hood.

### What this Actor gives you

Each dataset row is a shovel card:

- who the target buyer might be
- what they appear to want
- what pain or confusion is visible
- what shovel you could sell into that demand
- a concrete first offer
- tools needed
- evidence from public conversation
- lead quality: `research`, `warm_lead`, or `direct_lead`
- beginner difficulty
- saturation risk
- failure modes
- next step

### Best first run

```json
{
  "ambitionLevel": "side_hustle",
  "preferredModels": ["service", "api_actor", "template_pack"],
  "skillLevel": "beginner",
  "budget": "zero_to_low",
  "timeAvailable": "weekends",
  "interests": ["automation", "local business", "content"],
  "dataSources": ["apify_store", "reddit"],
  "redditCommunities": ["sidehustle", "Entrepreneur", "smallbusiness", "ChatGPT", "SaaS"],
  "days": 30,
  "maxResults": 100,
  "outputLimit": 10,
  "minScore": 45,
  "leadQualityMode": "all",
  "includeHigherDifficulty": false
}
````

### Output example

```json
{
  "opportunityTitle": "AI workflow automation around support, chatbot",
  "goldRushCategory": "AI customer support automation",
  "monetizationModel": "service",
  "targetBuyer": "small teams with repeated customer questions and no dedicated support engineer",
  "buyerDesire": "They want faster replies without hiring support staff or learning AI tooling.",
  "visiblePain": "People describe friction around setup and support, which can be packaged into setup, workflow, or tooling help.",
  "shovelToSell": "A fixed-price AI support FAQ and triage setup.",
  "firstOffer": "I'll turn your existing help docs and inbox patterns into a basic AI support triage flow for $199.",
  "difficulty": "beginner",
  "timeToFirstAttempt": "1 weekend",
  "toolsNeeded": ["Crisp or Tidio", "OpenAI or Claude", "Google Sheets", "Zapier or Make"],
  "saturationLevel": "medium",
  "leadQuality": "warm_lead",
  "leadQualityReason": "Operational pain is visible, but the buying/request intent is not explicit enough.",
  "directLead": false,
  "scores": {
    "buyerPain": 72,
    "monetizationClarity": 75,
    "beginnerFeasibility": 70,
    "competitionRisk": 55,
    "evidenceStrength": 64,
    "overall": 67
  },
  "failureModes": [
    "Support bots fail if the source FAQ is thin or wrong.",
    "Buyers may worry that AI will annoy customers.",
    "The offer needs clear human handoff, not full autopilot hype."
  ],
  "nextStep": "Pick one business with public FAQs and build a small before/after demo from their actual questions."
}
```

### Input tips

Use interests to steer the scan:

- `automation`
- `local business`
- `content`
- `lead generation`
- `customer support`
- `data`
- `SEO`
- `video clipping`
- `RAG`
- `AI agents`

Use data sources to choose where the signal comes from:

- `apify_store`: stable, free marketplace supply/demand signal from existing Actor categories, descriptions, usage, and pricing
- `hackernews`: optional developer/news-heavy fallback signal
- `reddit`: broader buyer-psychology signal from targeted public subreddit search; anonymous access can be sparse or rate-limited, so the Actor treats Reddit blocks as an empty source instead of crashing

Use `redditCommunities` to steer Reddit toward the actual AI-money audience. Good starter communities are `sidehustle`, `Entrepreneur`, `smallbusiness`, `ChatGPT`, and `SaaS`. This keeps the product focused on ambition/shovel demand rather than generic AI commentary. Add `all` only if you explicitly want broader Reddit search noise.

Use preferred models to control the kind of shovel:

- `service`: setup, audit, done-for-you workflow
- `api_actor`: APIs, Apify Actors, data tools
- `template_pack`: prompts, Notion systems, workflow packs
- `no_code_automation`: Zapier/Make style automations
- `content_newsletter`: attention and audience plays
- `data_report`: niche reports and lead lists

Use lead quality mode to control strictness:

- `all`: broad opportunity research and gold-rush signals
- `qualified`: only `warm_lead` and `direct_lead`
- `direct_only`: strict explicit buyer/request intent; this will usually be sparse on HN

`directLeadOnly: true` is a compatibility shortcut for `leadQualityMode: direct_only`.

The direct-lead classifier is intentionally conservative. High score often means “interesting AI-money discussion,” not “someone to contact.”

### Current data sources

Version 0.4 scans Apify Store marketplace search and targeted Reddit communities by default. Hacker News remains available as an optional fallback source via `dataSources`. No API key, no proxy, and no paid data dependency are required.

Future versions can add Product Hunt, GitHub discussions, YouTube, X, and Indie Hackers-style signals.

### Important disclaimer

This Actor does not provide financial advice and does not guarantee income. It outputs public-data opportunity signals and practical first-test ideas. What you do with those ideas is up to you.

### Local API mode

```bash
cd ai-shovel-radar
python -m venv .venv
. .venv/bin/activate
pip install -e '.[test]'
uvicorn ai_shovel_radar.app:app --app-dir src --host 0.0.0.0 --port 8000
```

Example:

```text
http://localhost:8000/v1/shovels?interests=automation,local%20business&dataSources=hackernews,reddit&redditCommunities=sidehustle,Entrepreneur,smallbusiness&preferredModels=service,api_actor&outputLimit=10
```

# Actor input Schema

## `ambitionLevel` (type: `string`):

What kind of AI-money path the user is exploring.

## `preferredModels` (type: `array`):

Types of shovels to prefer when generating opportunity cards.

## `skillLevel` (type: `string`):

The user's practical build/sales skill level.

## `budget` (type: `string`):

How much paid tooling the user is willing to use while testing ideas.

## `timeAvailable` (type: `string`):

How much time the user can spend on a first attempt.

## `interests` (type: `array`):

Niches or themes to bias the scan toward, such as automation, local business, content, support, data, or lead generation.

## `dataSources` (type: `array`):

Public signals to scan. Apify Store gives marketplace supply/demand signals; Reddit adds buyer-psychology signal but may return fewer items when anonymous access is blocked; Hacker News is optional fallback signal.

## `redditCommunities` (type: `array`):

Optional subreddit names to bias Reddit search toward AI-money, side-hustle, founder, and small-business conversations. Used only when reddit is selected as a data source.

## `keywords` (type: `array`):

Optional explicit public-search queries to add on top of the generated AI gold-rush query pack.

## `days` (type: `integer`):

Only include public conversation items from the last N days.

## `maxResults` (type: `integer`):

Maximum number of public search hits to scan before scoring and filtering.

## `outputLimit` (type: `integer`):

Maximum number of ranked shovel cards to push to the dataset after scoring and filtering.

## `minScore` (type: `integer`):

Only output shovel cards with an overall score at or above this value.

## `leadQualityMode` (type: `string`):

Control how strict the output should be: all research signals, qualified warm/direct signals, or strict direct-buyer-intent only.

## `directLeadOnly` (type: `boolean`):

Compatibility shortcut for leadQualityMode=direct\_only. Direct leads require explicit ask/buying language, so results may be sparse.

## `includeHigherDifficulty` (type: `boolean`):

Include ideas that are less beginner-friendly but may be more scalable.

## Actor input object example

```json
{
  "ambitionLevel": "side_hustle",
  "preferredModels": [
    "service",
    "api_actor",
    "template_pack"
  ],
  "skillLevel": "beginner",
  "budget": "zero_to_low",
  "timeAvailable": "weekends",
  "interests": [
    "automation",
    "local business",
    "content"
  ],
  "dataSources": [
    "apify_store",
    "reddit"
  ],
  "redditCommunities": [
    "sidehustle",
    "Entrepreneur",
    "smallbusiness",
    "ChatGPT",
    "SaaS"
  ],
  "keywords": [],
  "days": 30,
  "maxResults": 100,
  "outputLimit": 20,
  "minScore": 45,
  "leadQualityMode": "all",
  "directLeadOnly": false,
  "includeHigherDifficulty": false
}
```

# Actor output Schema

## `opportunities` (type: `string`):

Ranked opportunities with target buyer, visible pain, first offer, monetization model, evidence, score breakdown, and next step.

## `summary` (type: `string`):

Run metadata including source counts, output count, quality counts, direct-lead count, and zero-result hints when applicable.

# 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 = {
    "preferredModels": [
        "service",
        "api_actor",
        "template_pack"
    ],
    "interests": [
        "automation",
        "local business",
        "content"
    ],
    "dataSources": [
        "apify_store",
        "reddit"
    ],
    "redditCommunities": [
        "sidehustle",
        "Entrepreneur",
        "smallbusiness",
        "ChatGPT",
        "SaaS"
    ],
    "keywords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("datarummage/ai-shovel-radar").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 = {
    "preferredModels": [
        "service",
        "api_actor",
        "template_pack",
    ],
    "interests": [
        "automation",
        "local business",
        "content",
    ],
    "dataSources": [
        "apify_store",
        "reddit",
    ],
    "redditCommunities": [
        "sidehustle",
        "Entrepreneur",
        "smallbusiness",
        "ChatGPT",
        "SaaS",
    ],
    "keywords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("datarummage/ai-shovel-radar").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 '{
  "preferredModels": [
    "service",
    "api_actor",
    "template_pack"
  ],
  "interests": [
    "automation",
    "local business",
    "content"
  ],
  "dataSources": [
    "apify_store",
    "reddit"
  ],
  "redditCommunities": [
    "sidehustle",
    "Entrepreneur",
    "smallbusiness",
    "ChatGPT",
    "SaaS"
  ],
  "keywords": []
}' |
apify call datarummage/ai-shovel-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=datarummage/ai-shovel-radar",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AI Shovel Radar - AI Gold Rush Opportunity Finder",
        "description": "Find shovel-ready AI business ideas, service offers, APIs, and automation angles from public conversation and marketplace signals.",
        "version": "0.1",
        "x-build-id": "2r14QNuxchMc0x9CS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datarummage~ai-shovel-radar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datarummage-ai-shovel-radar",
                "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/datarummage~ai-shovel-radar/runs": {
            "post": {
                "operationId": "runs-sync-datarummage-ai-shovel-radar",
                "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/datarummage~ai-shovel-radar/run-sync": {
            "post": {
                "operationId": "run-sync-datarummage-ai-shovel-radar",
                "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": {
                    "ambitionLevel": {
                        "title": "Ambition level",
                        "enum": [
                            "side_hustle",
                            "replace_income",
                            "agency",
                            "indie_startup",
                            "content_business"
                        ],
                        "type": "string",
                        "description": "What kind of AI-money path the user is exploring.",
                        "default": "side_hustle"
                    },
                    "preferredModels": {
                        "title": "Preferred monetization models",
                        "type": "array",
                        "description": "Types of shovels to prefer when generating opportunity cards.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "skillLevel": {
                        "title": "Skill level",
                        "enum": [
                            "beginner",
                            "no_code",
                            "technical",
                            "sales_heavy",
                            "builder",
                            "content_creator"
                        ],
                        "type": "string",
                        "description": "The user's practical build/sales skill level.",
                        "default": "beginner"
                    },
                    "budget": {
                        "title": "Budget",
                        "enum": [
                            "zero",
                            "zero_to_low",
                            "paid_tools_ok"
                        ],
                        "type": "string",
                        "description": "How much paid tooling the user is willing to use while testing ideas.",
                        "default": "zero_to_low"
                    },
                    "timeAvailable": {
                        "title": "Time available",
                        "enum": [
                            "one_evening",
                            "weekends",
                            "part_time",
                            "full_time"
                        ],
                        "type": "string",
                        "description": "How much time the user can spend on a first attempt.",
                        "default": "weekends"
                    },
                    "interests": {
                        "title": "Interests",
                        "type": "array",
                        "description": "Niches or themes to bias the scan toward, such as automation, local business, content, support, data, or lead generation.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "dataSources": {
                        "title": "Data sources",
                        "type": "array",
                        "description": "Public signals to scan. Apify Store gives marketplace supply/demand signals; Reddit adds buyer-psychology signal but may return fewer items when anonymous access is blocked; Hacker News is optional fallback signal.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "apify_store",
                                "hackernews",
                                "reddit"
                            ],
                            "enumTitles": [
                                "Apify Store",
                                "Hacker News",
                                "Reddit"
                            ]
                        }
                    },
                    "redditCommunities": {
                        "title": "Reddit communities",
                        "type": "array",
                        "description": "Optional subreddit names to bias Reddit search toward AI-money, side-hustle, founder, and small-business conversations. Used only when reddit is selected as a data source.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "keywords": {
                        "title": "Extra search keywords",
                        "type": "array",
                        "description": "Optional explicit public-search queries to add on top of the generated AI gold-rush query pack.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "days": {
                        "title": "Lookback days",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Only include public conversation items from the last N days.",
                        "default": 30
                    },
                    "maxResults": {
                        "title": "Maximum public items to scan",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of public search hits to scan before scoring and filtering.",
                        "default": 100
                    },
                    "outputLimit": {
                        "title": "Maximum shovel cards to output",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of ranked shovel cards to push to the dataset after scoring and filtering.",
                        "default": 20
                    },
                    "minScore": {
                        "title": "Minimum shovel score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Only output shovel cards with an overall score at or above this value.",
                        "default": 45
                    },
                    "leadQualityMode": {
                        "title": "Lead quality mode",
                        "enum": [
                            "all",
                            "qualified",
                            "direct_only"
                        ],
                        "type": "string",
                        "description": "Control how strict the output should be: all research signals, qualified warm/direct signals, or strict direct-buyer-intent only.",
                        "default": "all"
                    },
                    "directLeadOnly": {
                        "title": "Direct leads only",
                        "type": "boolean",
                        "description": "Compatibility shortcut for leadQualityMode=direct_only. Direct leads require explicit ask/buying language, so results may be sparse.",
                        "default": false
                    },
                    "includeHigherDifficulty": {
                        "title": "Include harder ideas",
                        "type": "boolean",
                        "description": "Include ideas that are less beginner-friendly but may be more scalable.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
