# Patreon Scraper — Creator Earnings, Tiers & Members (`khadinakbar/patreon-scraper`) Actor

Scrape public Patreon creators by username or URL: profile, membership tiers and prices, patron and paid-member counts, an estimated monthly earnings range, social links, and recent posts. Keyword creator search included. HTTP-only, MCP-ready, no login required.

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

## Pricing

from $10.00 / 1,000 creator scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 — Earnings, Tiers & Patron Counts

Scrape **public Patreon creators** by username or URL and get one clean, structured record per creator: profile, membership **tiers and prices**, **patron and paid‑member counts**, an **estimated monthly earnings range**, social links, and (optionally) **recent posts** with engagement. Includes keyword **creator search** for discovery. HTTP‑only, no login required, and built for AI agents (MCP‑ready).

> Most Patreon scrapers only pull post content. This one is a **creator‑intelligence** tool: it surfaces the financial picture — tiers, member counts, and an earnings estimate — that sponsorship scouts and analysts actually need.

### What you can do

- **Profile a creator** → tiers, prices, patron count, paid‑member count, earnings estimate, socials.
- **Pull recent posts** → title, type, publish date, likes, comments, paywall status.
- **Discover creators** → search any keyword and get matching creators back.

### When to use it

- **Sponsorship & influencer scouting** — size a creator's paying audience and tier economics before you reach out.
- **Creator‑economy research** — benchmark tiers, pricing, and membership across a niche.
- **Competitor / market tracking** — monitor a roster of creators over time.
- **AI agents** — a single, predictable tool call that returns structured creator data.

**Not for:** the list of individual patrons (Patreon never exposes the patron roster publicly — this actor returns aggregate counts, not names), and not for private/paid post bodies unless you supply your own logged‑in `session_id`.

### Output — creator record

| Field | Description |
|---|---|
| `recordType` | `creator` or `post` |
| `campaignId` / `creatorId` | Patreon numeric ids |
| `vanity` | Creator handle |
| `creatorName` / `campaignName` | Display name and campaign title |
| `url` | Canonical Patreon URL |
| `summary` | Plain‑text creator description |
| `patronCount` | Total patrons (free + paid) |
| `paidMemberCount` | Paying members |
| `tiers[]` | `title`, `monthlyPriceUsd`, `amountCents`, `isFree`, `description` |
| `paidTierCount`, `minTierUsd`, `maxTierUsd` | Tier economics |
| `estimatedEarningsMinUsd` / `estimatedEarningsMaxUsd` | Estimated monthly earnings range |
| `earningsEstimateBasis` | How the estimate was derived |
| `earningsVisibility` / `reportedMonthlyEarningsUsd` | Actual earnings when the creator makes them public |
| `youtubeUrl`, `twitterUrl`, `instagramUrl`, `facebookUrl`, `twitchUrl`, `tiktokUrl`, `discordUrl` | Linked socials |
| `isNsfw`, `isMonthly`, `currency`, `publishedAt`, `avatarUrl` | Profile metadata |
| `scrapedAt` | ISO 8601 timestamp |

#### Output — post record (when `includePosts` is on)

`postId`, `title`, `teaserText`, `postType`, `publishedAt`, `likeCount`, `commentCount`, `isPaid`, `minPledgeUsdToView`, `url`, `imageUrl`.

### Pricing (pay‑per‑event)

| Event | Price |
|---|---|
| Actor start | $0.00005 |
| **Creator scraped** | **$0.01** per creator |
| **Post scraped** | **$0.002** per post |

A typical 100‑creator run costs about **$1.00**. Posts are billed only when `includePosts` is enabled. The `maxResults` input is a hard cap on total billable records so cost stays predictable. Pay‑per‑usage (compute + proxy) is also available for very large jobs.

### Input

```json
{
  "creators": ["TopoTraveler", "https://www.patreon.com/EconomicsExplained"],
  "searchQueries": ["true crime podcast"],
  "includePosts": true,
  "maxPostsPerCreator": 20,
  "maxSearchResults": 20,
  "enrichSearchResults": true,
  "maxResults": 1000
}
````

- **`creators`** — usernames, `@handles`, or full creator URLs (`/`, `/c/`, `/cw/`, and `user?u=` forms all work).
- **`searchQueries`** — keywords for creator discovery.
- **`includePosts`** / **`maxPostsPerCreator`** — also scrape recent posts (newest first).
- **`enrichSearchResults`** — when true (default), each search hit gets a full profile; when false, search returns lighter cards and runs cheaper.
- **`sessionId`** *(optional)* — your Patreon `session_id` cookie, only if you want metadata for exclusive posts you already have access to. Also reads the `PATREON_SESSION_ID` environment variable. Never required for public data.

### Example output

```json
{
  "recordType": "creator",
  "campaignId": "12104065",
  "vanity": "TopoTraveler",
  "creatorName": "Topo Traveler",
  "campaignName": "The Official Patreon for Topo Traveler",
  "url": "https://www.patreon.com/TopoTraveler",
  "patronCount": 209,
  "paidMemberCount": 104,
  "tiers": [
    { "title": "Casual Hiker", "monthlyPriceUsd": 5, "amountCents": 500, "isFree": false },
    { "title": "Experienced Trekkers", "monthlyPriceUsd": 10, "amountCents": 1000, "isFree": false }
  ],
  "paidTierCount": 2,
  "minTierUsd": 5,
  "maxTierUsd": 10,
  "estimatedEarningsMinUsd": 520,
  "estimatedEarningsMaxUsd": 780,
  "earningsEstimateBasis": "paid_member_count (104) x tier price: low = all at cheapest paid tier ($5), high = all at median paid tier ($7.5); per-tier counts are not public",
  "earningsVisibility": "private",
  "youtubeUrl": "https://youtube.com/channel/UCeagElDDKCx75ZJiICK-VNQ",
  "currency": "USD",
  "scrapedAt": "2026-06-17T00:00:00.000Z"
}
```

### How the earnings estimate works

Patreon keeps actual earnings private for most creators (`earnings_visibility: "private"`), and it does not publish how many members are on each tier. This actor builds an **honest, first‑party estimate** from data Patreon *does* expose: the public **paid‑member count** and the **published tier prices**.

- **Low** = every paid member on the cheapest paid tier.
- **High** = every paid member on the **median** paid tier (using the median, not the most expensive tier, avoids absurd numbers when a creator has a rarely‑bought high‑dollar tier).

The exact formula is recorded per record in `earningsEstimateBasis`. When a creator hides their patron/member count, the estimate fields are `null` rather than guessed. When a creator publishes real earnings, `reportedMonthlyEarningsUsd` carries the actual figure.

### How it works

The actor talks to Patreon's own public JSON API over HTTP — no headless browser — so it is fast and cheap. Creator handles are resolved to a campaign id deterministically from the page bootstrap data, then profile, tiers, and posts are fetched from the API. Apify Proxy (automatic datacenter selection) is used by default and works against Patreon out of the box; Residential is optional if your plan includes it. Blocked requests rotate sessions and back off automatically; partial failures degrade gracefully instead of crashing the run.

### Use with AI agents (MCP)

This actor is exposed through the Apify MCP server as `apify--patreon-scraper`. Point any MCP‑capable client (Claude, ChatGPT, Cursor) at it and ask in natural language — e.g. *"Get the tiers and estimated earnings for the Patreon creator TopoTraveler."* Input is a single handle or query; output is flat, stable JSON sized for agent context windows.

### FAQ

**Can it get the list of patrons/members?** No. Patreon never exposes the patron roster publicly. You get aggregate `patronCount` and `paidMemberCount`, not individual names.

**Why are earnings sometimes null?** The creator hid their patron/member count, so there is nothing reliable to estimate from. Tiers and prices are still returned.

**Do I need a Patreon account or cookies?** No. Everything here is public data. A `session_id` cookie is optional and only affects visibility of exclusive post metadata.

**Which URL formats work?** `username`, `@username`, `patreon.com/username`, `/c/username`, `/cw/username`, and `patreon.com/user?u=<id>`, plus raw numeric campaign ids.

### Legal & ethical use

This actor collects only **publicly available** information from Patreon creator pages and Patreon's public API. It does not bypass paywalls, access private patron data, or scrape the patron roster. You are responsible for using the data in compliance with Patreon's Terms of Service, applicable laws (including GDPR/CCPA where relevant), and for respecting creators' rights. Earnings figures are **estimates**, not official Patreon data, unless a creator has chosen to publish them.

### Related actors

Pairs well with the rest of the creator‑economy toolkit: `instagram-profile-scraper`, `tiktok-profile-scraper`, `youtube-channel-email-extractor`, and `x-tweet-scraper`.

# Actor input Schema

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

Patreon creators to scrape, each as a username, @handle, or full creator URL (e.g. 'TopoTraveler', '@TopoTraveler', or 'https://www.patreon.com/TopoTraveler'). The /c/, /cw/ and user?u= URL forms are also accepted. Each resolves to one creator-profile record. Leave empty if you only want keyword search; this is NOT a post URL.

## `searchQueries` (type: `array`):

Free-text keywords to discover Patreon creators (e.g. 'rock climbing podcast'). Each query returns up to maxSearchResults matching creators. Use this to find creators when you do not already know their handle; for a known creator use the 'creators' field instead. Optional.

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

When true, also scrape each creator's most recent posts (title, type, publish date, like and comment counts, paywall status). Adds one post-scraped charge per post returned. Applies to creators from both 'creators' and search results. Defaults to false.

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

Upper bound on posts returned per creator when includePosts is true (e.g. 20). Posts are returned newest-first. Set to 0 to disable posts even if includePosts is true. Defaults to 20; max 500.

## `maxSearchResults` (type: `integer`):

Upper bound on creators returned per search query (e.g. 20). Only applies to 'searchQueries'. Each result is a creator record. Defaults to 20; max 200.

## `enrichSearchResults` (type: `boolean`):

When true, each search hit is enriched with a full profile fetch (tiers, paid-member count, earnings estimate, socials) — same shape as the 'creators' output. When false, search returns the lighter card data only (name, patron count, URL, avatar) and runs cheaper. Defaults to true.

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

Hard safety cap on the TOTAL number of billable records (creators + posts) pushed across the whole run, regardless of inputs (e.g. 1000). Stops the run cleanly when reached so cost stays predictable. Defaults to 1000; max 100000.

## `sessionId` (type: `string`):

Optional Patreon 'session\_id' cookie value from a logged-in account, used only to read exclusive/paid post metadata you already have access to. Leave blank for public data (default). Can also be supplied via the PATREON\_SESSION\_ID environment variable. Never required; public profiles, tiers, counts and earnings work without it.

## `proxyConfiguration` (type: `object`):

Proxy settings. Defaults to Apify Proxy (automatic datacenter selection), which works against Patreon and is available on every plan. If your account has the Residential group you may add it for extra resilience, but it is not required.

## Actor input object example

```json
{
  "creators": [
    "TopoTraveler",
    "https://www.patreon.com/EconomicsExplained"
  ],
  "searchQueries": [
    "true crime podcast",
    "indie game dev"
  ],
  "includePosts": false,
  "maxPostsPerCreator": 20,
  "maxSearchResults": 20,
  "enrichSearchResults": true,
  "maxResults": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Default dataset with one record per creator and (optionally) per post.

## `state` (type: `string`):

STATE key in the default key-value store: pushed count and emitted ids for this run.

# 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 = {
    "creators": [
        "TopoTraveler"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "creators": ["TopoTraveler"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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 '{
  "creators": [
    "TopoTraveler"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call khadinakbar/patreon-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Patreon Scraper — Creator Earnings, Tiers & Members",
        "description": "Scrape public Patreon creators by username or URL: profile, membership tiers and prices, patron and paid-member counts, an estimated monthly earnings range, social links, and recent posts. Keyword creator search included. HTTP-only, MCP-ready, no login required.",
        "version": "0.1",
        "x-build-id": "IJuhKZBA5mFAivy6a"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~patreon-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-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/khadinakbar~patreon-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-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/khadinakbar~patreon-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-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",
                "properties": {
                    "creators": {
                        "title": "Creator usernames or URLs",
                        "type": "array",
                        "description": "Patreon creators to scrape, each as a username, @handle, or full creator URL (e.g. 'TopoTraveler', '@TopoTraveler', or 'https://www.patreon.com/TopoTraveler'). The /c/, /cw/ and user?u= URL forms are also accepted. Each resolves to one creator-profile record. Leave empty if you only want keyword search; this is NOT a post URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search keywords (creator discovery)",
                        "type": "array",
                        "description": "Free-text keywords to discover Patreon creators (e.g. 'rock climbing podcast'). Each query returns up to maxSearchResults matching creators. Use this to find creators when you do not already know their handle; for a known creator use the 'creators' field instead. Optional.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includePosts": {
                        "title": "Also scrape recent posts",
                        "type": "boolean",
                        "description": "When true, also scrape each creator's most recent posts (title, type, publish date, like and comment counts, paywall status). Adds one post-scraped charge per post returned. Applies to creators from both 'creators' and search results. Defaults to false.",
                        "default": false
                    },
                    "maxPostsPerCreator": {
                        "title": "Max posts per creator",
                        "minimum": 0,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Upper bound on posts returned per creator when includePosts is true (e.g. 20). Posts are returned newest-first. Set to 0 to disable posts even if includePosts is true. Defaults to 20; max 500.",
                        "default": 20
                    },
                    "maxSearchResults": {
                        "title": "Max results per search query",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Upper bound on creators returned per search query (e.g. 20). Only applies to 'searchQueries'. Each result is a creator record. Defaults to 20; max 200.",
                        "default": 20
                    },
                    "enrichSearchResults": {
                        "title": "Enrich search results with full profile",
                        "type": "boolean",
                        "description": "When true, each search hit is enriched with a full profile fetch (tiers, paid-member count, earnings estimate, socials) — same shape as the 'creators' output. When false, search returns the lighter card data only (name, patron count, URL, avatar) and runs cheaper. Defaults to true.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Max total records (cost cap)",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Hard safety cap on the TOTAL number of billable records (creators + posts) pushed across the whole run, regardless of inputs (e.g. 1000). Stops the run cleanly when reached so cost stays predictable. Defaults to 1000; max 100000.",
                        "default": 1000
                    },
                    "sessionId": {
                        "title": "Patreon session_id cookie (optional)",
                        "type": "string",
                        "description": "Optional Patreon 'session_id' cookie value from a logged-in account, used only to read exclusive/paid post metadata you already have access to. Leave blank for public data (default). Can also be supplied via the PATREON_SESSION_ID environment variable. Never required; public profiles, tiers, counts and earnings work without it."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. Defaults to Apify Proxy (automatic datacenter selection), which works against Patreon and is available on every plan. If your account has the Residential group you may add it for extra resilience, but it is not required.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
