# Indiegogo Scraper (`crawlerbros/indiegogo-scraper`) Actor

Scrape Indiegogo crowdfunding campaigns with funding goal, raised amount, backers, currency, deadline, creator, category, tags, image, and discovery feeds (trending, ending soon, by category, search).

- **URL**: https://apify.com/crawlerbros/indiegogo-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 11 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Indiegogo Scraper

Scrape Indiegogo crowdfunding campaigns at scale — discover trending or ending-soon campaigns, browse by category, search by keyword, or fetch one or more campaigns by URL/slug. Returns funding goal, raised amount, backers, currency, deadline, creator, category, tags, image, and the full project story.

No login required. No cookies. Works out of the box.

### Use cases

- Track competitor crowdfunding campaigns in your niche
- Build leaderboards of the most-funded campaigns by category
- Monitor new launches in tech, design, film, music, and more
- Power crowdfunding analytics dashboards
- Build email outreach lists of founders raising on Indiegogo
- Study what makes a campaign succeed (goal vs. raised vs. backers)

### Modes

| Mode | What it does |
|---|---|
| `discoverTrending` | Popular campaigns right now (default) |
| `discoverEndingSoon` | Campaigns about to close — fund-now urgency |
| `discoverNewest` | Newest campaigns |
| `discoverMostFunded` | Highest raised amount |
| `discoverCategory` | Browse a category (Tech, Creative, Community, Gaming) |
| `searchCampaigns` | Free-text keyword search |
| `byCampaign` | One or more campaign slugs (`witchcraft-the-lanterne-of-light`) |
| `byUrl` | One or more full Indiegogo campaign URLs |

### Input

| Field | Type | Description |
|---|---|---|
| `mode` | enum | What to scrape (see modes table). |
| `query` | string | Search keyword (mode=searchCampaigns). |
| `category` | enum | `tech`, `creative`, `community`, or `gaming`. |
| `subCategory` | enum | Specific tag (audio, film, drones, gaming, etc.). |
| `sortBy` | enum | `trending`, `newest`, `ending_soon`, `most_funded`. |
| `projectType` | enum | `any`, `campaign` (default — live crowdfunding), `marketplace`. |
| `status` | enum | `any`, `live`, `ended`, `in_demand` (post-campaign sales). |
| `slugs` | list | Campaign slugs (mode=byCampaign). |
| `urls` | list | Full Indiegogo URLs (mode=byUrl). |
| `minBackers` | int | Drop campaigns with fewer backers than this. |
| `minRaised` | int | Drop campaigns that raised less than this (native currency). |
| `fundedOnly` | bool | Drop campaigns that haven't reached their goal. |
| `maxItems` | int | Hard cap on emitted records (1-1000). |
| `autoEscalateOnBlock` | bool | Auto-engage Apify Proxy on Cloudflare 403. |

### Example input

```json
{
  "mode": "discoverTrending",
  "category": "tech",
  "maxItems": 10
}
````

```json
{
  "mode": "searchCampaigns",
  "query": "headphones",
  "sortBy": "most_funded",
  "fundedOnly": true,
  "maxItems": 50
}
```

```json
{
  "mode": "byUrl",
  "urls": [
    "https://www.indiegogo.com/projects/witchcraft-the-lanterne-of-light"
  ]
}
```

### Output

Each record is an Indiegogo campaign with these fields (`null`/empty values are omitted):

```json
{
  "platform": "indiegogo",
  "id": 244299,
  "slug": "Witchcraft-The-Lanterne-of-Light",
  "name": "Witchcraft: The Lanterne of Light",
  "shortDescription": "When a paranormal crew discovers a cursed lantern...",
  "url": "https://www.indiegogo.com/en/projects/andrewpierson-37875854/witchcraft-the-lanterne-of-light",
  "imageUrl": "https://cdn.images.indiegogo.com/...",
  "campaignGoal": 5000,
  "fundsGathered": 14230.0,
  "backersCount": 16,
  "followersCount": 54,
  "currencySymbol": "$",
  "currencyCode": "USD",
  "campaignStart": "2026-05-01T14:00:00Z",
  "campaignEnd": "2026-06-16T13:00:00Z",
  "publishedDate": "2026-04-24T03:55:18.137Z",
  "campaignDay": 8,
  "fundedAt": "2026-05-01T21:10:46.083Z",
  "phase": 10,
  "phaseLabel": "live",
  "categoryId": 56,
  "categoryName": "Film",
  "tags": ["horror", "indie", "film"],
  "creator": {
    "id": 1821148,
    "name": "Andrew Pierson",
    "urlName": "andrewpierson-37875854",
    "url": "https://www.indiegogo.com/creators/andrewpierson-37875854"
  },
  "creatorName": "Andrew Pierson",
  "creatorUrlName": "andrewpierson-37875854",
  "stretchGoals": [
    {"goalAmount": 10000, "title": "Goal #1: Production starts"}
  ],
  "tabUrls": {
    "project": "https://www.indiegogo.com/en/projects/.../witchcraft...",
    "rewards": "https://www.indiegogo.com/en/projects/.../rewards",
    "comments": "https://www.indiegogo.com/en/projects/.../comments",
    "updates": "https://www.indiegogo.com/en/projects/.../updates"
  },
  "storyHtml": "<div><b>WITCHCRAFT: THE LANTERNE OF LIGHT...",
  "storyText": "WITCHCRAFT: THE LANTERNE OF LIGHT A Feature Film...",
  "scrapedAt": "2026-05-09T20:51:08.123456+00:00"
}
```

Search/discover cards include the same core fields. Detail records (mode=`byUrl` / `byCampaign`) additionally include `storyHtml` / `storyText` and `tabUrls`.

### FAQs

**Q: Do I need cookies, an API key, or a proxy?**
A: No. The actor works directly from datacenter IPs via TLS impersonation (curl\_cffi Chrome 131). If Indiegogo's Cloudflare blocks your run, the actor automatically escalates to Apify Proxy (RESIDENTIAL on second block).

**Q: Why don't I see updates / comments?**
A: Indiegogo loads its Updates and Comments tabs via XHR after the campaign page renders, so neither the SSR HTML nor a public API exposes them. The actor surfaces the tab URLs (`tabUrls.updates`, `tabUrls.comments`) so you can navigate to them in a browser, but it does not paginate update/comment content. Story HTML, goal, raised, backers, dates, creator, category and stretch-goals are all returned.

**Q: What does "InDemand" mean?**
A: After a campaign closes, the creator can re-list the product on Indiegogo's InDemand marketplace for ongoing pre-orders. We expose this via `status=in_demand` and `phase=40`.

**Q: Why does `currencyCode` sometimes differ from `currencySymbol`?**
A: Some campaigns are listed in currencies whose symbol overlaps with USD (`$` for USD, AUD, CAD, HKD). The numeric `currencyCode` is the authoritative ISO code.

**Q: How many results per page?**
A: Indiegogo's search/discover endpoint returns 12-24 cards per page; the actor paginates automatically up to `maxItems`.

**Q: Can I filter by language / country?**
A: Indiegogo does not expose locale-based filters in search. The actor ships English (`/en/projects/search`) by default. Add `language` / `country` to your input to request — currently the upstream API doesn't support it.

**Q: Why does my run sometimes return zero records?**
A: The most likely cause is an over-restrictive filter combo (e.g., `minBackers=10000 + minRaised=1000000 + fundedOnly=true`). Try with fewer filters first, then narrow.

### Limitations

- **Updates / comments are not extracted** (XHR-rendered, no SSR data; see FAQ above).
- **Campaign rewards** are summarised on the detail page but not paginated separately — the actor returns whatever is in the SSR.
- **Currency conversion** is not performed — `fundsGathered` is in the campaign's native currency.
- **Cloudflare blocks** are auto-escalated to Apify Proxy; if RESIDENTIAL is also blocked the run will surface a typed error record per failed URL.

# Actor input Schema

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

What to scrape.

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

Free-text keyword search. Required for `mode=searchCampaigns`.

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

Indiegogo top-level catalog category. Required for `mode=discoverCategory`; optional otherwise to filter by topic. Provide `subCategory` for a narrower filter (e.g., `film`, `audio`).

## `subCategory` (type: `string`):

Specific Indiegogo sub-category. If set, takes precedence over `category` (it's narrower).

## `sortBy` (type: `string`):

Sort order for search and category browse.

## `projectType` (type: `string`):

Filter by project type. Indiegogo lists active crowdfunding campaigns plus marketplace post-campaign products.

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

Filter by campaign lifecycle phase.

## `slugs` (type: `array`):

Indiegogo campaign URL slugs (the part after `/projects/`, e.g. `witchcraft-the-lanterne-of-light`).

## `urls` (type: `array`):

Full Indiegogo campaign URLs (e.g. `https://www.indiegogo.com/projects/<slug>`).

## `minBackers` (type: `integer`):

Drop campaigns with fewer backers than this.

## `minRaised` (type: `integer`):

Drop campaigns that raised less than this (in the campaign's native currency).

## `fundedOnly` (type: `boolean`):

Drop campaigns that haven't reached their funding goal yet.

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

Hard cap on emitted records. Indiegogo serves 12-24 results per discovery page; the actor paginates as needed.

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

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

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

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

## Actor input object example

```json
{
  "mode": "discoverTrending",
  "category": "tech",
  "projectType": "campaign",
  "slugs": [],
  "urls": [],
  "fundedOnly": false,
  "maxItems": 10,
  "autoEscalateOnBlock": true,
  "proxyGroups": []
}
```

# Actor output Schema

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

Dataset of all scraped Indiegogo campaign records.

# 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": "discoverTrending",
    "category": "tech",
    "projectType": "campaign",
    "fundedOnly": false,
    "maxItems": 10,
    "autoEscalateOnBlock": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/indiegogo-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": "discoverTrending",
    "category": "tech",
    "projectType": "campaign",
    "fundedOnly": False,
    "maxItems": 10,
    "autoEscalateOnBlock": True,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/indiegogo-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": "discoverTrending",
  "category": "tech",
  "projectType": "campaign",
  "fundedOnly": false,
  "maxItems": 10,
  "autoEscalateOnBlock": true
}' |
apify call crawlerbros/indiegogo-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indiegogo Scraper",
        "description": "Scrape Indiegogo crowdfunding campaigns with funding goal, raised amount, backers, currency, deadline, creator, category, tags, image, and discovery feeds (trending, ending soon, by category, search).",
        "version": "1.0",
        "x-build-id": "Jx6G4XmjapGc0ndDc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~indiegogo-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-indiegogo-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~indiegogo-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-indiegogo-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~indiegogo-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-indiegogo-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "discoverTrending",
                            "discoverEndingSoon",
                            "discoverNewest",
                            "discoverMostFunded",
                            "discoverCategory",
                            "searchCampaigns",
                            "byCampaign",
                            "byUrl"
                        ],
                        "type": "string",
                        "description": "What to scrape.",
                        "default": "discoverTrending"
                    },
                    "query": {
                        "title": "Search query (mode=searchCampaigns)",
                        "type": "string",
                        "description": "Free-text keyword search. Required for `mode=searchCampaigns`."
                    },
                    "category": {
                        "title": "Category (mode=discoverCategory / discoverTrending / searchCampaigns)",
                        "enum": [
                            "tech",
                            "creative",
                            "community",
                            "gaming"
                        ],
                        "type": "string",
                        "description": "Indiegogo top-level catalog category. Required for `mode=discoverCategory`; optional otherwise to filter by topic. Provide `subCategory` for a narrower filter (e.g., `film`, `audio`).",
                        "default": "tech"
                    },
                    "subCategory": {
                        "title": "Sub-category (optional)",
                        "enum": [
                            "productivity",
                            "travel-and-outdoors",
                            "home",
                            "energy-and-green-tech",
                            "camera-gear",
                            "health-and-fitness",
                            "transportation",
                            "phones-and-accessories",
                            "fashion-and-wearables",
                            "food-and-beverages",
                            "audio",
                            "education",
                            "film",
                            "comics",
                            "music",
                            "writing-and-publishing",
                            "dance-and-theater",
                            "art",
                            "web-series-and-tv-shows",
                            "podcasts-blogs-and-vlogs",
                            "photography",
                            "wellness",
                            "culture",
                            "local-businesses",
                            "environment",
                            "human-rights",
                            "board-and-card-games",
                            "video-games",
                            "tabletop-rpg",
                            "gaming-accessories"
                        ],
                        "type": "string",
                        "description": "Specific Indiegogo sub-category. If set, takes precedence over `category` (it's narrower)."
                    },
                    "sortBy": {
                        "title": "Sort order (mode=searchCampaigns / discoverCategory)",
                        "enum": [
                            "trending",
                            "newest",
                            "ending_soon",
                            "most_funded"
                        ],
                        "type": "string",
                        "description": "Sort order for search and category browse."
                    },
                    "projectType": {
                        "title": "Project type",
                        "enum": [
                            "any",
                            "campaign",
                            "marketplace"
                        ],
                        "type": "string",
                        "description": "Filter by project type. Indiegogo lists active crowdfunding campaigns plus marketplace post-campaign products.",
                        "default": "campaign"
                    },
                    "status": {
                        "title": "Campaign status",
                        "enum": [
                            "any",
                            "live",
                            "ended",
                            "in_demand"
                        ],
                        "type": "string",
                        "description": "Filter by campaign lifecycle phase."
                    },
                    "slugs": {
                        "title": "Campaign slugs (mode=byCampaign)",
                        "type": "array",
                        "description": "Indiegogo campaign URL slugs (the part after `/projects/`, e.g. `witchcraft-the-lanterne-of-light`).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "urls": {
                        "title": "Campaign URLs (mode=byUrl)",
                        "type": "array",
                        "description": "Full Indiegogo campaign URLs (e.g. `https://www.indiegogo.com/projects/<slug>`).",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "minBackers": {
                        "title": "Min backers (filter)",
                        "minimum": 0,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Drop campaigns with fewer backers than this."
                    },
                    "minRaised": {
                        "title": "Min raised amount (filter)",
                        "minimum": 0,
                        "maximum": 100000000,
                        "type": "integer",
                        "description": "Drop campaigns that raised less than this (in the campaign's native currency)."
                    },
                    "fundedOnly": {
                        "title": "Funded campaigns only",
                        "type": "boolean",
                        "description": "Drop campaigns that haven't reached their funding goal yet.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Hard cap on emitted records. Indiegogo serves 12-24 results per discovery page; the actor paginates as needed.",
                        "default": 50
                    },
                    "autoEscalateOnBlock": {
                        "title": "Auto-escalate to Apify proxy on block",
                        "type": "boolean",
                        "description": "If true (default), the actor automatically engages Apify Proxy when it hits HTTP 403 / Cloudflare blocks from a raw datacenter IP. Set false to disable.",
                        "default": true
                    },
                    "proxyGroups": {
                        "title": "Apify proxy groups (used on auto-escalation)",
                        "type": "array",
                        "description": "Apify proxy groups to use when auto-escalating after a block. Empty = datacenter (default), then RESIDENTIAL fallback.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
