# Reddit Subreddit Search Scraper (`khadinakbar/reddit-subreddit-search-scraper`) Actor

Find public Reddit communities by keyword with activity, descriptions, and direct URLs. MCP-ready. $0.005/query + $0.01/community, plus platform usage.

- **URL**: https://apify.com/khadinakbar/reddit-subreddit-search-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, AI, MCP servers
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 subreddit founds

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

## Reddit Subreddit Search Scraper

Discover public Reddit communities from keywords and return clean subreddit metadata for market research, audience discovery, content planning, and AI-agent workflows.

Use this actor when you need to answer questions such as “Which public Reddit communities discuss AI safety?”, “What subreddits reach SaaS founders?”, or “Find active communities around personal finance.” It returns one record per subreddit with a canonical name, URL, subscriber count, activity count when exposed, content-safety flag, and the search query that found it.

This is deliberately a community-discovery tool. It does not scrape Reddit posts, comments, user profiles, private communities, or membership lists. Use a dedicated Reddit posts scraper after selecting the relevant communities.

### When to use it

- Find relevant subreddits before launching a social-listening or market-research workflow.
- Build a community list for an editorial calendar, sponsorship research, or competitor analysis.
- Identify public audiences for a niche such as “remote accounting,” “indie hackers,” or “machine learning.”
- Give an AI agent a small, predictable tool for choosing a public Reddit community instead of returning an unbounded set of posts and comments.
- Enrich a research brief with audience size, community title, public description, and a direct community URL.

Do not use this actor to find a particular Reddit post, scrape comment threads, collect user data, or access content that is private, quarantined, or otherwise unavailable publicly.

### What you get

Each dataset item has a stable, agent-friendly structure. `concise` mode keeps records small for automation; `detailed` mode adds public descriptions and artwork URLs when Reddit exposes them.

| Field | Description |
| --- | --- |
| `subreddit` | Canonical label, for example `r/MachineLearning` |
| `subredditName` | Community name without the `r/` prefix |
| `subredditUrl` | Direct browser URL to the public community |
| `title` | Human-facing community title, when supplied by Reddit |
| `subscribers` | Reported subscriber count, when available |
| `activeUsers` | Reported activity metric, when available |
| `isNsfw` | Whether Reddit marks the community as adult content |
| `publicDescription` | Public description in detailed mode |
| `searchQuery` | Input phrase that matched the community |
| `source` | `reddit-oauth`, `reddit-public-json`, or `scrapecreators` |
| `scrapedAt` | ISO-8601 normalization time |

The actor also writes `OUTPUT` and `RUN_SUMMARY` to its default key-value store. These records report the terminal outcome (`COMPLETE`, `PARTIAL`, `VALID_EMPTY`, `INVALID_INPUT`, or `UPSTREAM_FAILED`), source requests, filters, validation skips, and charged event counts. This makes an API or MCP workflow easy to audit without putting summary rows into the dataset.

### Input

`queries` is an array of one to twenty short phrases. The default is `artificial intelligence`, so the Actor has a safe health-check input. Query terms are matched by Reddit’s community search surface; they are not Reddit URLs and are not post-content searches.

`maxSubreddits` caps all unique records returned across all queries. It accepts 1–100 and is the principal cost control. `minSubscribers` filters out smaller communities. `sort` applies after deduplication and can keep Reddit’s relevance order or order by reported subscriber count, activity, or newest known community. Adult-marked communities are excluded unless `includeNsfw` is true. Select `responseFormat: "detailed"` only when you need descriptions and image URLs.

```json
{
  "queries": ["machine learning", "AI safety"],
  "maxSubreddits": 25,
  "minSubscribers": 1000,
  "sort": "subscribers",
  "includeNsfw": false,
  "responseFormat": "detailed"
}
````

### How retrieval works

The actor first uses owner-managed Reddit OAuth when it is configured. If that route is temporarily unavailable, it tries Reddit’s public JSON endpoint. If native routes are blocked or rate-limited, it falls back to ScrapeCreators’ verified public Reddit endpoints: a site search identifies candidate community names, then the provider’s subreddit-details endpoint supplies the public metadata required by the schema.

Users never need to provide Reddit credentials, browser cookies, or a provider API key. All access is owner-managed and public-data-only. The `source` field makes every returned record traceable to the route that supplied it. A successful fallback is reported as a normal completed run; a run becomes `PARTIAL` only if an advertised source route still leaves useful work incomplete.

### Pricing

This Actor uses **Pay per event + usage**. Event charges are simple and predictable; Apify compute and proxy usage are passed through separately by the platform.

| Event | Price | When charged |
| --- | ---: | --- |
| Actor start | $0.00005 | Once when a run starts |
| Search query processed | $0.005 | Once after each requested community search is processed |
| Subreddit found | $0.01 | Once for each validated community written to the dataset |

A run with one query and ten returned communities has $0.10505 in event charges, plus platform usage. Three processed queries and 25 returned communities cost $0.26505 in event charges, plus platform usage. `maxSubreddits` bounds result charges, and the actor prints the maximum possible event charge before it starts work.

The fallback provider uses one credit for a search plus one credit for each detailed community record. The event model keeps a healthy margin even when a user runs a small, multi-query discovery task, while avoiding any hidden provider fee.

### Run through the API

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('khadinakbar/reddit-subreddit-search-scraper').call({
  queries: ['indie hackers', 'bootstrapped SaaS'],
  maxSubreddits: 20,
  sort: 'activity',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient(token='YOUR_APIFY_TOKEN')
run = client.actor('khadinakbar/reddit-subreddit-search-scraper').call(
    run_input={"queries": ["personal finance"], "maxSubreddits": 15}
)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/khadinakbar~reddit-subreddit-search-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"queries":["remote work"],"maxSubreddits":10}'
```

### Practical tips

Use multiple precise phrases instead of one vague phrase when researching adjacent audiences. For example, `"technical writing"`, `"developer relations"`, and `"docs as code"` provide a more controllable community set than `"writing"`. Use a positive `minSubscribers` threshold when you only need established communities, but leave it at zero when researching small emerging niches. Detailed mode is useful for human review; concise mode is usually the better default for agents and scheduled automations.

Results depend on public Reddit and provider metadata at the time of the request. Subscriber and activity counts can be unavailable, delayed, or rounded by the source. `activity` sorting uses the reported activity metric only when it is exposed; it is not a live traffic guarantee. The actor never infers missing values or invents community metadata.

### FAQ

#### Does this scrape posts or comments?

No. It finds and describes communities only. This keeps runs faster, output smaller, and the actor’s MCP scope unambiguous.

#### Do I need a Reddit account or cookies?

No. The actor uses owner-managed public access routes. Do not put Reddit passwords, session cookies, or API keys in the input.

#### What happens when a search has no matching communities?

The run succeeds with `VALID_EMPTY`, an empty dataset, and a clear message in `OUTPUT` and `RUN_SUMMARY`. Broaden the phrase or lower `minSubscribers` before trying again.

#### Why did a run return `PARTIAL`?

Some useful records were stored, but a source route, provider detail lookup, schema validation, or your charge cap prevented the actor from completing the full requested work. The exact reason is in `RUN_SUMMARY`.

#### Is this an official Reddit API client?

No. It is an independent Apify Actor that retrieves public community metadata. Follow applicable laws, platform rules, and your organization’s data-use requirements.

### Data-use notice

Only use this actor for lawful, authorized purposes and handle returned public data responsibly. Do not use it to identify, profile, or target individuals in ways that violate privacy, platform rules, or applicable law.

# Actor input Schema

## `queries` (type: `array`):

Use this when you need to discover public Reddit communities from keywords. Pass one or more phrases such as "machine learning" or "personal finance". Defaults to "artificial intelligence" and accepts at most 20 distinct phrases. This is not a subreddit URL, post URL, or Reddit username.

## `maxSubreddits` (type: `integer`):

Use this to cap the total unique communities returned across every query. Pass an integer such as 25. Defaults to 25 and accepts 1 through 100, which also caps event charges. This is not a number of posts, comments, or results per query.

## `minSubscribers` (type: `integer`):

Use this to filter out communities below a subscriber threshold. Pass an integer such as 10000. Defaults to 0 and accepts 0 through 1,000,000,000; communities with an unavailable count do not pass a positive threshold. This is not a sort order or a guaranteed active-user count.

## `sort` (type: `string`):

Use this to choose how matching communities are ordered after deduplication. Choose relevance, subscribers, activity, or newest; for example, "subscribers" ranks the largest known communities first. Defaults to relevance. This does not change Reddit's matching logic or search inside post content.

## `includeNsfw` (type: `boolean`):

Use this only when adult-marked public communities are appropriate for the research task. Pass true to include a community whose Reddit metadata is marked NSFW, for example true. Defaults to false. This does not bypass Reddit safety controls or access private communities.

## `responseFormat` (type: `string`):

Use this to balance agent context size against metadata depth. Choose concise for identifiers, counts, URLs, and status, or detailed for descriptions and artwork URLs; for example, "concise". Defaults to concise. This does not affect matching, filtering, or billing per returned community.

## Actor input object example

```json
{
  "queries": [
    "machine learning",
    "AI safety"
  ],
  "maxSubreddits": 25,
  "minSubscribers": 10000,
  "sort": "subscribers",
  "includeNsfw": false,
  "responseFormat": "concise"
}
```

# Actor output Schema

## `results` (type: `string`):

Validated public Reddit community records returned by the requested searches.

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

Terminal outcome, item count, diagnostics, and billable-event counts.

## `runSummary` (type: `string`):

Detailed retrieval, filtering, validation, fallback, and billing telemetry.

# 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 = {
    "queries": [
        "machine learning",
        "AI safety"
    ],
    "maxSubreddits": 25,
    "minSubscribers": 1000,
    "sort": "relevance",
    "includeNsfw": false,
    "responseFormat": "concise"
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/reddit-subreddit-search-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 = {
    "queries": [
        "machine learning",
        "AI safety",
    ],
    "maxSubreddits": 25,
    "minSubscribers": 1000,
    "sort": "relevance",
    "includeNsfw": False,
    "responseFormat": "concise",
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/reddit-subreddit-search-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 '{
  "queries": [
    "machine learning",
    "AI safety"
  ],
  "maxSubreddits": 25,
  "minSubscribers": 1000,
  "sort": "relevance",
  "includeNsfw": false,
  "responseFormat": "concise"
}' |
apify call khadinakbar/reddit-subreddit-search-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=khadinakbar/reddit-subreddit-search-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Reddit Subreddit Search Scraper",
        "description": "Find public Reddit communities by keyword with activity, descriptions, and direct URLs. MCP-ready. $0.005/query + $0.01/community, plus platform usage.",
        "version": "1.2",
        "x-build-id": "jfeNKM0JvxrAc5fCG"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~reddit-subreddit-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-reddit-subreddit-search-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/khadinakbar~reddit-subreddit-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-reddit-subreddit-search-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/khadinakbar~reddit-subreddit-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-reddit-subreddit-search-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": {
                    "queries": {
                        "title": "Subreddit search queries",
                        "type": "array",
                        "description": "Use this when you need to discover public Reddit communities from keywords. Pass one or more phrases such as \"machine learning\" or \"personal finance\". Defaults to \"artificial intelligence\" and accepts at most 20 distinct phrases. This is not a subreddit URL, post URL, or Reddit username.",
                        "default": [
                            "artificial intelligence"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxSubreddits": {
                        "title": "Maximum subreddits",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Use this to cap the total unique communities returned across every query. Pass an integer such as 25. Defaults to 25 and accepts 1 through 100, which also caps event charges. This is not a number of posts, comments, or results per query.",
                        "default": 25
                    },
                    "minSubscribers": {
                        "title": "Minimum subscriber count",
                        "minimum": 0,
                        "maximum": 1000000000,
                        "type": "integer",
                        "description": "Use this to filter out communities below a subscriber threshold. Pass an integer such as 10000. Defaults to 0 and accepts 0 through 1,000,000,000; communities with an unavailable count do not pass a positive threshold. This is not a sort order or a guaranteed active-user count.",
                        "default": 0
                    },
                    "sort": {
                        "title": "Result order",
                        "enum": [
                            "relevance",
                            "subscribers",
                            "activity",
                            "newest"
                        ],
                        "type": "string",
                        "description": "Use this to choose how matching communities are ordered after deduplication. Choose relevance, subscribers, activity, or newest; for example, \"subscribers\" ranks the largest known communities first. Defaults to relevance. This does not change Reddit's matching logic or search inside post content.",
                        "default": "relevance"
                    },
                    "includeNsfw": {
                        "title": "Include NSFW communities",
                        "type": "boolean",
                        "description": "Use this only when adult-marked public communities are appropriate for the research task. Pass true to include a community whose Reddit metadata is marked NSFW, for example true. Defaults to false. This does not bypass Reddit safety controls or access private communities.",
                        "default": false
                    },
                    "responseFormat": {
                        "title": "Response detail",
                        "enum": [
                            "concise",
                            "detailed"
                        ],
                        "type": "string",
                        "description": "Use this to balance agent context size against metadata depth. Choose concise for identifiers, counts, URLs, and status, or detailed for descriptions and artwork URLs; for example, \"concise\". Defaults to concise. This does not affect matching, filtering, or billing per returned community.",
                        "default": "concise"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```