# Kickstarter Scraper — Creator Leads, Contacts & Launch Monitor (`scrapersdelight/kickstarter-scraper`) Actor

Scrape Kickstarter campaigns and their creators — funding, backers, category, plus the creator's own website and social links — as real B2B leads. Search the full catalog by state, category and date window, or monitor new launches on a schedule.

- **URL**: https://apify.com/scrapersdelight/kickstarter-scraper.md
- **Developed by:** [Scrapers Delight](https://apify.com/scrapersdelight) (community)
- **Categories:** Lead generation, Automation, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 per campaign scrapeds

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

## Kickstarter Scraper — Creator Leads, Contacts & Launch Monitor

Most Kickstarter scrapers hand you **project stats**. This one hands you **leads.**

For every campaign it also profiles the **creator** — their own **website/store** and **social profiles** — so you get a real B2B contact you can sell to, enrich, or add to a CRM. Search the whole catalog by state, category, and date window, or run it on a schedule to catch **new launches** the day they go live.

Built for founders, agencies, suppliers, and GTM teams who sell **to the people running crowdfunding campaigns** — fulfilment, manufacturing, marketing, pre-order/where's-my-order tooling, packaging, financing.

---

### Why this one

| | Typical KS scraper | **This actor** |
|---|---|---|
| Campaign stats (funding, backers, category, dates) | ✅ | ✅ |
| Creator's **own website / store** | ❌ | ✅ |
| Creator **social profiles** (IG, FB, X, TikTok, YouTube, LinkedIn…) | ❌ | ✅ |
| **New-launch monitor** (schedule it, get only new) | rare | ✅ |
| Full-catalog search (beats the 200-page cap) | ❌ | ✅ |

The website column is the point: pipe it into an email finder (see [Turn it into email](#turn-leads-into-email) below) and you've got a complete outbound list — campaign, creator, site, socials, email.

### What you get (one row per campaign)

- **Campaign** — name, blurb, url, state (live / upcoming / successful / failed / canceled), category + parent, staff-pick, tags, rewards count, min pledge
- **Funding** — goal, pledged, USD pledged, % funded, backers, currency, launched / deadline / created dates
- **Creator lead** — name, profile url, bio, # of launched projects, last login, **location** (city / state / country)
- **Contact** — `website` + `websites_all[]`, `website_source` (see below), and `socials { instagram, facebook, twitter_x, tiktok, youtube, linkedin, pinterest, discord, threads, bluesky }`

#### Honest coverage (read this)

The creator's own website is published on their Kickstarter profile for **live and upcoming** campaigns, and that's where we read it — cleanly and reliably. For **ended** campaigns (successful/failed), Kickstarter no longer exposes that field, so we fall back to a **best-effort** website pulled from links in the campaign story. Every row tells you which you got:

- `website_source: "profile"` — the creator's own website, straight from their profile (highest confidence)
- `website_source: "story"` — best-effort site recovered from the campaign story
- `website_source: "none"` — no website found (metadata-only lead)

So: **live / upcoming** campaigns are the richest lead source. Filter on `website_source` if you only want confirmed sites.

### Modes

- **Search** *(default)* — one filter: state + optional category + optional date window. Great for "all live tabletop games" or "everything that ended last month."
- **Sweep** — tile the **whole catalog** by month automatically, working around Kickstarter's ~200-page-per-query limit. For building a full historical list.
- **Monitor** — return only campaigns that are **new since the last run**. Point a daily schedule at it and get a fresh-launch feed. Optional webhook (Slack/Zapier).
- **URLs** — paste specific project URLs to scrape + enrich.

### Turn leads into email

This actor gives you the creator's **website**; pair it with an email finder to complete the contact. Recipe:

1. Run this actor, export the dataset.
2. Feed the `website` column into **[Local Business Contact Enricher](https://apify.com/scrapersdelight/local-business-enricher)** (our $0.01/contact email finder).
3. You now have campaign → creator → website → **email**.

### Pricing (pay per event)

| Event | Price | When |
|---|---|---|
| `campaign-scraped` | **$0.0008** | per campaign row returned |
| `creator-enriched` | **$0.004** | per unique creator **only when a website or social is found** — misses are free |
| `new-campaign-detected` | **$0.02** | per new campaign in monitor mode (replaces `campaign-scraped`) |
| `monitor-run-completed` | **$0.05** | per scheduled monitor run |
| `alert-delivered` | **$0.005** | only when a webhook alert is delivered |

**Example** — pull 10,000 live campaigns with enrichment, ~7,000 unique creators with a contact found: `10,000 × $0.0008` + `7,000 × $0.004` ≈ **$36**. Turn enrichment off for a metadata-only pull and it's just `$0.0008`/row.

### Example input

```json
{
  "mode": "search",
  "searchState": "live",
  "category": "Tabletop Games",
  "maxItems": 200,
  "enrichCreators": true
}
````

Daily new-launch monitor:

```json
{
  "mode": "monitor",
  "category": "Technology",
  "enrichCreators": true,
  "webhookUrl": "https://hooks.slack.com/services/…"
}
```

### FAQ

**Is this only public data?** Yes — everything comes from public Kickstarter campaign and profile pages. No login, no private data. You are responsible for compliant outreach (CAN-SPAM / GDPR / CCPA).

**Do I need proxies?** Residential proxy is the default and recommended — Kickstarter rate-limits datacenter IPs. The actor paces itself (one request per session, rotating).

**Will it get the whole catalog?** Sweep mode tiles by month to cover far more than a single query's ~200-page cap. Very large historical sweeps take time — give the run a high timeout.

**What about the creator's legal name?** Off by default. Kickstarter sometimes exposes a verified legal name (distinct from display name); enable `includeVerifiedName` only if you have a lawful basis — it's personal data.

**Socials came back empty for some campaigns.** Not every creator links socials on-site. Website coverage is strongest on live/upcoming campaigns (see [Honest coverage](#honest-coverage-read-this)).

***

*Public campaign data. Not affiliated with Kickstarter, PBC.*

# Actor input Schema

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

search = one filter (state/category/date). sweep = tile the WHOLE catalog by month (beats the 200-page cap). monitor = only NEW campaigns since last run (schedule it). urls = scrape specific project URLs you paste below.

## `searchState` (type: `string`):

Which campaigns to include. 'live' = currently funding, 'upcoming' = prelaunch, 'successful/failed/canceled' = ended, 'all' = everything.

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

Filter by a Kickstarter category — a name ('Tabletop Games', 'Technology', 'Design') or a numeric category\_id. Leave blank for all categories.

## `deadlineAfter` (type: `string`):

Only campaigns whose deadline is on/after this date. Used to narrow a search window (sweep mode auto-tiles months for you).

## `deadlineBefore` (type: `string`):

Only campaigns whose deadline is before this date.

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

Paste specific Kickstarter project URLs to scrape (used when Mode = URLs).

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

Cap on campaigns per run. Set 0 for no cap (sweep mode). Creator enrichment adds ~1-2 page fetches per campaign, so give big runs more timeout.

## `enrichCreators` (type: `boolean`):

Fetch each campaign page to pull the creator's own website + social profiles (the lead data). Costs nothing until a contact is actually found. Turn OFF for a fast metadata-only pull.

## `includeVerifiedName` (type: `boolean`):

Off by default. When a campaign exposes the creator's verified legal name (distinct from display name), include it. This is personal data — you are responsible for compliant use (GDPR/CCPA).

## `monitorStateStore` (type: `string`):

Named key-value store used to remember which campaigns were already seen, so monitor mode only returns NEW ones. Reuse the same name across scheduled runs.

## `webhookUrl` (type: `string`):

In monitor mode, POST newly-detected campaigns to this URL (Slack/Zapier/your endpoint). Leave blank for none.

## `concurrency` (type: `integer`):

How many campaigns to fetch in parallel — each on its own proxy session. Kickstarter blocks bursts from one IP, so parallelism = more sessions, not faster per session.

## `enrichTries` (type: `integer`):

Max fresh-IP attempts per campaign page. Kickstarter project pages 403 most shared residential IPs, so we rotate IPs until one gets through (good IPs are then cached). Raise for higher coverage on Apify's pool; premium residential proxies need far fewer.

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

Residential proxy is recommended — Kickstarter rate-limits datacenter IPs. Keep the default unless you have your own proxy.

## `diagnose` (type: `boolean`):

Dev only. Logs the first parsed + enriched campaign, then exits.

## Actor input object example

```json
{
  "mode": "search",
  "searchState": "live",
  "startUrls": [],
  "maxItems": 12,
  "enrichCreators": true,
  "includeVerifiedName": false,
  "monitorStateStore": "kickstarter-monitor-state",
  "concurrency": 4,
  "enrichTries": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "diagnose": false
}
```

# Actor output Schema

## `leads` (type: `string`):

The dataset of campaigns + creators (one item per campaign).

# 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": "search",
    "searchState": "live",
    "maxItems": 12,
    "enrichCreators": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapersdelight/kickstarter-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": "search",
    "searchState": "live",
    "maxItems": 12,
    "enrichCreators": False,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapersdelight/kickstarter-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": "search",
  "searchState": "live",
  "maxItems": 12,
  "enrichCreators": false
}' |
apify call scrapersdelight/kickstarter-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kickstarter Scraper — Creator Leads, Contacts & Launch Monitor",
        "description": "Scrape Kickstarter campaigns and their creators — funding, backers, category, plus the creator's own website and social links — as real B2B leads. Search the full catalog by state, category and date window, or monitor new launches on a schedule.",
        "version": "0.1",
        "x-build-id": "TJbZL1W5K2XV20eDm"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapersdelight~kickstarter-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapersdelight-kickstarter-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/scrapersdelight~kickstarter-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scrapersdelight-kickstarter-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/scrapersdelight~kickstarter-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scrapersdelight-kickstarter-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": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "sweep",
                            "monitor",
                            "urls"
                        ],
                        "type": "string",
                        "description": "search = one filter (state/category/date). sweep = tile the WHOLE catalog by month (beats the 200-page cap). monitor = only NEW campaigns since last run (schedule it). urls = scrape specific project URLs you paste below.",
                        "default": "search"
                    },
                    "searchState": {
                        "title": "Campaign state",
                        "enum": [
                            "live",
                            "upcoming",
                            "successful",
                            "failed",
                            "canceled",
                            "late_pledge",
                            "all"
                        ],
                        "type": "string",
                        "description": "Which campaigns to include. 'live' = currently funding, 'upcoming' = prelaunch, 'successful/failed/canceled' = ended, 'all' = everything.",
                        "default": "live"
                    },
                    "category": {
                        "title": "Category (optional)",
                        "type": "string",
                        "description": "Filter by a Kickstarter category — a name ('Tabletop Games', 'Technology', 'Design') or a numeric category_id. Leave blank for all categories."
                    },
                    "deadlineAfter": {
                        "title": "Deadline after (optional, YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only campaigns whose deadline is on/after this date. Used to narrow a search window (sweep mode auto-tiles months for you)."
                    },
                    "deadlineBefore": {
                        "title": "Deadline before (optional, YYYY-MM-DD)",
                        "type": "string",
                        "description": "Only campaigns whose deadline is before this date."
                    },
                    "startUrls": {
                        "title": "Project URLs (mode = urls)",
                        "type": "array",
                        "description": "Paste specific Kickstarter project URLs to scrape (used when Mode = URLs).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max campaigns",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap on campaigns per run. Set 0 for no cap (sweep mode). Creator enrichment adds ~1-2 page fetches per campaign, so give big runs more timeout.",
                        "default": 100
                    },
                    "enrichCreators": {
                        "title": "Enrich creators (website + socials)",
                        "type": "boolean",
                        "description": "Fetch each campaign page to pull the creator's own website + social profiles (the lead data). Costs nothing until a contact is actually found. Turn OFF for a fast metadata-only pull.",
                        "default": true
                    },
                    "includeVerifiedName": {
                        "title": "Include creator's verified legal name (PII)",
                        "type": "boolean",
                        "description": "Off by default. When a campaign exposes the creator's verified legal name (distinct from display name), include it. This is personal data — you are responsible for compliant use (GDPR/CCPA).",
                        "default": false
                    },
                    "monitorStateStore": {
                        "title": "Monitor state store (mode = monitor)",
                        "type": "string",
                        "description": "Named key-value store used to remember which campaigns were already seen, so monitor mode only returns NEW ones. Reuse the same name across scheduled runs.",
                        "default": "kickstarter-monitor-state"
                    },
                    "webhookUrl": {
                        "title": "Alert webhook (optional)",
                        "type": "string",
                        "description": "In monitor mode, POST newly-detected campaigns to this URL (Slack/Zapier/your endpoint). Leave blank for none."
                    },
                    "concurrency": {
                        "title": "Concurrency (sessions)",
                        "minimum": 1,
                        "maximum": 12,
                        "type": "integer",
                        "description": "How many campaigns to fetch in parallel — each on its own proxy session. Kickstarter blocks bursts from one IP, so parallelism = more sessions, not faster per session.",
                        "default": 4
                    },
                    "enrichTries": {
                        "title": "Enrichment fetch retries",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Max fresh-IP attempts per campaign page. Kickstarter project pages 403 most shared residential IPs, so we rotate IPs until one gets through (good IPs are then cached). Raise for higher coverage on Apify's pool; premium residential proxies need far fewer.",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Residential proxy is recommended — Kickstarter rate-limits datacenter IPs. Keep the default unless you have your own proxy.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "diagnose": {
                        "title": "Diagnostic mode (dev)",
                        "type": "boolean",
                        "description": "Dev only. Logs the first parsed + enriched campaign, then exits.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```