# Peptide Market Intelligence Scraper (`constructive_calm/peptide-market-intel`) Actor

Track GLP-1s, BPC-157, and 30+ peptide compounds across Reddit, YouTube, and Amazon with sentiment, intent, and vendor leaderboards.

- **URL**: https://apify.com/constructive\_calm/peptide-market-intel.md
- **Developed by:** [Omar Eldeeb](https://apify.com/constructive_calm) (community)
- **Categories:** SEO tools, E-commerce, Social media
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.012 / peptide mention (enriched row)

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.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

## Peptide Market Intelligence Scraper

**Track GLP-1s, BPC-157, and 30+ peptide compounds across Reddit, YouTube, and Amazon with sentiment, intent, and vendor leaderboards.**

### What does Peptide Market Intelligence do?

This actor aggregates peptide-related consumer conversation from Reddit, YouTube, and Amazon in a single run, then enriches every matched mention with compound disambiguation, sentiment, intent classification, and vendor/brand extraction via Gemini 2.5 Flash.

It produces a unified dataset plus aggregate Key-Value Store reports for supplement DTC brands, peptide market researchers, and market-intelligence teams tracking consumer demand around compounds such as semaglutide, tirzepatide, retatrutide, BPC-157, TB-500, MK-677, CJC-1295, GHK-Cu, and related aliases.

Target sources:

- Reddit posts
- YouTube video search results
- Amazon product search results

TikTok is available only as an experimental opt-in and is off by default.

### Why use this actor?

- **Unified schema** - one mention row shape across Reddit, YouTube, and Amazon, joined by canonical compound.
- **Noise filtered out** - peptide-keyword hits that do not contain a resolved compound are dropped before billing.
- **Compound disambiguation** - slang and brand names such as sema, tirz, Ozempic, Wegovy, and Mounjaro collapse to canonical compound names.
- **Vendor leaderboards** - see which consumer peptide retailers are discussed, broken down by sentiment when Gemini enrichment is enabled.
- **Trending compound deltas** - set a stable `datasetName` across scheduled runs to get week-over-week mention-count changes per compound.
- **Auto-discovery** - Gemini can flag compound-like terms that are not yet in the vocabulary for later review.

### How to use

1. Open the input form.
2. Pick sources. Default is YouTube and Amazon. Add Reddit when you want extra coverage and can tolerate occasional 403s from Apify cloud.
3. Optionally filter by `compoundCategories`.
4. Start with `maxItemsPerSource: 30` to preview before scaling up.
5. Keep `enrichmentMode: "full"` for Gemini sentiment, intent, vendor, and brand extraction.
6. Open the Dataset tab for individual mentions and the Key-Value Store tab for aggregate reports.

### Input

Example production input:

```json
{
  "sources": ["youtube", "amazon"],
  "compoundCategories": ["GLP-1", "healing"],
  "maxItemsPerSource": 25,
  "enrichmentMode": "full",
  "includeAggregates": true
}
````

Example broad input:

```json
{
  "sources": ["reddit", "youtube", "amazon"],
  "compoundCategories": ["GLP-1", "healing"],
  "customVocabulary": ["orforglipron"],
  "maxItemsPerSource": 500,
  "enrichmentMode": "full",
  "includeAggregates": true,
  "autoDiscover": false,
  "datasetName": "peptide-intel-weekly"
}
```

### Output

Dataset row, one per matched mention:

```json
{
  "id": "youtube:video:TX5lzmQLg30",
  "source": "youtube",
  "sourceUrl": "https://youtube.com/watch?v=TX5lzmQLg30&lc=video:TX5lzmQLg30",
  "nativeId": "video:TX5lzmQLg30",
  "text": "BPC-157 Explained: The Peptide That Speeds Up Recovery...",
  "author": "Jonathan Schoeff",
  "createdAt": "2026-05-01T11:30:34.711Z",
  "engagement": {},
  "context": {
    "videoId": "TX5lzmQLg30",
    "videoTitle": "BPC-157 Explained: The Peptide That Speeds Up Recovery"
  },
  "compounds": ["BPC-157"],
  "compoundCategory": "healing",
  "compoundAliases": ["BPC-157", "Bpc 157"],
  "sentiment": { "label": "neutral", "score": 0.9 },
  "intent": "other",
  "vendorMentions": [],
  "brandMentions": [],
  "enriched": true
}
```

Key-Value Store reports:

- `TOP_COMPOUNDS` - mention count per compound, overall and per source
- `VENDOR_LEADERBOARD` - top consumer peptide vendors with sentiment breakdown
- `SENTIMENT_BY_COMPOUND` - label distribution per compound for brand-risk monitoring
- `TRENDING_COMPOUNDS_7D` - week-over-week deltas when `datasetName` is set across scheduled runs
- `SUGGESTED_VOCABULARY` - new compound candidates when `autoDiscover: true`
- `RUN_SUMMARY` - per-source counts, enrichment stats, event totals

### Data fields

| Field | Description |
|---|---|
| `id` | Stable dedupe key: `${source}:${nativeId}` |
| `source` | `reddit`, `youtube`, `amazon`, or experimental `tiktok` |
| `sourceUrl` | Canonical URL back to the item |
| `text` | Source text normalized into a single field |
| `author` | Username, handle, channel, or public author when available |
| `createdAt` | ISO-8601 UTC timestamp |
| `engagement.upvotes` | Reddit ups, YouTube likes, or Amazon helpful votes when available |
| `engagement.rating` | Amazon 1-5 star rating when available |
| `context.subreddit` | Reddit-only context |
| `context.videoId` | YouTube-only context |
| `context.asin` | Amazon-only context |
| `compounds` | Canonical compound names |
| `compoundCategory` | `GLP-1`, `healing`, `GH-GHRP`, `cosmetic`, `sexual`, `nootropic`, or `longevity` |
| `compoundAliases` | Raw alias/slang hits from the text |
| `sentiment.label` | `positive`, `neutral`, or `negative` |
| `sentiment.score` | 0..1 confidence |
| `intent` | `vendor-question`, `experience-report`, `dosage-question`, `side-effect`, `price-inquiry`, or `other` |
| `vendorMentions` | Consumer peptide retailer names |
| `brandMentions` | Drug brand names such as Ozempic, Wegovy, and Mounjaro |
| `enriched` | `true` if Gemini processed this row |

### Pricing and cost estimation

Pay-per-event pricing:

- **Actor start** - $0.01 per run
- **Peptide mention** - $0.01 per enriched mention row
- **Aggregate report** - $0.03 per Key-Value Store aggregate doc, up to 4 charged aggregate docs per normal run

The first 50 chargeable events per run are free. A small preview run with `maxItemsPerSource: 30` usually stays mostly or fully inside the free event allowance after the actor start fee.

A typical weekly scan with `maxItemsPerSource: 500` across all active sources may produce around 600 enriched mentions after the regex noise filter, costing roughly **$6.13 per run**: $0.01 actor start, about $6.00 for mentions, and about $0.12 for aggregate reports. Heavier runs with `maxItemsPerSource: 5000` may produce around 6,000 enriched mentions for about **$60.13**.

### Tips and advanced options

- **Start small**: use `maxItemsPerSource: 30` and one or two sources for a preview run.
- **Named dataset for deltas**: set `datasetName` to something stable, such as `peptide-weekly`, and schedule the actor.
- **Customize the consumer overlay**: edit the `VOCAB_CONSUMER_OVERLAY` Key-Value Store record to add slang, brand names, or experimental compounds without redeploying.
- **Auto-discovery loop**: run with `autoDiscover: true`, review `SUGGESTED_VOCABULARY`, then promote good candidates into `customVocabulary` or the overlay record.
- **Raw mode**: set `enrichmentMode: "raw"` to skip Gemini enrichment. It is faster, but sentiment, intent, vendor, and brand fields will be empty.

### FAQ, disclaimers, and support

- **Is scraping this legal?** Reddit, YouTube, and Amazon all have terms of service. You are responsible for ensuring your use case complies with each platform's ToS and applicable law.
- **No medical advice.** Mentions extracted from consumer platforms are user-generated and not medical advice. This actor is a market-intelligence tool, not a clinical reference.
- **Known limitations**: Google Trends is currently disabled because its public endpoints return rate limits/HTML too often for reliable production runs. Reddit can return 403 from Apify cloud in some runs. TikTok is experimental and off by default. Amazon vendor mentions are rare because retailers often obfuscate peptide names.
- **Support**: report issues or feature requests via the Issues tab on this actor's page.

# Actor input Schema

## `sources` (type: `array`):

Which channels to aggregate peptide mentions from. YouTube and Amazon are enabled by default. Reddit is available as opt-in but can return 403 from Apify cloud.

## `compoundCategories` (type: `array`):

Filter the resolved vocabulary by therapeutic category. Leave empty to track all categories. Categories come from UniProt keywords + the consumer overlay.

## `customVocabulary` (type: `array`):

Add peptide compounds (canonical names) to track beyond the resolved UniProt + consumer-overlay list. Useful for experimental or newly-launched compounds not yet in the public vocabulary.

## `maxItemsPerSource` (type: `integer`):

Cap the number of items fetched from each mention-producing source (Reddit, YouTube, Amazon). Higher values increase coverage and runtime. Start low (30-100) to preview before scaling up.

## `enrichmentMode` (type: `string`):

full = Gemini 2.5 Flash adds compound disambiguation, sentiment (positive/neutral/negative + score), intent classification, and vendor/brand extraction. raw = faster, no LLM fields; rows still have deterministic compound + alias matches. Same price per mention either way.

## `includeAggregates` (type: `boolean`):

Write TOP\_COMPOUNDS, VENDOR\_LEADERBOARD, SENTIMENT\_BY\_COMPOUND, and TRENDING\_COMPOUNDS\_7D to the Key-Value Store. Recommended: this is where the cross-source intelligence lives.

## `autoDiscover` (type: `boolean`):

Ask Gemini to flag compound-like terms that look like peptides but aren't in the resolved vocabulary. Results land in the SUGGESTED\_VOCABULARY KV doc. Review them and add promising ones to customVocabulary or the VOCAB\_CONSUMER\_OVERLAY KV record on next run.

## `datasetName` (type: `string`):

Set a persistent dataset name across scheduled runs to get week-over-week TRENDING\_COMPOUNDS\_7D deltas. Leave empty for one-off runs; the trending doc will return a note rather than real deltas.

## Actor input object example

```json
{
  "sources": [
    "youtube",
    "amazon"
  ],
  "compoundCategories": [
    "GLP-1",
    "healing"
  ],
  "customVocabulary": [],
  "maxItemsPerSource": 500,
  "enrichmentMode": "full",
  "includeAggregates": true,
  "autoDiscover": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Normalized mention rows from Reddit, YouTube, and Amazon with compound, sentiment, intent, and vendor fields.

## `keyValueStore` (type: `string`):

TOP\_COMPOUNDS, VENDOR\_LEADERBOARD, SENTIMENT\_BY\_COMPOUND, TRENDING\_COMPOUNDS\_7D, SUGGESTED\_VOCABULARY, RUN\_SUMMARY.

# 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 = {
    "sources": [
        "youtube",
        "amazon"
    ],
    "compoundCategories": [
        "GLP-1",
        "healing"
    ],
    "customVocabulary": [],
    "maxItemsPerSource": 500,
    "enrichmentMode": "full"
};

// Run the Actor and wait for it to finish
const run = await client.actor("constructive_calm/peptide-market-intel").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 = {
    "sources": [
        "youtube",
        "amazon",
    ],
    "compoundCategories": [
        "GLP-1",
        "healing",
    ],
    "customVocabulary": [],
    "maxItemsPerSource": 500,
    "enrichmentMode": "full",
}

# Run the Actor and wait for it to finish
run = client.actor("constructive_calm/peptide-market-intel").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 '{
  "sources": [
    "youtube",
    "amazon"
  ],
  "compoundCategories": [
    "GLP-1",
    "healing"
  ],
  "customVocabulary": [],
  "maxItemsPerSource": 500,
  "enrichmentMode": "full"
}' |
apify call constructive_calm/peptide-market-intel --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=constructive_calm/peptide-market-intel",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Peptide Market Intelligence Scraper",
        "description": "Track GLP-1s, BPC-157, and 30+ peptide compounds across Reddit, YouTube, and Amazon with sentiment, intent, and vendor leaderboards.",
        "version": "1.0",
        "x-build-id": "UEc6O6hB4FSfHpJYR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/constructive_calm~peptide-market-intel/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-constructive_calm-peptide-market-intel",
                "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/constructive_calm~peptide-market-intel/runs": {
            "post": {
                "operationId": "runs-sync-constructive_calm-peptide-market-intel",
                "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/constructive_calm~peptide-market-intel/run-sync": {
            "post": {
                "operationId": "run-sync-constructive_calm-peptide-market-intel",
                "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",
                "required": [
                    "sources"
                ],
                "properties": {
                    "sources": {
                        "title": "Sources",
                        "type": "array",
                        "description": "Which channels to aggregate peptide mentions from. YouTube and Amazon are enabled by default. Reddit is available as opt-in but can return 403 from Apify cloud.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "reddit",
                                "youtube",
                                "amazon"
                            ],
                            "enumTitles": [
                                "Reddit",
                                "YouTube videos",
                                "Amazon product search"
                            ]
                        },
                        "default": [
                            "youtube",
                            "amazon"
                        ]
                    },
                    "compoundCategories": {
                        "title": "Compound categories",
                        "type": "array",
                        "description": "Filter the resolved vocabulary by therapeutic category. Leave empty to track all categories. Categories come from UniProt keywords + the consumer overlay.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "GLP-1",
                                "healing",
                                "GH-GHRP",
                                "cosmetic",
                                "sexual",
                                "nootropic",
                                "longevity"
                            ]
                        },
                        "default": []
                    },
                    "customVocabulary": {
                        "title": "Custom compound vocabulary",
                        "type": "array",
                        "description": "Add peptide compounds (canonical names) to track beyond the resolved UniProt + consumer-overlay list. Useful for experimental or newly-launched compounds not yet in the public vocabulary.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItemsPerSource": {
                        "title": "Max items per source",
                        "minimum": 10,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Cap the number of items fetched from each mention-producing source (Reddit, YouTube, Amazon). Higher values increase coverage and runtime. Start low (30-100) to preview before scaling up.",
                        "default": 30
                    },
                    "enrichmentMode": {
                        "title": "Enrichment mode",
                        "enum": [
                            "full",
                            "raw"
                        ],
                        "type": "string",
                        "description": "full = Gemini 2.5 Flash adds compound disambiguation, sentiment (positive/neutral/negative + score), intent classification, and vendor/brand extraction. raw = faster, no LLM fields; rows still have deterministic compound + alias matches. Same price per mention either way.",
                        "default": "full"
                    },
                    "includeAggregates": {
                        "title": "Include aggregate reports",
                        "type": "boolean",
                        "description": "Write TOP_COMPOUNDS, VENDOR_LEADERBOARD, SENTIMENT_BY_COMPOUND, and TRENDING_COMPOUNDS_7D to the Key-Value Store. Recommended: this is where the cross-source intelligence lives.",
                        "default": true
                    },
                    "autoDiscover": {
                        "title": "Auto-discover new compounds",
                        "type": "boolean",
                        "description": "Ask Gemini to flag compound-like terms that look like peptides but aren't in the resolved vocabulary. Results land in the SUGGESTED_VOCABULARY KV doc. Review them and add promising ones to customVocabulary or the VOCAB_CONSUMER_OVERLAY KV record on next run.",
                        "default": false
                    },
                    "datasetName": {
                        "title": "Named dataset (enables 7-day trending deltas)",
                        "type": "string",
                        "description": "Set a persistent dataset name across scheduled runs to get week-over-week TRENDING_COMPOUNDS_7D deltas. Leave empty for one-off runs; the trending doc will return a note rather than real deltas."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
