# Steam Curator Reviews Scraper (`automation-lab/steam-curator-reviews-scraper`) Actor

Extract public Steam curator profiles, follower metrics, and game recommendations.

- **URL**: https://apify.com/automation-lab/steam-curator-reviews-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

## Steam Curator Reviews Scraper

Extract public Steam curator profiles, audience metrics, and game recommendations into clean, analysis-ready records.

Use the Actor to discover outreach targets, monitor launch coverage, compare curator audiences, and build repeatable games-industry research workflows.

It uses public Steam pages, requires no Steam login, and returns data in the default Apify dataset.

### What does Steam Curator Reviews Scraper do?

Steam Curator Reviews Scraper collects two related record types:

- **Curator records** with identity, profile URL, avatar, description, follower count, review count, and recommendation totals when available.
- **Review records** with curator identity, Steam app ID, game title, recommendation status, review text, publication date, and source URL when available.

The Actor accepts the public Steam Curators directory, individual curator profile URLs, or numeric curator IDs.

Responses are pinned to English to make repeated exports easier to compare.

Duplicate records are removed during each run.

### Who is it for?

#### Game publishers

Discover curators with relevant audiences and prioritize outreach using follower and review metrics.

#### PR and creator-relations agencies

Build evidence-based prospect lists and track which curators cover a client launch.

#### Competitive-intelligence teams

Monitor curator recommendations around competing releases and compare recommendation direction.

#### Researchers and analysts

Create structured datasets from a public games-industry influence surface without manually copying profile pages.

#### Indie developers

Find public curators, understand their coverage, and prepare relevant personalized pitches.

### Why use this Actor?

- ⚡ HTTP-first extraction avoids browser overhead.
- 🔐 No Steam account or password is required.
- 📊 Results are normalized for JSON, CSV, Excel, XML, and RSS export.
- 🔁 Stable curator and app IDs support scheduled comparisons.
- 🧹 Per-run deduplication reduces repeated rows.
- 🌍 English locale hints improve output consistency.
- 🔗 Every row retains provenance through `sourceUrl` and `scrapedAt`.

### How to scrape Steam curator reviews

1. Open the Actor input page.
2. Add `https://store.steampowered.com/curators/` to **Steam curator or discovery URLs**.
3. Set **Maximum records** to the number of rows you need.
4. Click **Start**.
5. Wait for the run to finish.
6. Open the **Dataset** tab.
7. Export results as JSON, CSV, Excel, XML, or RSS.
8. Filter `type` to separate curator rows from review rows.

For a known curator, provide its public profile URL or numeric ID instead of the directory URL.

### Input

| Field | Type | Description |
|---|---|---|
| `startUrls` | array | Steam Curators directory URLs or public curator profile URLs. |
| `curatorIds` | string array | Numeric Steam curator/group IDs to fetch directly. |
| `maxItems` | integer | Maximum combined curator and review rows, from 1 to 10,000. |

If no source is provided, the Actor uses the public Steam Curators directory.

#### Directory example

```json
{
  "startUrls": [{ "url": "https://store.steampowered.com/curators/" }],
  "maxItems": 100
}
````

#### Curator ID example

```json
{
  "curatorIds": ["1850"],
  "maxItems": 50
}
```

#### Profile URL example

```json
{
  "startUrls": [{ "url": "https://store.steampowered.com/curator/1850/" }],
  "maxItems": 50
}
```

### Output data

| Field | Applies to | Description |
|---|---|---|
| `type` | all | `curator` or `review`. |
| `curatorId` | all | Stable numeric Steam curator identifier as a string. |
| `curatorName` | all | Public curator display name. |
| `curatorUrl` | all | Canonical curator page URL. |
| `avatarUrl` | curator | Public avatar image URL. |
| `description` | curator | Public profile description. |
| `followerCount` | curator | Visible follower total. |
| `reviewCount` | curator | Visible review total. |
| `recommendedCount` | curator | Visible recommended total. |
| `notRecommendedCount` | curator | Visible not-recommended total. |
| `informativeCount` | curator | Visible informative total. |
| `communityUrl` | curator | Steam Community link when present. |
| `discussionUrl` | curator | Public discussion link when present. |
| `appId` | review | Numeric Steam app ID. |
| `appTitle` | review | Game title when present. |
| `appUrl` | review | Steam store app URL. |
| `recommendation` | review | `recommended`, `not_recommended`, or `informative`. |
| `reviewText` | review | Public curator recommendation text. |
| `postedAt` | review | ISO publication timestamp when exposed by Steam. |
| `sourceUrl` | all | Input page that produced the row. |
| `pageNumber` | all | Source page number. |
| `scrapedAt` | all | ISO extraction timestamp. |

Optional fields are omitted when Steam does not expose them; the Actor does not invent values.

### Example output

```json
{
  "type": "review",
  "curatorId": "1850",
  "curatorName": "Example Curator",
  "curatorUrl": "https://store.steampowered.com/curator/1850/",
  "appId": 570,
  "appTitle": "Dota 2",
  "appUrl": "https://store.steampowered.com/app/570/",
  "recommendation": "recommended",
  "reviewText": "Public recommendation text",
  "sourceUrl": "https://store.steampowered.com/curators/",
  "pageNumber": 1,
  "scrapedAt": "2026-07-12T00:00:00.000Z"
}
```

### How much does it cost to scrape Steam curators?

Pricing is pay per event:

- **Run start:** $0.005 once per run.
- **Dataset item:** tiered by Apify plan.

| Plan | Price per item |
|---|---:|
| FREE | $0.000033038 |
| BRONZE | $0.000028729 |
| SILVER | $0.000022409 |
| GOLD | $0.000017237 |
| PLATINUM | $0.000011492 |
| DIAMOND | $0.000010000 |

A 100-item BRONZE run has an event price of about $0.00787: $0.005 start plus approximately $0.00287 for items. Platform compute and plan terms may also apply.

Use a larger `maxItems` in one run instead of many tiny runs to avoid paying the start event repeatedly.

### Build a Steam curator outreach list

1. Run the directory source.
2. Export the dataset as CSV.
3. Filter rows where `type` equals `curator`.
4. Sort by `followerCount` or `reviewCount`.
5. Read profile descriptions to assess relevance.
6. Visit the retained public curator URL before outreach.

Use the data to qualify contacts, not to send indiscriminate bulk messages.

### Monitor game-launch coverage

Schedule the Actor daily or weekly and retain each dated dataset.

Filter review rows by `appId` after export, then compare curator-and-app keys across runs.

New keys indicate newly observed coverage; recommendation values show the published direction.

Steam may vary which recommendations are exposed on a page, so treat the output as a public-page snapshot rather than a complete historical archive.

### Data quality and limitations

- Steam can change public markup without notice.
- Directory responses may expose only a current subset of curators and recommendations.
- Some profiles do not publish descriptions, dates, discussion links, or recommendation details.
- `maxItems` limits the combined number of curator and review rows.
- The Actor does not access private curators or authenticated content.
- The Actor does not guarantee historical completeness.
- IDs are better join keys than display names.

For critical monitoring, retain prior datasets and compare multiple scheduled snapshots.

### Scheduling and change monitoring

In Apify Console, create a schedule for the Actor and select your saved input.

A weekly cadence works well for market research; launch monitoring may justify a daily cadence.

Connect the resulting dataset to a webhook, Make, Zapier, Google Sheets, or your warehouse.

Deduplicate downstream using `curatorId` for profiles and `curatorId` plus `appId` for recommendations.

### Integrations

#### Google Sheets

Export curator rows to a sheet, rank by audience metrics, and add human qualification columns.

#### Make or Zapier

Trigger a workflow after successful runs and route newly observed app recommendations to Slack or email.

#### Webhooks

Send run completion events to your own endpoint, then fetch the default dataset through the Apify API.

#### Data warehouses

Load JSON or CSV snapshots into BigQuery, Snowflake, or PostgreSQL for longitudinal analysis.

#### Slack alerts

Compare current and previous datasets and alert only when a new curator-and-app pair appears.

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/steam-curator-reviews-scraper').call({
  startUrls: [{ url: 'https://store.steampowered.com/curators/' }],
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/steam-curator-reviews-scraper').call(run_input={
    'startUrls': [{'url': 'https://store.steampowered.com/curators/'}],
    'maxItems': 100,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~steam-curator-reviews-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://store.steampowered.com/curators/"}],"maxItems":100}'
```

Fetch dataset items with the `defaultDatasetId` returned by the run API.

### Use with Apify MCP

Connect Claude Code:

```bash
claude mcp add apify --transport http "https://mcp.apify.com/?tools=automation-lab/steam-curator-reviews-scraper"
```

Claude Desktop configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/steam-curator-reviews-scraper"
    }
  }
}
```

Example prompts:

- “Scrape 100 public Steam curator records and rank curators by followers.”
- “Extract public recommendations for curator ID 1850.”
- “Compare this Steam curator dataset with last week's export and summarize new game coverage.”

### Troubleshooting

#### Why did the run return fewer reviews than expected?

Steam varies which recommendations appear in public responses. Use a canonical curator URL, increase `maxItems`, and inspect the run log for request warnings.

#### Why are optional fields missing?

Not every curator publishes every value. Missing public values are omitted rather than represented with fabricated defaults.

#### Why did the dataset stop at an unexpected record type?

`maxItems` applies to the combined dataset. Curator and review rows both count toward the limit.

#### What should I do after an HTTP warning?

Confirm the URL opens publicly, check that it is a Steam curator or directory URL, and retry later if Steam is temporarily unavailable.

#### Can the Actor scrape private curator data?

No. It intentionally processes public pages only.

### Legality and responsible use

This Actor extracts publicly available information.

You are responsible for ensuring that your use complies with Steam terms, applicable laws, privacy requirements, and outreach regulations.

Use conservative schedules, collect only data needed for a legitimate purpose, secure exported datasets, and honor deletion or objection requests where applicable.

Do not use the Actor to bypass access controls, impersonate users, or facilitate spam.

### FAQ

#### Does it require a Steam login?

No. The Actor uses public Steam curator surfaces.

#### Can I supply multiple curator IDs?

Yes. Add multiple numeric strings to `curatorIds`; all rows share the same `maxItems` budget.

#### Which export formats are available?

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

#### Are results deduplicated?

Yes, within each run. Use stable IDs to deduplicate across scheduled runs.

#### Can I monitor one game directly?

The Actor does not expose an app-ID input filter. Export recommendations and filter the numeric `appId` downstream.

### Related Automation Lab actors

- [Steam Scraper](https://apify.com/automation-lab/steam-scraper) — collect Steam game catalog and store metadata.
- [Steam Workshop Scraper](https://apify.com/automation-lab/steam-workshop-scraper) — collect public Workshop items and creator data.

Use this Actor for curator profiles and curator recommendations; use the related actors when the primary entity is a game or Workshop item.

### Support

If a valid public Steam curator URL produces no output, open an issue from the Actor page.

Include the input, run ID, expected result, and a public example URL.

Do not include credentials or private personal data in support requests.

# Actor input Schema

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

Steam Curators directory or public curator profile URLs.

## `curatorIds` (type: `array`):

Numeric Steam curator/group IDs.

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

Stop after this many curator or review records.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://store.steampowered.com/curators/"
    }
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "startUrls": [
        {
            "url": "https://store.steampowered.com/curators/"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/steam-curator-reviews-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "startUrls": [{ "url": "https://store.steampowered.com/curators/" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/steam-curator-reviews-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    {
      "url": "https://store.steampowered.com/curators/"
    }
  ],
  "maxItems": 10
}' |
apify call automation-lab/steam-curator-reviews-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Steam Curator Reviews Scraper",
        "description": "Extract public Steam curator profiles, follower metrics, and game recommendations.",
        "version": "0.1",
        "x-build-id": "f5tG5KUEevgFuwR6G"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~steam-curator-reviews-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-steam-curator-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~steam-curator-reviews-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-steam-curator-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~steam-curator-reviews-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-steam-curator-reviews-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "startUrls": {
                        "title": "🎯 Steam curator or discovery URLs",
                        "type": "array",
                        "description": "Steam Curators directory or public curator profile URLs.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "curatorIds": {
                        "title": "Curator IDs",
                        "type": "array",
                        "description": "Numeric Steam curator/group IDs.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum records",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many curator or review records.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```