# Indiegogo Campaign Scraper - Crowdfunding Data Extractor (`parseforge/indiegogo-scraper`) Actor

Scrape Indiegogo crowdfunding campaigns with title, funding goal, amount raised, backers, days left, category, and location.

- **URL**: https://apify.com/parseforge/indiegogo-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 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.
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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🚀 Indiegogo Scraper

> 🚀 **Export Indiegogo crowdfunding campaigns in seconds.** No API key required. Works right out of the box.

> 🕒 **Last updated:** 2026-05-21 · **📊 12 fields** per record · **Thousands of campaigns** · **Global coverage**

The Indiegogo Scraper extracts live campaign data directly from [Indiegogo](https://www.indiegogo.com), one of the world's largest crowdfunding platforms. Every field is scraped in real time - funding goals, amounts raised, backer counts, percent funded, days remaining, and more.

This actor covers all public Indiegogo campaigns across technology, games, arts, food, fashion, and every other category listed on the platform. Data is fetched fresh on every run - no stale cache, no static snapshots.

**Coverage:** All publicly listed Indiegogo campaigns, including InDemand campaigns. Trending, most funded, newest, and ending-soon sort orders. Category filters available. Results include campaigns hosted natively on Indiegogo as well as partner-hosted campaigns (Gamefound, etc.) that appear in Indiegogo search results.

| Who uses this | Why |
|---|---|
| Investors and VCs | Track which categories attract the most backer funding |
| Product researchers | Benchmark crowdfunding performance by category |
| Marketing analysts | Identify high-performing campaign copy and taglines |
| Journalists and bloggers | Monitor trending crowdfunding campaigns |
| E-commerce operators | Spot emerging product trends before they hit retail |
| Data scientists | Build crowdfunding performance datasets |

### 📋 What the Indiegogo Scraper does

- Scrapes the Indiegogo trending, most funded, new, and ending-soon campaign listings
- Filters by category (Technology, Home, Health, Games, Art, Music, Film, and more)
- Searches campaigns by keyword
- Extracts 12 fields per campaign including goal, raised, percent funded, backers, and days left
- Fetches detail pages to enrich listings with tagline, category name, and precise funding figures
- Respects your `maxItems` limit - run small batches or collect thousands

> 💡 **Why it matters:** Indiegogo does not offer a public data API. This scraper is the only reliable way to export Indiegogo campaign data in bulk for analysis, monitoring, or integration.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Default | Description |
|---|---|---|---|
| `maxItems` | integer | 10 | Maximum number of campaigns to return. Free users are limited to 10. |
| `search` | string | - | Keyword to search for (e.g. "smart watch", "solar panel") |
| `category` | string | All | Category filter (Technology, Home, Health, Video Games, etc.) |
| `sort` | select | trending | Sort order: Trending, Most Funded, New, Ending Soon |

**Example - trending campaigns:**
```json
{
    "maxItems": 25,
    "sort": "trending"
}
````

**Example - technology campaigns by keyword:**

```json
{
    "maxItems": 50,
    "search": "smart home",
    "category": "Technology",
    "sort": "most_funded"
}
```

> ⚠️ **Good to Know:** Free users are limited to 10 campaigns per run. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) and upgrade to unlock up to 1,000,000 campaigns.

### 📊 Output

Each record contains 12 fields:

| Field | Type | Description |
|---|---|---|
| 🖼️ `imageUrl` | string | Campaign cover image URL |
| 🏷️ `title` | string | Campaign title |
| 💬 `tagline` | string | Short description / tagline |
| 📂 `category` | string | Category name (Board & Card Games, Technology, etc.) |
| 🎯 `goal` | string | Funding goal (e.g. "$50,000") |
| 💰 `raised` | string | Amount raised so far (e.g. "$576,246.55") |
| 📈 `percentFunded` | string | Percent of goal reached (e.g. "1152%") |
| 👥 `backers` | integer | Number of backers |
| ⏱️ `daysLeft` | string | Time remaining (e.g. "21 days left") |
| 🔗 `url` | string | Campaign URL |
| 🕒 `scrapedAt` | string | ISO 8601 timestamp of when data was scraped |
| ❌ `error` | string/null | Error message if scraping failed, null otherwise |

**Sample records (real data from 2026-05-21):**

```json
[
  {
    "imageUrl": "https://cdn.images.indiegogo.com/projectimage/projects/428363/052aa4c1-67a9-4560-a62f-18d24d1e2f56.png",
    "title": "Proxmark5: Professional RFID Research Platform for Researchers",
    "tagline": "Proxmark5: Open-source ultimate RFID research platform. Wireless. Modular. Extended range. UHF-ready. Endless possibilities for pentesting",
    "category": "General",
    "goal": "$50,000",
    "raised": "$576,246.55",
    "percentFunded": "1152%",
    "backers": 1645,
    "daysLeft": "21 days left",
    "url": "https://www.indiegogo.com/en/projects/rfidresearchgroup/proxmark5",
    "scrapedAt": "2026-05-21T23:58:58.023Z",
    "error": null
  },
  {
    "imageUrl": "https://imgcdn.gamefound.com/projectimage/projects/6631/26b04b7e-692c-4ae3-a1d2-e4a832b1ba2a.png",
    "title": "Terraforming Mars: The Legacy of Mars",
    "tagline": "Terraforming Beyond Mars! Mankind has finally dragged itself out of the hole that is Earth's gravity well, and now has the entire solar system at its feet.",
    "category": "Board & Card Games",
    "goal": "$20,000",
    "raised": "$1,796,941.15",
    "percentFunded": "8984%",
    "backers": 7294,
    "daysLeft": "8 days left",
    "url": "https://gamefound.com/en/projects/stronghold-games/terraforming-mars-the-legacy-of--mars",
    "scrapedAt": "2026-05-21T23:58:41.830Z",
    "error": null
  }
]
```

### ✨ Why choose this Actor

| Feature | Details |
|---|---|
| 🛡️ Real-time data | Every run scrapes live data - no cached responses |
| 🌐 No API key required | Works immediately, no registration needed |
| 📂 12 fields per record | Goal, raised, percent funded, backers, days left, and more |
| 🔍 Flexible filtering | Keyword search, category filter, sort order |
| 💰 Free tier included | 10 campaigns per run on the free plan |
| 📤 Multiple export formats | JSON, CSV, Excel, XML via Apify dataset |
| 🔌 Webhook-ready | Trigger downstream apps on run completion |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual browsing | Indiegogo API |
|---|---|---|---|
| Bulk export | Up to 1,000,000 | Tedious | Not available publicly |
| Category filter | Yes | Yes | N/A |
| Funding data | Yes | Yes | N/A |
| Export CSV/Excel | Yes | No | N/A |
| Automation-ready | Yes | No | N/A |
| Cost | Pay-per-run | Free (time cost) | N/A |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) (includes $5 credit)
2. Open the **Indiegogo Scraper** actor in Apify Store
3. Set your desired `maxItems`, `category`, `search`, and `sort` inputs
4. Click **Run** and wait for the actor to finish
5. Download your dataset as JSON, CSV, Excel, or XML

### 💼 Business use cases

#### Market research and competitive intelligence

Export trending campaigns to identify which product categories are gaining traction with consumers. Compare funding velocity - campaigns that hit 100% of goal in the first 48 hours signal strong product-market fit.

#### Investor deal flow

Monitor Indiegogo for breakthrough hardware, consumer goods, and creative projects. Filter by "most\_funded" to track campaigns that consistently attract large backer communities.

#### Content and journalism

Run this actor daily to track which campaigns went viral. Export to a spreadsheet and sort by `percentFunded` to find the most oversubscribed campaigns of the week.

#### E-commerce product sourcing

Identify products that demonstrated strong consumer demand on Indiegogo before they hit retail. Use `raised` and `backers` to gauge real purchase intent.

### 🔌 Automating Indiegogo Scraper

Connect this actor to your workflow using Apify integrations:

- **Make (formerly Integromat):** Trigger on run completion, send items to Google Sheets or Airtable
- **Zapier:** Run the actor on a schedule, push new campaigns to Slack or Notion
- **Apify Scheduler:** Schedule daily or weekly runs automatically from the Apify Console
- **REST API:** Start runs and download results programmatically via the [Apify API](https://docs.apify.com/api/v2)
- **Webhooks:** Receive a POST request when the run completes to trigger downstream processing

### 🌟 Beyond business use cases

#### Research and academia

Study crowdfunding success patterns over time. Correlate backer counts with funding velocity, tagline length, or category to build predictive models.

#### Non-profit and advocacy

Monitor campaigns in categories like environment, community, and education. Identify grassroots initiatives gaining momentum before mainstream media coverage.

#### Creative and hobbyist projects

Track board game, music, and film campaigns. Build personal watchlists of projects you want to support.

#### Experimentation and learning

Use this actor as a foundation for learning web scraping, data pipelines, and crowdfunding market analysis. Real-world data, ready to explore.

### 🤖 Ask an AI assistant about this scraper

Paste this into ChatGPT, Claude, or Gemini:

> I have a dataset of Indiegogo crowdfunding campaigns with fields: imageUrl, title, tagline, category, goal, raised, percentFunded, backers, daysLeft, url, scrapedAt. Each row is one campaign. Help me analyze which categories have the highest average percent funded, and which campaigns have the most backers relative to their funding goal.

### ❓ Frequently Asked Questions

#### ❓ Does this require an Indiegogo account?

No. All data is scraped from publicly visible campaign listings. No login, no API key, no account needed.

#### ❓ How many campaigns can I scrape?

Free users: up to 10 per run. Paid users: up to 1,000,000. [Upgrade here](https://console.apify.com/sign-up?fpr=vmoqkp).

#### ❓ How fresh is the data?

Data is scraped live on every run. Funding figures, backer counts, and days left reflect the state at the time the actor ran.

#### ❓ Can I filter by category?

Yes. Use the `category` input to filter by Technology, Home, Health, Video Games, Board & Card Games, Art, Music, and more.

#### ❓ Can I search by keyword?

Yes. The `search` field accepts any keyword (e.g. "solar panel", "smart watch", "board game").

#### ❓ What sort orders are available?

Trending, Most Funded, New, and Ending Soon.

#### ❓ Some URLs point to Gamefound - is that normal?

Yes. Indiegogo has a partnership with Gamefound and some campaigns are co-listed. These campaigns appear in Indiegogo search results and are included in the output.

#### ❓ What format is the output in?

By default JSON, but you can download CSV, Excel, or XML from the Apify dataset page.

#### ❓ Can I automate this scraper to run on a schedule?

Yes. Use the Apify Scheduler to run daily, weekly, or on any cron schedule.

#### ❓ Does the scraper capture the funding goal?

Yes. The `goal` field shows the campaign's stated funding goal (e.g. "$50,000"). The `raised` field shows the actual amount raised.

#### ❓ Is the percent funded field accurate?

It reflects the percentage shown on the campaign page, derived from the progress bar. Campaigns over 100% are shown as e.g. "1152%".

#### ❓ Can I use this data commercially?

You are responsible for ensuring your use of scraped data complies with Indiegogo's Terms of Service and applicable laws. This actor accesses only publicly visible data.

### 🔌 Integrate with any app

Export your Indiegogo dataset to any tool:

- **Google Sheets** - via Make or Zapier
- **Airtable** - via Make or the Apify Airtable integration
- **Slack** - send new campaigns to a channel
- **Notion** - sync campaign data to a Notion database
- **BigQuery / Snowflake** - via Apify API and your ETL pipeline
- **Excel** - download directly as .xlsx from the dataset page
- **REST API** - query the dataset via `https://api.apify.com/v2/datasets/{datasetId}/items`
- **Webhook** - receive a POST when a run completes

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [Kickstarter Scraper](https://apify.com/parseforge) | Export Kickstarter campaigns with funding data |
| [Product Hunt Scraper](https://apify.com/parseforge) | Track trending products and upvote counts |
| [Amazon Best Sellers Scraper](https://apify.com/parseforge) | Export Amazon best seller rankings by category |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) to find scrapers for hundreds of popular websites - no code required.

***

**Disclaimer:** This actor scrapes publicly available data from Indiegogo. It is not affiliated with or endorsed by Indiegogo. Use responsibly and in accordance with Indiegogo's Terms of Service and applicable laws.

# Actor input Schema

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `search` (type: `string`):

Keyword search term (e.g. 'smart watch', 'solar panel').

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

Filter campaigns by category.

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

Sort order for results.

## Actor input object example

```json
{
  "maxItems": 10,
  "sort": "trending"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# 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 = {
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = { "maxItems": 10 }

# Run the Actor and wait for it to finish
run = client.actor("parseforge/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 '{
  "maxItems": 10
}' |
apify call parseforge/indiegogo-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Indiegogo Campaign Scraper - Crowdfunding Data Extractor",
        "description": "Scrape Indiegogo crowdfunding campaigns with title, funding goal, amount raised, backers, days left, category, and location.",
        "version": "0.1",
        "x-build-id": "dnUKLouM6hWj9ZDFX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~indiegogo-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-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/parseforge~indiegogo-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-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/parseforge~indiegogo-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-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",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "search": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Keyword search term (e.g. 'smart watch', 'solar panel')."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "Technology",
                            "Home",
                            "Health",
                            "HealthAndFitness",
                            "Productivity",
                            "Transportation",
                            "Art",
                            "Music",
                            "Film",
                            "Food",
                            "Fashion",
                            "Sports",
                            "VideoGames",
                            "BoardAndCardGames",
                            "TTRPG",
                            "Accessories",
                            "WebSeriesAndTVShows",
                            "General"
                        ],
                        "type": "string",
                        "description": "Filter campaigns by category."
                    },
                    "sort": {
                        "title": "Sort By",
                        "enum": [
                            "trending",
                            "most_funded",
                            "new",
                            "ending_soon"
                        ],
                        "type": "string",
                        "description": "Sort order for results.",
                        "default": "trending"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
