# Kickstarter Scraper (`solidcode/kickstarter-scraper`) Actor

\[💰 $0.9 / 1K]  Extract Kickstarter crowdfunding projects with full funding metrics, creator info, category, location, and timelines. Search by keyword, filter by category, funding status, sort, and location, or paste Kickstarter Discover URLs directly. One clean row per project.

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

## Pricing

from $0.90 / 1,000 results

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.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

## Kickstarter Scraper

Pull crowdfunding projects from Kickstarter at scale — funding goals, amount pledged (native currency and USD), backer counts, percent funded, days left, creator, category, location, and exact launch and deadline timestamps for every campaign. Built for crowdfunding marketers, product scouts, and investment analysts who need a clean, structured dataset of live and successful campaigns without clicking through the Discover feed one page at a time.

### Why This Scraper?

- **30 data points per project in one flat row** — funding goal, pledged (native + USD), backers, percent funded, days left, creator, category, location, currency, and timestamps, all without descending into per-project comment or backer pages.
- **Native and USD pledge amounts side by side** — `pledged` in the project's own currency plus `usdPledged` converted to dollars, so you can compare a £-, €-, and $-funded campaign on one axis.
- **15 Kickstarter categories as a dropdown** — Art, Comics, Crafts, Dance, Design, Fashion, Film & Video, Food, Games, Journalism, Music, Photography, Publishing, Technology, and Theater. No typos, no guessing category slugs.
- **5 sort modes including Most Funded** — Magic, Popularity, Newest, Ending Soon, and Most Funded, so you can rank by total raised or surface campaigns about to close.
- **Funding-velocity signals built in** — `percentFunded` and `daysLeft` on every row let you spot overfunded breakouts (above 100%) and last-minute closers in the same pull.
- **Staff Picks filter** — restrict to Kickstarter's editor-curated highlights to study what the platform itself promotes.
- **Live, successful, or all states** — pull only campaigns currently raising money, only fully-funded winners, or everything in one run.
- **Location targeting by city, state, or country** — type "Berlin", "California", or "Canada" and the actor resolves it to Kickstarter's place filter for you.
- **Paste any Discover URL** — drop a fully-filtered Kickstarter Discover link and it's scraped exactly as built, covering any combination the site's UI exposes.

### Use Cases

**Market Research**
- Size a niche by category, then rank campaigns by total USD pledged
- Track how many projects in a category reach 100% funded versus stall out
- Map crowdfunding demand by city, state, or country
- Benchmark funding goals against what backers actually pledge

**Product Scouting**
- Surface new physical products in Design, Technology, and Games before they hit retail
- Find overfunded campaigns (percent funded well above 100%) signaling proven demand
- Spot Staff-Picked projects as editorially-vetted early signals
- Watch newest launches to catch trends as they start

**Competitive Intelligence**
- Monitor a competitor's category for new and live campaigns
- Compare backer counts and pledge totals across rival projects
- Track creator output by following a creator's category and location
- Build a watchlist of campaigns ending soon to study final-stretch behavior

**Investment & Trend Analysis**
- Study what wins by pulling successful, most-funded campaigns at scale
- Correlate funding velocity (percent funded vs. days left) with final outcomes
- Identify breakout categories by aggregating pledge totals over time
- Feed live campaign metrics into deal-flow and diligence pipelines

### Getting Started

#### Search by Keyword

The simplest start — one keyword and a result cap:

```json
{
    "searchTerms": ["board game"],
    "maxResults": 100
}
````

#### Keyword + Category + Sort

Find the most-funded tabletop games:

```json
{
    "searchTerms": ["board game"],
    "category": "games",
    "sort": "most_funded",
    "maxResults": 200
}
```

#### Full Multi-Filter Search

Successful, Staff-Picked design projects out of Berlin, ranked by total raised:

```json
{
    "searchTerms": ["furniture", "lamp"],
    "category": "design",
    "state": "successful",
    "sort": "most_funded",
    "staffPicks": true,
    "location": "Berlin",
    "maxResults": 500
}
```

#### Paste a Discover URL

Scrape any pre-built Kickstarter Discover or search page directly:

```json
{
    "startUrls": ["https://www.kickstarter.com/discover/categories/games?sort=end_date&state=live"],
    "maxResults": 300
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchTerms` | array | `["board game"]` | Keywords to search across Kickstarter. Each keyword runs independently and respects the filters below. Leave empty to browse the full Discover feed. |
| `startUrls` | array | `[]` | Paste Kickstarter Discover or search URLs directly. Each URL is scraped as-is and ignores the filters below. |

#### Filters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `category` | string | (all) | Limit results to one of 15 Kickstarter categories: Art, Comics, Crafts, Dance, Design, Fashion, Film & Video, Food, Games, Journalism, Music, Photography, Publishing, Technology, Theater. Leave empty for all categories. |
| `state` | string | `all` | Funding status: All projects, Live (currently funding), or Successful (fully funded). |
| `sort` | string | `magic` | Result ordering: Magic (recommended), Popularity, Newest, Ending soon, or Most funded. |
| `staffPicks` | boolean | `false` | Only include projects featured as Kickstarter Staff Picks (editor-curated highlights). |
| `location` | string | (worldwide) | Limit to a place — a city, state, or country name (e.g. "Berlin", "California", "Canada"). Leave empty for worldwide. |

#### Limits

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum projects to collect across all keywords and URLs. Set to `0` for unlimited. Kickstarter limits how deep its Discover feed can be paged, so each keyword or URL returns up to about 2,500 projects — use filters to reach deeper. Each project is one billed result. |

### Output

Every run returns one flat row per project. Example record:

```json
{
    "projectId": 1234567890,
    "slug": "the-best-board-game-ever",
    "title": "The Best Board Game Ever",
    "blurb": "A fast, tactical board game for 2-5 players.",
    "state": "live",
    "url": "https://www.kickstarter.com/projects/gamestudio/the-best-board-game-ever",
    "rewardsUrl": "https://www.kickstarter.com/projects/gamestudio/the-best-board-game-ever/rewards",
    "imageUrl": "https://i.kickstarter.com/assets/044/cover.jpg",
    "creator": "Game Studio",
    "creatorId": 987654321,
    "creatorSlug": "gamestudio",
    "category": "Tabletop Games",
    "categoryId": 34,
    "parentCategory": "Games",
    "country": "US",
    "location": "Portland, OR",
    "currency": "USD",
    "currencySymbol": "$",
    "fundingGoal": 25000.0,
    "pledged": 142380.0,
    "usdPledged": 142380.0,
    "backers": 3104,
    "percentFunded": 569.52,
    "daysLeft": 12,
    "staffPick": true,
    "spotlight": false,
    "createdAt": "2025-09-01T14:22:10+00:00",
    "launchedAt": "2025-10-15T16:00:00+00:00",
    "deadline": "2025-11-30T16:00:00+00:00",
    "sourceQuery": "board game"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `projectId` | integer | Kickstarter numeric project ID. |
| `slug` | string | Project URL slug. |
| `title` | string | Project name. |
| `blurb` | string | Short one-line description. |
| `state` | string | Funding state (live, successful, failed, canceled, suspended). |

#### Funding Metrics

| Field | Type | Description |
|-------|------|-------------|
| `fundingGoal` | number | Funding goal in the project's currency. |
| `pledged` | number | Amount pledged in the project's currency. |
| `usdPledged` | number | Amount pledged converted to USD. |
| `backers` | integer | Number of backers. |
| `percentFunded` | number | Percent of the goal funded (above 100 = overfunded). |
| `daysLeft` | integer | Days remaining (0 or negative once ended). |
| `currency` | string | Project currency code (ISO 4217). |
| `currencySymbol` | string | Currency symbol. |

#### Creator & Category

| Field | Type | Description |
|-------|------|-------------|
| `creator` | string | Creator display name. |
| `creatorId` | integer | Creator numeric ID. |
| `creatorSlug` | string | Creator profile slug. |
| `category` | string | Sub-category name (e.g. "Tabletop Games"). |
| `categoryId` | integer | Category numeric ID. |
| `parentCategory` | string | Top-level category name (e.g. "Games"). |

#### Location & Dates

| Field | Type | Description |
|-------|------|-------------|
| `country` | string | Project country code. |
| `location` | string | Human-readable location (city, state/country). |
| `createdAt` | string | Project creation timestamp (ISO 8601). |
| `launchedAt` | string | Campaign launch timestamp (ISO 8601). |
| `deadline` | string | Campaign end timestamp (ISO 8601). |

#### Flags, Media & Source

| Field | Type | Description |
|-------|------|-------------|
| `staffPick` | boolean | Featured as a Kickstarter Staff Pick. |
| `spotlight` | boolean | In the post-campaign Spotlight. |
| `url` | string | Canonical project URL. |
| `rewardsUrl` | string | Direct URL to the rewards/pledge tiers section. |
| `imageUrl` | string | Project cover image URL. |
| `sourceQuery` | string | Which input (search term, URL, or filter combo) produced this row. |

### Tips for Best Results

- **Study what wins by combining `state: successful` with `sort: most_funded`** — this surfaces the top-raising completed campaigns in any category, the gold standard for "what backers reward".
- **Spot proven demand with `percentFunded`** — any value above 100 means the campaign is overfunded; sort by Most Funded and scan for breakouts well into the hundreds or thousands of percent.
- **Catch final-stretch campaigns with `sort: end_date` and `state: live`** — this is the "Ending soon" ordering, and last-minute pledge surges are common, so closing campaigns are useful momentum signals.
- **Use `staffPicks: true` for editorially-vetted leads** — these are hand-selected by Kickstarter's team and skew toward higher-quality, better-presented projects.
- **Run multiple `searchTerms` in one job** — each keyword paginates independently, and the `sourceQuery` field tags every row so you can tell which term it came from.
- **Paste a Discover URL when you've already filtered on the site** — anything you build in Kickstarter's own UI scrapes exactly as-is, no need to recreate it with input fields.
- **Set `maxResults: 0` for an exhaustive pull of a narrow niche** — best paired with a tight category and location so the run stays focused. Kickstarter caps any single feed at roughly 2,500 projects, so narrow filters are how you reach the deeper data.

### Pricing

**$0.90 per 1,000 results** — flat pay-per-result, slightly below the typical market rate for Kickstarter data.

| Results | Estimated Cost |
|---------|----------------|
| 100 | $0.09 |
| 1,000 | $0.90 |
| 10,000 | $9.00 |
| 100,000 | $90.00 |

No compute charges — you only pay per result returned. Each project row counts as one result. Apify platform fees are additional.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor collects publicly available data from Kickstarter's Discover feed for research, analysis, and business intelligence. Use it responsibly: respect Kickstarter's Terms of Service, do not use the data to spam creators or backers, and comply with all applicable data-protection laws (including GDPR and CCPA) when handling any personal information. You are responsible for how you use the data you collect.

# Actor input Schema

## `searchTerms` (type: `array`):

Keywords to search across Kickstarter (e.g., 'board game', 'enamel pin', 'sci-fi novel'). Each keyword runs independently and respects the filters below. Leave empty to browse the full Discover feed instead.

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

Paste Kickstarter Discover or search page URLs directly (for example a category page or a fully filtered Discover URL). Each URL is scraped as-is and ignores the filter settings below.

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

Limit results to a single Kickstarter category. Leave empty to include every category.

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

Filter by funding status. 'All' includes every project, 'Live' is currently raising money, 'Successful' has met its goal.

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

Result ordering. 'Magic' is Kickstarter's recommended mix, 'Popularity' surfaces the most-backed, 'Newest' shows recently launched, 'Ending soon' sorts by closest deadline, 'Most funded' ranks by total pledged.

## `staffPicks` (type: `boolean`):

Only include projects featured as Kickstarter Staff Picks (editor-curated highlights).

## `location` (type: `string`):

Limit results to a place — a city, state, or country name (e.g., 'Berlin', 'California', or 'Canada'). Leave empty for worldwide.

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

Maximum number of projects to collect across all keywords and URLs. Set to 0 for unlimited (the run keeps paging until Kickstarter returns no more projects). Kickstarter limits how deep its Discover feed can be paged, so each keyword or URL returns up to about 2,500 projects — use category, location, or funding-status filters to reach beyond that. Each project is one billed result.

## Actor input object example

```json
{
  "searchTerms": [
    "board game"
  ],
  "startUrls": [],
  "state": "all",
  "sort": "magic",
  "staffPicks": false,
  "maxResults": 100
}
```

# Actor output Schema

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

All scraped projects with the key funding and status fields.

# 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 = {
    "searchTerms": [
        "board game"
    ],
    "startUrls": [],
    "state": "all",
    "sort": "magic",
    "staffPicks": false,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/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 = {
    "searchTerms": ["board game"],
    "startUrls": [],
    "state": "all",
    "sort": "magic",
    "staffPicks": False,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/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 '{
  "searchTerms": [
    "board game"
  ],
  "startUrls": [],
  "state": "all",
  "sort": "magic",
  "staffPicks": false,
  "maxResults": 100
}' |
apify call solidcode/kickstarter-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kickstarter Scraper",
        "description": "[💰 $0.9 / 1K]  Extract Kickstarter crowdfunding projects with full funding metrics, creator info, category, location, and timelines. Search by keyword, filter by category, funding status, sort, and location, or paste Kickstarter Discover URLs directly. One clean row per project.",
        "version": "1.0",
        "x-build-id": "Qcjjy3ztPzcKKPEgB"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~kickstarter-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-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/solidcode~kickstarter-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-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/solidcode~kickstarter-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-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": {
                    "searchTerms": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Keywords to search across Kickstarter (e.g., 'board game', 'enamel pin', 'sci-fi novel'). Each keyword runs independently and respects the filters below. Leave empty to browse the full Discover feed instead.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Kickstarter URLs",
                        "type": "array",
                        "description": "Paste Kickstarter Discover or search page URLs directly (for example a category page or a fully filtered Discover URL). Each URL is scraped as-is and ignores the filter settings below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "art",
                            "comics",
                            "crafts",
                            "dance",
                            "design",
                            "fashion",
                            "film & video",
                            "food",
                            "games",
                            "journalism",
                            "music",
                            "photography",
                            "publishing",
                            "technology",
                            "theater"
                        ],
                        "type": "string",
                        "description": "Limit results to a single Kickstarter category. Leave empty to include every category."
                    },
                    "state": {
                        "title": "Funding Status",
                        "enum": [
                            "all",
                            "live",
                            "successful"
                        ],
                        "type": "string",
                        "description": "Filter by funding status. 'All' includes every project, 'Live' is currently raising money, 'Successful' has met its goal.",
                        "default": "all"
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "magic",
                            "popularity",
                            "newest",
                            "end_date",
                            "most_funded"
                        ],
                        "type": "string",
                        "description": "Result ordering. 'Magic' is Kickstarter's recommended mix, 'Popularity' surfaces the most-backed, 'Newest' shows recently launched, 'Ending soon' sorts by closest deadline, 'Most funded' ranks by total pledged.",
                        "default": "magic"
                    },
                    "staffPicks": {
                        "title": "Staff Picks only",
                        "type": "boolean",
                        "description": "Only include projects featured as Kickstarter Staff Picks (editor-curated highlights).",
                        "default": false
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Limit results to a place — a city, state, or country name (e.g., 'Berlin', 'California', or 'Canada'). Leave empty for worldwide."
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of projects to collect across all keywords and URLs. Set to 0 for unlimited (the run keeps paging until Kickstarter returns no more projects). Kickstarter limits how deep its Discover feed can be paged, so each keyword or URL returns up to about 2,500 projects — use category, location, or funding-status filters to reach beyond that. Each project is one billed result.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
