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

Search Kickstarter projects based on your selected criteria and get structured data on matching projects. Download your data as HTML table, JSON, CSV, Excel, XML, and RSS feed. Forked from misceres/kickstarter-search.

- **URL**: https://apify.com/qbie/kickstarter-scraper.md
- **Developed by:** [Matt Warwick](https://apify.com/qbie) (community)
- **Categories:** Other, Open source
- **Stats:** 431 total users, 10 monthly users, 95.7% runs succeeded, 11 bookmarks
- **User rating**: 2.02 out of 5 stars

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

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

Since the official Kickstarter API does not provide structured output of search results, you can get list of Kickstarter news and projects with this Kickstarter Scraper.

### This Fork
This fork has the following fixes/changes:
- Fixes an issue where the image/photo of a project is not included correctly. See https://console.apify.com/actors/h9kEJvo62ufE8PkSC#/issues/qNFoNx3PwZLS7bBGo/comments
- Changed 'photo' to 'image'
- Adds the image to the 'description' so that it can be parsed by RSS feed readers. I have only tested this with feedly but hopefully others should work too.

### Features

- scrape Kickstarter data up to **2400 items/per run**
- get data from the most recent projects of **any category** and from **any city** 
- search and scrape based on the amount of money **aimed for, pledged and collected**
- **sort by** status, recency or popularity
- name your Kickstarter **datasets** to keep track of all the various runs

### Why scrape Kickstarter?

[Kickstarter](https://www.kickstarter.com/) website is full of crowdfunding projects that are changing the world in many little ways. Here's what you can do with the data about them:

 - Monitor both existing and upcoming  [Kickstarter](https://www.kickstarter.com/) projects in your country or city
 - Analyze which projects are the most likely to get supported and estimate the potential for success
 - Strengthen your own crowdfunding campaign with real-time data
 - Follow the projects competing in the same category all over the country
 - Oversee your own project and [get notifications](https://apify.com/jakubbalada/content-checker) every time it gets funding 
 - Back up your Kickstarter investment analysis with the most recent data
 - Keep track and archive the past successful projects in your city

### Tutorial

For a more detailed explanation of  [how to scrape Kickstarter](https://blog.apify.com/kickstarter-search-actor-create-your-own-kickstarter-api/)  read a step-by-step tutorial on our  [blog](https://blog.apify.com/).

And for more ideas on how to use the extracted data, check out our  [industries pages](https://apify.com/industries)  for concrete ways web scraping results are already being used across businesses of various scale and direction - in  [NGO and Government work](https://apify.com/industries/ngo-and-government) or [Journalism](https://apify.com/industries/marketing-and-media), for instance.

### Cost of usage

On average, scraping  **1000 items**  from Kickstarter via Apify platform will cost you as little as  **0.03 USD credits**  off your subscription plan. For more details about the plans we offer, platform credits and usage, see the  [platform pricing page](https://apify.com/pricing/actors).

If you're not sure how much credits you've got left on your plan and whether you might need to upgrade, you can always check your limits in the  _Settings_  ->  _Usage and Billing_  tab in  [your Console](https://console.apify.com/). The easiest way to know how many credits your actor will need is to perform a test run.


### Input

Input of this actor should be JSON containing filter specification. Allowed filters are:

| **Field** | **Description** | **Allowed values** |
|--|--|--|
|  **query**| Search term | Any string value, e.g. *Nimbus 2000 project*  |
| **category** | Category to search in | Category slug from  [this list](https://github.com/gippy/kickstarter-search/blob/master/categories.json) - anything from *books* to *community gardens* |
|  **location**| Location to search around | Name of the location, e.g. *Prague* |
|  **status**| Status of the project | *All, Live *or* Successful*|
|  **pledged**| Amount pledged |One of: *All, <$1,000 pledged, $1,000 to $10,000 pledged, $10,000 to $100,000 pledged, $100,000 to $1,000,000 pledged and >$1,000,000 pledged*|
|  **goal**| Goal amount | One of: *All, <$1,000 goal, $1,000 to $10,000 goal, $10,000 to $100,000 goal, $100,000 to $1,000,000 goal and >$1,000,000 goal*|
|  **raised**| Amount % raised | One of: *All, < 5% raised, 75% to 100% raised, >100% raised*|
|  **Sort**| Sort by| Popularity,  newest,  end_date,  most_funded or  most_backed|
|  **maxResults**| Maximum number of projects in output | Has to be a positive number, from 0 to 2400 results|
|  **datasetName**| Name of dataset that will be overwritten with data on each run| Alphabet characters, numbers and dash (e.q. my-dataset)|

#### Input example:

```json
{
    "query":  "Board games",  "
    maxResults":  100,  
    "category":  "games",  
    "location":  "United States",  
    "sort":  "newest",  "proxyConfig":  
    {  "useApifyProxy":  true  },  
    "status":  "Successful",  
    "pledged":  "$1,000 to $10,000 pledged",  
    "goal":  "$1,000 to $10,000 goal",  
    "raised":  "All",  
    "datasetName":  ""
}
````

#### Important considerations

- **maxResults**  - Kickstarter website can return a maximum of 200 pages, so at most, you will get 2400 results for any query. To get over 2400 results, run multiple instances of this actor with more specific search terms.

- **datasetName** - If you provide name to a named dataset, every time you run this Kickstarter search actor, it will clear the existing dataset and rewrite it with new data. You can use this option if you want to use named dataset as RSS feed or if you are creating an API.

- **Location**  - You can also run another actor [Kickstarter Location To Ids](https://www.apify.com/jaroslavhejlek/kickstarter-location-to-ids)  to find the specific ID associated with the location.

### During the run

During the run, the actor will output messages letting the you know what is going on. If you provide incorrect input the Kickstarter search actor, it will immediately stop with *Failure* state and output an explanation of what is wrong.

### Output

Once input is properly parsed the actor will load first page of results and output information about the number of found results and how many results are remaining. Every 10th page load will output prediction of how long it will take for the run to finish.

#### Output example

```json
{  
"id":  1662550845,  
"photo":  null,  
"name":  "Escape from HelL",  
"blurb":  "A board game about getting to Manhattan from Williamsburg once the L train shuts down.",  
"goal":  2500,  
"pledged":  7580,  
"state":  "successful",  
"slug":  "escape-from-hell",  
"disable_communication":  false,  
"country":  "US",  
"country_displayable_name":  "the United States",  
"currency":  "USD",  
"currency_symbol":  "$",  
"currency_trailing_code":  true,  
"deadline":  1547854200,  
"state_changed_at":  1547854200,  
"created_at":  1543533003,  
"launched_at":  1545138257,  
"staff_pick":  false,  
"is_starrable":  false,  
"backers_count":  195,  
"static_usd_rate":  1,  
"usd_pledged":  "7580.0",  
"converted_pledged_amount":  7580,  
"fx_rate":  1,  
"usd_exchange_rate":  1,  
"current_currency":  "USD",  
"usd_type":  "international",  
"spotlight":  true,  
"creatorId":  696946511,  
"creatorName": "Escape from Hell",  
"creatorAvatar": "https://ksr-ugc.imgix.net/assets/023/572/288/d31afa951de00ed08ad0c8876cfbb0f2_original.png?ixlib=rb-4.0.2&w=160&h=160&fit=crop&v=1544981648&auto=format&frame=1&q=92&s=c7c176c48efa1a78213c52d58f7b5b98",  
"creatorUrl":  "https://www.kickstarter.com/profile/escapefromhell",  
},
```

### Kickstarter open source

You can manage search results in any language (Python, PHP, Node JS/NPM). See the FAQ or  [our API reference](https://www.apify.com/docs/api)  to learn more about getting results from this Kickstarter Search Actor. The code of this Kickstarter search actor is also open source, so you can create your own solution if you need.

# Actor input Schema

## `query` (type: `string`):

What to search Kickstarter for

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

Limit number of results

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

Category to search in

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

Location where you want to search

## `status` (type: `string`):

Status of the project

## `pledged` (type: `string`):

Amount pledged

## `goal` (type: `string`):

Goal

## `raised` (type: `string`):

% Raised

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

Allows you to change the

## `datasetName` (type: `string`):

Use this if you want the data to be written into named dataset, setting this will overwrite the data with each run

## `proxyConfig` (type: `object`):

Proxy group to use

## Actor input object example

```json
{
  "maxResults": 50,
  "category": "All",
  "status": "All",
  "pledged": "All",
  "goal": "All",
  "raised": "All",
  "sort": "newest",
  "datasetName": "",
  "proxyConfig": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "maxResults": 50,
    "category": "All",
    "sort": "newest",
    "proxyConfig": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("qbie/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 = {
    "maxResults": 50,
    "category": "All",
    "sort": "newest",
    "proxyConfig": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("qbie/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 '{
  "maxResults": 50,
  "category": "All",
  "sort": "newest",
  "proxyConfig": {
    "useApifyProxy": true
  }
}' |
apify call qbie/kickstarter-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Kickstarter Scraper",
        "description": "Search Kickstarter projects based on your selected criteria and get structured data on matching projects. Download your data as HTML table, JSON, CSV, Excel, XML, and RSS feed. Forked from misceres/kickstarter-search.",
        "version": "0.0",
        "x-build-id": "i0VAfLhE8sfSyV2f1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/qbie~kickstarter-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-qbie-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/qbie~kickstarter-scraper/runs": {
            "post": {
                "operationId": "runs-sync-qbie-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/qbie~kickstarter-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-qbie-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",
                "required": [
                    "proxyConfig"
                ],
                "properties": {
                    "query": {
                        "title": "Query",
                        "type": "string",
                        "description": "What to search Kickstarter for"
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Limit number of results"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "All",
                            "art",
                            "art/ceramics",
                            "art/conceptual art",
                            "art/digital art",
                            "art/illustration",
                            "art/installations",
                            "art/mixed media",
                            "art/painting",
                            "art/performance art",
                            "art/public art",
                            "art/sculpture",
                            "art/textiles",
                            "art/video art",
                            "comics",
                            "comics/anthologies",
                            "comics/comic books",
                            "comics/events",
                            "comics/graphic novels",
                            "comics/webcomics",
                            "crafts",
                            "crafts/candles",
                            "crafts/crochet",
                            "crafts/diy",
                            "crafts/embroidery",
                            "crafts/glass",
                            "crafts/knitting",
                            "crafts/pottery",
                            "crafts/printing",
                            "crafts/quilts",
                            "crafts/stationery",
                            "crafts/taxidermy",
                            "crafts/weaving",
                            "crafts/woodworking",
                            "dance",
                            "dance/performances",
                            "dance/residencies",
                            "dance/spaces",
                            "dance/workshops",
                            "design",
                            "design/architecture",
                            "design/civic design",
                            "design/graphic design",
                            "design/interactive design",
                            "design/product design",
                            "design/typography",
                            "fashion",
                            "fashion/accessories",
                            "fashion/apparel",
                            "fashion/childrenswear",
                            "fashion/couture",
                            "fashion/footwear",
                            "fashion/jewelry",
                            "fashion/pet fashion",
                            "fashion/ready-to-wear",
                            "film & video",
                            "film & video/action",
                            "film & video/animation",
                            "film & video/comedy",
                            "film & video/documentary",
                            "film & video/drama",
                            "film & video/experimental",
                            "film & video/family",
                            "film & video/fantasy",
                            "film & video/festivals",
                            "film & video/horror",
                            "film & video/movie theaters",
                            "film & video/music videos",
                            "film & video/narrative film",
                            "film & video/romance",
                            "film & video/science fiction",
                            "film & video/shorts",
                            "film & video/television",
                            "film & video/thrillers",
                            "film & video/webseries",
                            "food",
                            "food/bacon",
                            "food/community gardens",
                            "food/cookbooks",
                            "food/drinks",
                            "food/events",
                            "food/farmer's markets",
                            "food/farms",
                            "food/food trucks",
                            "food/restaurants",
                            "food/small batch",
                            "food/spaces",
                            "food/vegan",
                            "games",
                            "games/gaming hardware",
                            "games/live games",
                            "games/mobile games",
                            "games/playing cards",
                            "games/puzzles",
                            "games/tabletop games",
                            "games/video games",
                            "journalism",
                            "journalism/audio",
                            "journalism/photo",
                            "journalism/print",
                            "journalism/video",
                            "journalism/web",
                            "music",
                            "music/blues",
                            "music/chiptune",
                            "music/classical music",
                            "music/comedy",
                            "music/country & folk",
                            "music/electronic music",
                            "music/faith",
                            "music/hip-hop",
                            "music/indie rock",
                            "music/jazz",
                            "music/kids",
                            "music/latin",
                            "music/metal",
                            "music/pop",
                            "music/punk",
                            "music/r&b",
                            "music/rock",
                            "music/world music",
                            "photography",
                            "photography/animals",
                            "photography/fine art",
                            "photography/nature",
                            "photography/people",
                            "photography/photobooks",
                            "photography/places",
                            "publishing",
                            "publishing/academic",
                            "publishing/anthologies",
                            "publishing/art books",
                            "publishing/calendars",
                            "publishing/children's books",
                            "publishing/comedy",
                            "publishing/fiction",
                            "publishing/letterpress",
                            "publishing/literary journals",
                            "publishing/nonfiction",
                            "publishing/periodicals",
                            "publishing/poetry",
                            "publishing/radio & podcasts",
                            "publishing/translations",
                            "publishing/young adult",
                            "publishing/zines",
                            "publishing/literary spaces",
                            "technology",
                            "technology/3d printing",
                            "technology/apps",
                            "technology/camera equipment",
                            "technology/diy electronics",
                            "technology/fabrication tools",
                            "technology/flight",
                            "technology/gadgets",
                            "technology/hardware",
                            "technology/makerspaces",
                            "technology/robots",
                            "technology/software",
                            "technology/sound",
                            "technology/space exploration",
                            "technology/wearables",
                            "technology/web",
                            "theater",
                            "theater/comedy",
                            "theater/experimental",
                            "theater/festivals",
                            "theater/immersive",
                            "theater/musical",
                            "theater/plays",
                            "theater/spaces"
                        ],
                        "type": "string",
                        "description": "Category to search in"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Location where you want to search"
                    },
                    "status": {
                        "title": "Status",
                        "enum": [
                            "All",
                            "Live",
                            "Successful",
                            "Upcoming"
                        ],
                        "type": "string",
                        "description": "Status of the project",
                        "default": "All"
                    },
                    "pledged": {
                        "title": "Amount pledged",
                        "enum": [
                            "All",
                            "< $1,000 pledged",
                            "$1,000 to $10,000 pledged",
                            "$10,000 to $100,000 pledged",
                            "$100,000 to $1,000,000 pledged",
                            "> $1,000,000 pledged"
                        ],
                        "type": "string",
                        "description": "Amount pledged",
                        "default": "All"
                    },
                    "goal": {
                        "title": "Goal",
                        "enum": [
                            "All",
                            "< $1,000 goal",
                            "$1,000 to $10,000 goal",
                            "$10,000 to $100,000 goal",
                            "$100,000 to $1,000,000 goal",
                            "> $1,000,000 goal"
                        ],
                        "type": "string",
                        "description": "Goal",
                        "default": "All"
                    },
                    "raised": {
                        "title": "% Raised",
                        "enum": [
                            "All",
                            "< 75% raised",
                            "75% to 100% raised",
                            "> 100% raised"
                        ],
                        "type": "string",
                        "description": "% Raised",
                        "default": "All"
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "newest",
                            "popularity",
                            "end_date",
                            "most_funded",
                            "most_backed",
                            "magic"
                        ],
                        "type": "string",
                        "description": "Allows you to change the ",
                        "default": "newest"
                    },
                    "datasetName": {
                        "title": "Dataset name",
                        "type": "string",
                        "description": "Use this if you want the data to be written into named dataset, setting this will overwrite the data with each run",
                        "default": ""
                    },
                    "proxyConfig": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy group to use",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
