# Patreon Scraper (`crawlerbros/patreon-scraper`) Actor

Scrape Patreon creators (campaigns) with campaign metadata, tier pricing, public posts, and patron counts.

- **URL**: https://apify.com/crawlerbros/patreon-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Social media, Developer tools, Lead generation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 17 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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.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

## Patreon Scraper

Scrape **Patreon** creators (campaigns) — name, summary, patron count, paid-member count, total post count, currency, tier pricing (with USD conversion), and recent public posts. No login required, pure HTTP using Patreon's `__NEXT_DATA__` payload + public posts API.

Built for creator-economy analytics, brand-deal teams, and competitive research on Patreon-monetised creators.

### What you get

#### Creator records (`recordType=creator`)

| Field | Description |
| --- | --- |
| `id` | Patreon campaign ID |
| `vanity` | Vanity slug (`PhilosophyTube`) |
| `url` | Public Patreon URL |
| `name` | Campaign name |
| `summary` | Plain-text campaign description |
| `oneLiner` | Short tagline |
| `creationName` | What the creator makes (e.g. "Creating Philosophy Videos") |
| `currency` | Currency code (USD / EUR / GBP / …) |
| `patronCount` | Total patron count (free + paid) |
| `paidMemberCount` | Paid-member count |
| `creationCount` | Total post count |
| `payPerName` | "month" / "video" / "creation" |
| `isMonthly` | `true` if billing is monthly |
| `isNsfw` | `true` for adult content |
| `offersFreeMembership` | Whether a free tier exists |
| `offersPaidMembership` | Whether paid tiers exist |
| `publishedAt` | ISO 8601 launch date |
| `avatarPhotoUrl` | Avatar image URL |
| `coverPhotoUrl` | Banner image URL |
| `pledgeUrl` | Direct checkout URL |
| `creator` | `{fullName, vanity, url}` for the underlying user |
| `tiers` | Array of paid tiers (sorted by price ascending) |
| `scrapedAt` | ISO 8601 UTC timestamp |

Each tier in `tiers`:

| Field | Description |
| --- | --- |
| `id` | Tier (reward) ID |
| `title` | Tier title |
| `description` | Tier description (plain text) |
| `amountCents` | Price in cents |
| `amountUsd` | Price as a decimal USD/local-currency value |
| `currency` | Currency code |
| `patronCount` | Patrons on this tier |
| `requiresShipping` | `true` if physical fulfilment required |
| `imageUrl` | Tier illustration URL |

#### Post records (`recordType=post`)

| Field | Description |
| --- | --- |
| `id` | Post ID |
| `vanity` | Creator vanity (added by us) |
| `title` | Post title |
| `publishedAt` | ISO 8601 publish timestamp |
| `url` | Public post URL |
| `postType` | `video_external_file`, `image_file`, `text_only`, `audio_file`, `link`, … |
| `isPaid` | `true` if patron-only |
| `isPublic` | `true` if visible to anonymous users |
| `patronCount` | Number of patrons who can see the post |
| `commentCount` | Comment count |
| `likeCount` | Like count |
| `teaserText` | Plain-text teaser (when paid post has a public teaser) |
| `content` | Plain-text body (when public) |
| `thumbnailUrl` | Thumbnail image URL |

Empty fields are dropped from every record at every depth.

### Input

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | Enum | `creator` | `creator` (campaign + tiers + posts) / `posts` (posts only) / `search` (creators by keyword) / `explore` (browse by category) / `postByUrl` (single post by URL) |
| `creators` | Array | `["PhilosophyTube"]` | Vanity slugs or full URLs (mode=creator/posts) |
| `searchQuery` | String | — | Keyword for `mode=search` |
| `category` | Enum | — | Patreon Explore category — `podcasts`, `video-film`, `music`, `visual-arts`, `comedy`, `games`, `writing`, `drawing-painting`, `comics-graphic-novels`, `tabletop-games`, `science`, `education`, `crafts-diy`, `lifestyle` |
| `postUrls` | Array | — | Patreon post URLs (`https://www.patreon.com/posts/<id>`) for `mode=postByUrl` |
| `includePosts` | Boolean | `true` | When `mode=creator`, also fetch posts |
| `maxPostsPerCreator` | Integer | `20` | Hard cap per-creator post emission (1-200) |
| `minPatronCount` | Integer | — | Drop creators with fewer patrons |
| `excludeNsfw` | Boolean | `false` | Drop NSFW creators |
| `maxItems` | Integer | `50` | Hard cap on total emitted records (1-5000) |

#### Example input — single creator + posts

```json
{
  "mode": "creator",
  "creators": ["PhilosophyTube"],
  "includePosts": true,
  "maxPostsPerCreator": 20
}
````

#### Example input — batch creators

```json
{
  "mode": "creator",
  "creators": ["jordanbpeterson", "PhilosophyTube"],
  "includePosts": false,
  "minPatronCount": 1000
}
```

#### Example input — posts only

```json
{
  "mode": "posts",
  "creators": ["PhilosophyTube"],
  "maxPostsPerCreator": 100
}
```

#### Example input — search creators

```json
{
  "mode": "search",
  "searchQuery": "philosophy",
  "minPatronCount": 500,
  "maxItems": 50
}
```

#### Example input — explore by category

```json
{
  "mode": "explore",
  "category": "podcasts",
  "maxItems": 50
}
```

#### Example input — fetch post by URL

```json
{
  "mode": "postByUrl",
  "postUrls": [
    "https://www.patreon.com/posts/85614999",
    "https://www.patreon.com/posts/welcome-to-the-12345"
  ]
}
```

### Example output

```json
{
  "recordType": "creator",
  "id": "114875",
  "vanity": "PhilosophyTube",
  "url": "https://www.patreon.com/PhilosophyTube",
  "name": "Philosophy Tube",
  "creationName": "Creating Philosophy Videos",
  "oneLiner": "Giving away a philosophy degree one video at a time.",
  "summary": "When the British government tripled university tuition in 2010 …",
  "currency": "USD",
  "patronCount": 15382,
  "paidMemberCount": 5233,
  "creationCount": 756,
  "payPerName": "month",
  "offersFreeMembership": true,
  "offersPaidMembership": true,
  "publishedAt": "2014-09-21T17:34:46.000+00:00",
  "creator": {
    "fullName": "Philosophy Tube",
    "vanity": "PhilosophyTube",
    "url": "https://www.patreon.com/PhilosophyTube"
  },
  "tiers": [
    { "id": "...", "title": "Patron", "amountCents": 200, "amountUsd": 2.00, "currency": "USD" },
    { "id": "...", "title": "Producer", "amountCents": 500, "amountUsd": 5.00 }
  ],
  "scrapedAt": "2026-05-06T05:42:18Z"
}
```

### Use cases

- **Creator-economy analytics** — Track patron growth and tier pricing across a portfolio of creators.
- **Brand-deal targeting** — Identify creators with N+ patrons in a niche for sponsorship outreach.
- **Competitive research** — Compare your creator's pricing/post-cadence with peers.
- **Investor due-diligence** — Patron counts are a public approximation of MRR; compare across creators.
- **Content audits** — Pull every public post from a Patreon creator for analysis or archival.

### FAQ

**Do I need a Patreon account?**
No. Every endpoint this actor uses is part of Patreon's public-facing site (the campaign page that any visitor can see) and the public posts JSON API.

**Why does `paidMemberCount` differ from `patronCount`?**
`patronCount` includes free-tier members. `paidMemberCount` is paying patrons only — usually a much smaller number for creators that offer a free tier.

**Are full post bodies included?**
Only for posts marked `is_public=true`. Patron-only posts return a public teaser (when set) but the full body is locked. Each post's `isPaid` / `isPublic` flags tell you which type you have.

**How many posts can I scrape per creator?**
Up to 200 per run via `maxPostsPerCreator`. The Patreon posts API paginates 20 at a time — large pulls take ~1 second per page.

**How current is the data?**
Live — every run hits Patreon at request time. Schedule the actor for hourly / daily refreshes to track patron-growth curves.

**Do I need a proxy?**
No. Patreon's public site is happy to serve datacenter IPs.

**What if Patreon does block me?**
The actor has built-in auto-escalation: on the first HTTP 403 / anti-bot block it lazily engages Apify Proxy (datacenter group first, residential as a second-stage fallback) and retries the failed URL transparently. All subsequent fetches in the same run continue through the proxied session. To disable, set `autoEscalateOnBlock=false`. To force a specific group set, populate `proxyGroups`.

### Limitations

- Patron-only post bodies are not accessible without a logged-in account.
- Some creators hide `patronCount` (set `member_count_preference` to TIER\_BREAKDOWN); those records will still emit but with the count omitted.
- Earnings are not exposed unless the creator explicitly publishes them (`show_earnings`); we don't surface this field by default.
- Comments are not included in this version (each post would need a follow-up fetch); we surface `commentCount` for sentiment-trend approximation.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `creators` (type: `array`):

Creator slugs (e.g. `PhilosophyTube`) or full URLs (`https://www.patreon.com/c/PhilosophyTube`).

## `searchQuery` (type: `string`):

Keyword to search across all Patreon creators.

## `category` (type: `string`):

Patreon's Explore directory category. Leave empty to browse the top-level `/explore/` page.

## `postUrls` (type: `array`):

Patreon post URLs to fetch individually, e.g. `https://www.patreon.com/posts/12345` or `https://www.patreon.com/posts/title-slug-12345`.

## `includePosts` (type: `boolean`):

When `mode=creator`, also fetch the creator's recent posts.

## `maxPostsPerCreator` (type: `integer`):

Hard cap on posts emitted per creator.

## `minPatronCount` (type: `integer`):

Drop creators with fewer than this many patrons.

## `excludeNsfw` (type: `boolean`):

Drop creators marked as NSFW.

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

Hard cap on total emitted records (creators + posts combined).

## `autoEscalateOnBlock` (type: `boolean`):

If true (default), the actor automatically engages Apify Proxy when it hits HTTP 403 / anti-bot blocks from a raw datacenter IP. Set false to disable (request fails fast).

## `proxyGroups` (type: `array`):

Apify proxy groups to use when auto-escalating after a block. Empty = datacenter (default), then residential fallback.

## Actor input object example

```json
{
  "mode": "creator",
  "creators": [
    "PhilosophyTube"
  ],
  "includePosts": true,
  "maxPostsPerCreator": 20,
  "excludeNsfw": false,
  "maxItems": 50,
  "autoEscalateOnBlock": true,
  "proxyGroups": []
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset containing all scraped creators and posts.

# 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 = {
    "mode": "creator",
    "creators": [
        "PhilosophyTube"
    ],
    "includePosts": true,
    "maxPostsPerCreator": 20,
    "excludeNsfw": false,
    "maxItems": 50,
    "autoEscalateOnBlock": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/patreon-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 = {
    "mode": "creator",
    "creators": ["PhilosophyTube"],
    "includePosts": True,
    "maxPostsPerCreator": 20,
    "excludeNsfw": False,
    "maxItems": 50,
    "autoEscalateOnBlock": True,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/patreon-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 '{
  "mode": "creator",
  "creators": [
    "PhilosophyTube"
  ],
  "includePosts": true,
  "maxPostsPerCreator": 20,
  "excludeNsfw": false,
  "maxItems": 50,
  "autoEscalateOnBlock": true
}' |
apify call crawlerbros/patreon-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Patreon Scraper",
        "description": "Scrape Patreon creators (campaigns) with campaign metadata, tier pricing, public posts, and patron counts.",
        "version": "1.0",
        "x-build-id": "rlwMv3hbbXDdpW23d"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~patreon-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-patreon-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/crawlerbros~patreon-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-patreon-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/crawlerbros~patreon-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-patreon-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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "creator",
                            "posts",
                            "search",
                            "explore",
                            "postByUrl"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "creator"
                    },
                    "creators": {
                        "title": "Creator vanity slugs or URLs (mode=creator / posts)",
                        "type": "array",
                        "description": "Creator slugs (e.g. `PhilosophyTube`) or full URLs (`https://www.patreon.com/c/PhilosophyTube`).",
                        "default": [
                            "PhilosophyTube"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Keyword to search across all Patreon creators."
                    },
                    "category": {
                        "title": "Explore category (mode=explore)",
                        "enum": [
                            "",
                            "podcasts",
                            "video-film",
                            "music",
                            "visual-arts",
                            "comedy",
                            "games",
                            "writing",
                            "drawing-painting",
                            "comics-graphic-novels",
                            "tabletop-games",
                            "science",
                            "education",
                            "crafts-diy",
                            "lifestyle"
                        ],
                        "type": "string",
                        "description": "Patreon's Explore directory category. Leave empty to browse the top-level `/explore/` page."
                    },
                    "postUrls": {
                        "title": "Post URLs (mode=postByUrl)",
                        "type": "array",
                        "description": "Patreon post URLs to fetch individually, e.g. `https://www.patreon.com/posts/12345` or `https://www.patreon.com/posts/title-slug-12345`.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includePosts": {
                        "title": "Include posts (mode=creator)",
                        "type": "boolean",
                        "description": "When `mode=creator`, also fetch the creator's recent posts.",
                        "default": true
                    },
                    "maxPostsPerCreator": {
                        "title": "Max posts per creator",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Hard cap on posts emitted per creator.",
                        "default": 20
                    },
                    "minPatronCount": {
                        "title": "Min patron count",
                        "minimum": 0,
                        "maximum": 10000000,
                        "type": "integer",
                        "description": "Drop creators with fewer than this many patrons."
                    },
                    "excludeNsfw": {
                        "title": "Exclude NSFW",
                        "type": "boolean",
                        "description": "Drop creators marked as NSFW.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Hard cap on total emitted records (creators + posts combined).",
                        "default": 50
                    },
                    "autoEscalateOnBlock": {
                        "title": "Auto-escalate to Apify proxy on block",
                        "type": "boolean",
                        "description": "If true (default), the actor automatically engages Apify Proxy when it hits HTTP 403 / anti-bot blocks from a raw datacenter IP. Set false to disable (request fails fast).",
                        "default": true
                    },
                    "proxyGroups": {
                        "title": "Apify proxy groups (used on auto-escalation)",
                        "type": "array",
                        "description": "Apify proxy groups to use when auto-escalating after a block. Empty = datacenter (default), then residential fallback.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```