# CryptoPanic News Scraper (`solidcode/cryptopanic-news-scraper`) Actor

\[💰 $0.9 / 1K] Collect cryptocurrency news from CryptoPanic — headlines, source, links, coin tags, publish dates, and community sentiment votes (bullish, bearish, important, LOL, and more). Filter by category (rising, hot, bullish, bearish, important), by coin, by content type, and by language.

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

## Pricing

from $0.90 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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

## CryptoPanic News Scraper

Pull real-time cryptocurrency news from CryptoPanic at scale — headlines, source domains, coin tags, publish timestamps, the full community vote breakdown, PanicScore momentum signals, and AI sentiment levels for every post across the feed. Works zero-config with no login or developer token. Built for crypto traders, quant researchers, and sentiment-analysis builders who need a clean, structured stream of crypto news and market mood without managing logins or rate limits.

### Why This Scraper?

- **Zero-config, no token or login required** — point it at a category and get structured news immediately. No account, no key, no signup wall.
- **Full community vote breakdown on every post** — 7 sentiment vote types (bullish, bearish, important, LOL, liked, disliked, saved) plus toxic flags and comment counts, populated on the free anonymous feed.
- **Dual sentiment signals** — CryptoPanic's proprietary PanicScore momentum reading *and* a numeric AI sentiment level on each post, so you can cross-check crowd mood against the model.
- **PanicScore on every curated-category post** — Hot, Rising, Bullish, Bearish, Important, and LOL feeds carry a populated PanicScore on ~98% of rows, giving you a ready-made heat signal for trade timing.
- **8 category filters** — All news, Rising, Hot, Bullish, Bearish, Important, LOL, and Saved, matching CryptoPanic's own community-curated tabs.
- **Coin-tag enrichment with full names** — every post lists the tickers it mentions (BTC, ETH, SOL) plus a `coinsDetail` block resolving each ticker to its full coin name and slug, so you never have to maintain a ticker lookup table.
- **News and media in one run** — collect written articles, video and podcast posts, or both, with each post carrying its own content type.
- **14 region/language locales** — supply your free CryptoPanic developer token to unlock true server-side filtering across English, German, Spanish, Chinese, Japanese, Korean, and 8 more.
- **Up to 1,000 posts per run** — sweeps CryptoPanic's full feed depth with smooth automatic pagination and duplicate removal.

### Use Cases

**Trading & Market Signals**
- Surface Hot and Rising headlines with PanicScore to time entries and exits
- Track bullish-vs-bearish vote ratios as a real-time crowd-sentiment gauge
- Monitor the Important feed for market-moving announcements as they break
- Watch a single coin (BTC, ETH, SOL) and alert on spikes in coverage

**Quant & Sentiment Research**
- Build labeled datasets pairing headlines with AI sentiment levels and community votes
- Backtest news-driven strategies against PanicScore momentum readings
- Correlate comment counts and vote velocity with price action
- Feed structured crypto-news streams into NLP and forecasting models

**Brand & Project Monitoring**
- Track every mention of your token across hundreds of crypto news sources
- Measure community reception via the bullish/bearish/LOL vote mix
- Catch negative or toxic-flagged coverage early
- Compare share of voice between competing coins

**Content & Newsletter Curation**
- Pull the top Hot and Rising stories for a daily crypto digest
- Filter to media posts for video and podcast round-ups
- Source region-specific headlines for localized newsletters
- Auto-populate a research dashboard with fresh, deduplicated news

### Getting Started

#### Latest News (simplest)

Just run it — the default returns the latest 100 stories across all coins, no token needed:

```json
{
    "filter": "all",
    "maxItems": 100
}
````

#### Hot Bitcoin News with Sentiment

The most useful combination — a curated feed (so PanicScore lands on every row) narrowed to one coin:

```json
{
    "filter": "hot",
    "coins": ["BTC"],
    "kind": "news",
    "maxItems": 200
}
```

#### Region-Filtered Feed with API Token

Supply your free developer token to unlock server-side language and region filtering:

```json
{
    "filter": "rising",
    "coins": ["ETH", "SOL"],
    "language": "de",
    "apiToken": "your-free-cryptopanic-token",
    "maxItems": 500
}
```

### Input Reference

#### What to Collect

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `filter` | select | `All news` | Which slice of the feed to collect: All news, Rising, Hot, Bullish, Bearish, Important, LOL, or Saved. The curated tabs (Hot, Rising, Bullish, Bearish, Important, LOL) carry PanicScore on almost every post. |
| `kind` | select | `News and media` | Content type: News and media, News only, or Media only (videos and podcasts). |
| `coins` | string\[] | `[]` | Limit results to specific coins by ticker symbol, e.g. BTC, ETH, SOL. Leave empty to collect news about every coin. |

#### Region & Token

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `language` | select | `English` | Region/language for results — 14 options (English, German, Dutch, Spanish, French, Italian, Portuguese, Russian, Turkish, Arabic, Chinese, Japanese, Korean, Vietnamese). Applies only when an API token is supplied below; without a token the feed is global and this setting is ignored. |
| `apiToken` | string | `null` | Optional free CryptoPanic developer token. Supplying it switches to CryptoPanic's official developer API and unlocks true language/region filtering. Get one free at cryptopanic.com/developers/api. Leave empty to run in anonymous mode, which returns PanicScore and AI sentiment. |

#### Limit

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxItems` | integer | `100` | Maximum news items to collect in one run (1–1,000). The feed exposes roughly the latest 1,000 stories, so higher values return at most 1,000. |

### Output

Each post is one flat row. Here is a representative result from the anonymous (no-token) mode:

```json
{
    "id": 18472311,
    "title": "Bitcoin Reclaims $70K as Spot ETF Inflows Hit Record High",
    "newsUrl": "https://www.coindesk.com/markets/2026/06/12/bitcoin-reclaims-70k",
    "cryptopanicUrl": "https://cryptopanic.com/news/18472311/Bitcoin-Reclaims-70K",
    "sourceTitle": "CoinDesk",
    "sourceDomain": "coindesk.com",
    "sourceRegion": "en",
    "coins": ["BTC", "ETH"],
    "coinsDetail": [
        { "code": "BTC", "title": "Bitcoin", "slug": "bitcoin" },
        { "code": "ETH", "title": "Ethereum", "slug": "ethereum" }
    ],
    "kind": "news",
    "filter": "hot",
    "publishedAt": "2026-06-12T09:14:00Z",
    "createdAt": "2026-06-12T09:15:22Z",
    "image": "https://static.cryptopanic.com/media/18472311.jpg",
    "summary": "Bitcoin climbed back above $70,000 on Thursday as spot ETF inflows...",
    "panicScore": 87,
    "panicScore1h": 87,
    "panicScore24h": 72,
    "aiSentimentLevel": 4,
    "votesPositive": 31,
    "votesNegative": 4,
    "votesImportant": 12,
    "votesLol": 1,
    "votesLiked": 18,
    "votesDisliked": 2,
    "votesToxic": 0,
    "votesSaved": 9,
    "commentsCount": 6,
    "relatedPosts": [
        {
            "id": 18472390,
            "title": "ETF inflows top $1B in a single day",
            "url": "https://www.theblock.co/post/etf-inflows",
            "domain": "theblock.co",
            "publishedAt": "2026-06-12T09:40:00Z"
        }
    ],
    "source": "anonymous",
    "scrapedAt": "2026-06-12T09:45:10Z"
}
```

#### Core Fields

| Field | Type | Description |
|-------|------|-------------|
| `id` | number | Unique CryptoPanic post identifier |
| `title` | string | News headline |
| `kind` | string | Post content type (news, media, etc.) |
| `filter` | string | The category feed this post came from |
| `summary` | string | Short article summary, when available |
| `image` | string | Thumbnail image URL, when available |
| `publishedAt` | string | Original publish timestamp (ISO 8601) |
| `createdAt` | string | When CryptoPanic indexed the post (ISO 8601) |
| `scrapedAt` | string | ISO timestamp of data collection |
| `source` | string | Data mode for this row: `anonymous` or `api` |

#### Source & Links

| Field | Type | Description |
|-------|------|-------------|
| `newsUrl` | string | Direct link to the original article |
| `cryptopanicUrl` | string | The post's page on CryptoPanic |
| `sourceTitle` | string | Publication name (e.g. CoinDesk) |
| `sourceDomain` | string | Publication domain |
| `sourceRegion` | string | Source region/language code |
| `relatedPosts` | object\[] | Linked coverage of the same story (id, title, url, domain, publishedAt) |

#### Coins

| Field | Type | Description |
|-------|------|-------------|
| `coins` | string\[] | Ticker symbols mentioned in the post (e.g. BTC, ETH) |
| `coinsDetail` | object\[] | Each ticker resolved to full coin name and slug (code, title, slug) |

#### Sentiment & Votes

| Field | Type | Description |
|-------|------|-------------|
| `panicScore` | number | Live PanicScore momentum signal (populated on ~98% of curated-category posts) |
| `panicScore1h` | number | Rolling 1-hour PanicScore |
| `panicScore24h` | number | Rolling 24-hour PanicScore |
| `aiSentimentLevel` | number | AI-assigned sentiment level for the post |
| `votesPositive` | number | Bullish votes |
| `votesNegative` | number | Bearish votes |
| `votesImportant` | number | "Important" votes |
| `votesLol` | number | "LOL" votes |
| `votesLiked` | number | Likes |
| `votesDisliked` | number | Dislikes |
| `votesToxic` | number | Toxic-flag votes |
| `votesSaved` | number | Times the post was saved |
| `commentsCount` | number | Number of community comments |

### Tips for Best Results

- **Use Hot or Rising for sentiment work** — these curated feeds carry a populated PanicScore on ~98% of rows, while the raw "All news" feed has it on only a fraction. Pick a curated category whenever you want a momentum signal on every post.
- **Read `coinsDetail`, not just `coins`** — CryptoPanic's auto-tagger occasionally attaches short or generic tickers; the full coin name and slug in `coinsDetail` let you confirm which asset a post really concerns.
- **Filter by ticker to cut noise** — set `coins` to the assets you track so each run returns only relevant headlines instead of the whole firehose.
- **Combine vote fields into a ratio** — dividing `votesPositive` by `votesNegative` gives a quick crowd bull/bear gauge that updates as a story spreads.
- **Add your free token for localized feeds** — language/region filtering only activates with a developer token; without one the feed is global regardless of the language setting.
- **Start small, then scale** — run with `maxItems` at 50–100 to confirm the data fits your needs before pulling the full 1,000-post depth.
- **Schedule short, frequent runs** — crypto news moves fast; a small run every few minutes keeps a fresher stream than one large daily pull.

### Pricing

**From $0.90 per 1,000 results** — pay only for the news posts you collect. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.11 | $0.10 | $0.10 | $0.09 |
| 1,000 | $1.05 | $1.00 | $0.95 | $0.90 |
| 10,000 | $10.50 | $10.00 | $9.50 | $9.00 |
| 100,000 | $105.00 | $100.00 | $95.00 | $90.00 |

A "result" is any news post row in the output dataset. Apify platform fees are additional and depend on your plan.

### Integrations

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

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

### Legal & Ethical Use

This actor is designed for legitimate market research, sentiment analysis, and news monitoring. Users are responsible for complying with applicable laws and CryptoPanic's Terms of Service. Do not use collected data for spam, harassment, or any illegal purpose. Nothing here is financial advice — crypto news and sentiment signals are informational only.

# Actor input Schema

## `filter` (type: `string`):

Which slice of the news feed to collect. 'All news' returns the latest stories; the other options match CryptoPanic's community-curated tabs.

## `kind` (type: `string`):

Collect written news articles, media posts (videos, podcasts), or both.

## `coins` (type: `array`):

Limit results to specific coins by their ticker symbol, for example BTC, ETH, SOL. Leave empty to collect news about every coin.

## `language` (type: `string`):

Region/language filtering applies only when a CryptoPanic API token is provided below; without a token the feed is global and this setting is ignored. Defaults to English.

## `apiToken` (type: `string`):

Optional. Paste a free CryptoPanic developer token to unlock community vote counts (bullish, bearish, important, LOL, liked, disliked, toxic, saved), comment counts, and true language/region filtering. Get one free at cryptopanic.com/developers/api. Leave empty to run in anonymous mode (no token needed), which instead provides PanicScore and AI sentiment.

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

Most news items to collect in one run. CryptoPanic exposes roughly the latest 1,000 stories per feed, so values above 1,000 will return at most 1,000 items.

## Actor input object example

```json
{
  "filter": "all",
  "kind": "all",
  "coins": [],
  "language": "en",
  "maxItems": 100
}
```

# Actor output Schema

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

Table of news items with title, source, coins, published date, category, PanicScore, and sentiment votes.

# 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 = {
    "filter": "all",
    "kind": "all",
    "coins": [],
    "language": "en",
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/cryptopanic-news-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 = {
    "filter": "all",
    "kind": "all",
    "coins": [],
    "language": "en",
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/cryptopanic-news-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 '{
  "filter": "all",
  "kind": "all",
  "coins": [],
  "language": "en",
  "maxItems": 100
}' |
apify call solidcode/cryptopanic-news-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CryptoPanic News Scraper",
        "description": "[💰 $0.9 / 1K] Collect cryptocurrency news from CryptoPanic — headlines, source, links, coin tags, publish dates, and community sentiment votes (bullish, bearish, important, LOL, and more). Filter by category (rising, hot, bullish, bearish, important), by coin, by content type, and by language.",
        "version": "1.0",
        "x-build-id": "oqbhVM2xfraQ4jicC"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~cryptopanic-news-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-cryptopanic-news-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/solidcode~cryptopanic-news-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-cryptopanic-news-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/solidcode~cryptopanic-news-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-cryptopanic-news-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": {
                    "filter": {
                        "title": "News Category",
                        "enum": [
                            "all",
                            "rising",
                            "hot",
                            "bullish",
                            "bearish",
                            "important",
                            "lol",
                            "saved"
                        ],
                        "type": "string",
                        "description": "Which slice of the news feed to collect. 'All news' returns the latest stories; the other options match CryptoPanic's community-curated tabs.",
                        "default": "all"
                    },
                    "kind": {
                        "title": "Content Type",
                        "enum": [
                            "all",
                            "news",
                            "media"
                        ],
                        "type": "string",
                        "description": "Collect written news articles, media posts (videos, podcasts), or both.",
                        "default": "all"
                    },
                    "coins": {
                        "title": "Coins",
                        "type": "array",
                        "description": "Limit results to specific coins by their ticker symbol, for example BTC, ETH, SOL. Leave empty to collect news about every coin.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Language / Region",
                        "enum": [
                            "en",
                            "de",
                            "nl",
                            "es",
                            "fr",
                            "it",
                            "pt",
                            "ru",
                            "tr",
                            "ar",
                            "zh",
                            "ja",
                            "ko",
                            "vi"
                        ],
                        "type": "string",
                        "description": "Region/language filtering applies only when a CryptoPanic API token is provided below; without a token the feed is global and this setting is ignored. Defaults to English.",
                        "default": "en"
                    },
                    "apiToken": {
                        "title": "CryptoPanic API Token (optional)",
                        "type": "string",
                        "description": "Optional. Paste a free CryptoPanic developer token to unlock community vote counts (bullish, bearish, important, LOL, liked, disliked, toxic, saved), comment counts, and true language/region filtering. Get one free at cryptopanic.com/developers/api. Leave empty to run in anonymous mode (no token needed), which instead provides PanicScore and AI sentiment."
                    },
                    "maxItems": {
                        "title": "Maximum News Items",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Most news items to collect in one run. CryptoPanic exposes roughly the latest 1,000 stories per feed, so values above 1,000 will return at most 1,000 items.",
                        "default": 100
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
