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

Scrape CryptoPanic headlines, source links, coin tags, publish times, and summaries for crypto trading alerts and market intelligence.

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

## Pricing

Pay per event

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

Scrape public CryptoPanic crypto news feeds for headlines, publisher links, coin tags, publish times, and summaries.

Use this actor when you need a repeatable CryptoPanic scraper for trading dashboards, market-intelligence alerts, newsletters, and research pipelines.

### What does CryptoPanic News Scraper do?

CryptoPanic News Scraper collects public news posts from CryptoPanic.

It starts from the latest feed, selected coin feeds, or your own CryptoPanic feed URLs.

For each post it can also open the CryptoPanic detail page and resolve the original publisher URL.

This gives you a clean dataset of crypto narratives without manually refreshing the website.

### Who is it for?

Crypto traders use it to monitor breaking headlines by coin.

Market analysts use it to build topic timelines for Bitcoin, Ethereum, Solana, XRP, and other assets.

Newsletter teams use it to collect source links and summaries for daily crypto briefings.

Data engineers use it to feed alerts, BI dashboards, and LLM/RAG workflows.

Agencies use it to watch coin narratives for clients.

### Why use this actor?

- 📰 Scrapes public CryptoPanic feed pages
- 🔗 Resolves original source URLs when available
- 🪙 Extracts coin and tag links from each post
- ⏱️ Captures publication timestamps
- 📦 Exports structured JSON, CSV, Excel, XML, and API results through Apify datasets
- ⚙️ Supports custom CryptoPanic feed URLs

### What data can you extract?

| Field | Description |
| --- | --- |
| `postId` | CryptoPanic post ID |
| `title` | News headline or post text |
| `cryptoPanicUrl` | CryptoPanic detail URL |
| `sourceName` | Publisher/source label shown by CryptoPanic |
| `sourceDomain` | Publisher domain when resolved |
| `sourceUrl` | Original publisher URL from the detail page |
| `publishedAt` | ISO publication timestamp |
| `feedUrl` | Feed URL that produced the item |
| `feedLabel` | Latest, coin slug, or custom label |
| `coins` | Coin/tag links visible in the feed |
| `summary` | Detail-page summary text when available |
| `sentimentAvailable` | Whether public vote counts were visible in the scraped markup |
| `scrapedAt` | Actor scrape timestamp |

### How much does it cost to scrape CryptoPanic news?

This actor uses pay-per-event pricing.

There is a small start fee and then a per-result item charge.

The initial BRONZE target is around one tenth of a cent per saved news post, aligned with equivalent CryptoPanic actors on Apify.

Actual total cost depends on how many posts you request and whether you resolve source URLs.

### Input options

`maxItems` controls how many unique CryptoPanic posts are saved.

`includeLatestFeed` starts with the public homepage/latest feed.

`coinSlugs` lists CryptoPanic `/news/<slug>/` pages such as `bitcoin`, `ethereum`, `ripple`, `solana`, or `cardano`.

`startUrls` lets you provide exact CryptoPanic feed URLs and overrides the generated coin feeds.

`resolveSourceUrls` opens each post detail page to extract the original publisher URL and summary.

`requestDelayMs` adds a polite delay between detail-page requests.

### Example input: monitor major coins

```json
{
  "maxItems": 100,
  "includeLatestFeed": true,
  "coinSlugs": ["bitcoin", "ethereum", "ripple", "solana", "cardano"],
  "resolveSourceUrls": true,
  "requestDelayMs": 150
}
````

### Example input: fastest feed-only scrape

```json
{
  "maxItems": 100,
  "includeLatestFeed": true,
  "coinSlugs": ["bitcoin", "ethereum", "dogecoin", "chainlink"],
  "resolveSourceUrls": false
}
```

### Example input: custom CryptoPanic URL

```json
{
  "maxItems": 25,
  "startUrls": [
    { "url": "https://cryptopanic.com/news/bitcoin/" }
  ],
  "resolveSourceUrls": true
}
```

### Output example

```json
{
  "postId": "32988766",
  "title": "Samsung AI Boosts 5G Speeds in Japan Trial",
  "cryptoPanicUrl": "https://cryptopanic.com/news/32988766/Samsung-AI-Boosts-5G-Speeds-in-Japan-Trial",
  "sourceName": "Catenaa News",
  "sourceDomain": "catenaa.com",
  "sourceUrl": "https://catenaa.com/industries/telecom/samsung-ai-boosts-5g-speeds-in-japan-trial/",
  "publishedAt": "2026-07-07T05:00:00.000Z",
  "feedLabel": "latest",
  "coins": [],
  "summary": "Samsung and KDDI have demonstrated AI-driven 5G network optimization...",
  "sentimentAvailable": false,
  "scrapedAt": "2026-07-07T05:04:56.136Z"
}
```

### How to run

1. Open the actor on Apify.
2. Set `maxItems` to the number of posts you need.
3. Choose coin slugs or paste custom CryptoPanic feed URLs.
4. Keep `resolveSourceUrls` enabled if you need publisher URLs.
5. Click **Start**.
6. Download the dataset or call it through the API.

### Tips for better results

Use several coin slugs when you need more than 20 items.

Disable source URL resolution for very fast feed monitoring.

Enable source URL resolution when your workflow needs canonical publisher links.

Use custom URLs for niche CryptoPanic coin pages.

Keep `maxItems` realistic for scheduled monitoring runs.

### Integrations

Send results to Google Sheets for editorial review.

Load JSON into a trading dashboard.

Trigger alerts when a watched coin appears in `coins`.

Use Apify webhooks to notify Slack, Discord, or Telegram when a scheduled run finishes.

Feed the dataset to an LLM summarizer for daily crypto narrative reports.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/cryptopanic-news-scraper').call({
  maxItems: 100,
  coinSlugs: ['bitcoin', 'ethereum', 'solana'],
  resolveSourceUrls: true
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')
run = client.actor('automation-lab/cryptopanic-news-scraper').call(run_input={
    'maxItems': 100,
    'coinSlugs': ['bitcoin', 'ethereum', 'solana'],
    'resolveSourceUrls': True,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~cryptopanic-news-scraper/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"maxItems":100,"coinSlugs":["bitcoin","ethereum"],"resolveSourceUrls":true}'
```

### MCP usage

Use this actor from Claude Code, Claude Desktop, or any client that supports the Apify MCP server.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/cryptopanic-news-scraper
```

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=automation-lab/cryptopanic-news-scraper
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=automation-lab/cryptopanic-news-scraper"
    }
  }
}
```

Example prompts showing MCP usage:

- "Use the CryptoPanic News Scraper to collect Bitcoin and Ethereum headlines, then summarize the top themes."
- "Run automation-lab/cryptopanic-news-scraper for 100 posts with source URLs and group them by coin tag."
- "Monitor CryptoPanic Solana news and prepare a short market-intel brief with publisher links."

### Scheduling

Schedule the actor hourly for near-real-time monitoring.

Schedule it daily for newsletter source collection.

Use small runs for alerts and larger runs for research snapshots.

### Limitations

CryptoPanic's public SSR markup exposes headlines, timestamps, source labels, tags, and detail-page publisher links.

Public vote counts are not always visible without authenticated web API calls, so sentiment vote fields are nullable.

Some coin pages may have fewer than 20 public SSR items.

If a source URL is not visible on the detail page, the actor still saves the CryptoPanic URL.

### Troubleshooting

### Why did I get fewer results than maxItems?

CryptoPanic public pages expose a finite number of SSR posts per feed.

Add more coin slugs or custom feed URLs to increase coverage.

### Why are vote fields null?

The public page does not always expose community vote counts in static markup.

The actor does not invent sentiment numbers; it returns null when the data is not publicly visible.

### Legality

This actor extracts publicly visible CryptoPanic pages and should be used responsibly.

Respect CryptoPanic's terms, avoid abusive run frequency, and do not scrape personal data.

Consult your legal team if your use case has regulatory requirements.

### FAQ

### Is scraping CryptoPanic legal?

This actor extracts public web pages. You are responsible for using the data lawfully and respecting the target website's terms.

### Why are some source URLs missing?

Some CryptoPanic detail pages may not expose a full publisher link in public markup. The actor still saves the CryptoPanic URL and source label.

### Related scrapers

Explore other automation-lab actors for crypto, news, market intelligence, and website monitoring.

Related actor ideas include RSS feed scrapers, website content monitors, and social media trend scrapers.

### Changelog

Initial version: public CryptoPanic feed scraping with coin pages, source URL resolution, summaries, and structured dataset output.

### Support

If a CryptoPanic page structure changes or you need additional public fields, open an Apify issue with a sample run and expected output.

# Actor input Schema

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

Maximum unique CryptoPanic posts to save. The actor combines latest and coin feeds until this limit is reached.

## `includeLatestFeed` (type: `boolean`):

Start with the public CryptoPanic homepage/latest feed before coin-specific feeds.

## `coinSlugs` (type: `array`):

CryptoPanic /news/<slug>/ pages to scrape, for example bitcoin, ethereum, ripple, solana, cardano. Leave empty to use popular defaults.

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

Optional explicit CryptoPanic feed URLs. When provided, these override latest/coin slug generation.

## `resolveSourceUrls` (type: `boolean`):

Open each CryptoPanic detail page to extract the original publisher URL and article summary. Disable for the fastest feed-only monitoring.

## `requestDelayMs` (type: `integer`):

Politeness delay used when resolving source URLs from detail pages.

## `proxyConfiguration` (type: `object`):

Use Apify Proxy for reliable cloud access to CryptoPanic. Default datacenter proxy is usually enough; use residential only if your own tests require it.

## Actor input object example

```json
{
  "maxItems": 20,
  "includeLatestFeed": true,
  "coinSlugs": [
    "bitcoin",
    "ethereum",
    "ripple",
    "solana",
    "cardano"
  ],
  "startUrls": [],
  "resolveSourceUrls": true,
  "requestDelayMs": 150,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (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": 20,
    "includeLatestFeed": true,
    "coinSlugs": [
        "bitcoin",
        "ethereum",
        "ripple",
        "solana",
        "cardano"
    ],
    "startUrls": [],
    "resolveSourceUrls": true,
    "requestDelayMs": 150,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "maxItems": 20,
    "includeLatestFeed": True,
    "coinSlugs": [
        "bitcoin",
        "ethereum",
        "ripple",
        "solana",
        "cardano",
    ],
    "startUrls": [],
    "resolveSourceUrls": True,
    "requestDelayMs": 150,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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 '{
  "maxItems": 20,
  "includeLatestFeed": true,
  "coinSlugs": [
    "bitcoin",
    "ethereum",
    "ripple",
    "solana",
    "cardano"
  ],
  "startUrls": [],
  "resolveSourceUrls": true,
  "requestDelayMs": 150,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call automation-lab/cryptopanic-news-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CryptoPanic News Scraper",
        "description": "Scrape CryptoPanic headlines, source links, coin tags, publish times, and summaries for crypto trading alerts and market intelligence.",
        "version": "0.1",
        "x-build-id": "twzQuEvmjPZuwvBeQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~cryptopanic-news-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~cryptopanic-news-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-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/automation-lab~cryptopanic-news-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-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": {
                    "maxItems": {
                        "title": "Maximum news posts",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum unique CryptoPanic posts to save. The actor combines latest and coin feeds until this limit is reached.",
                        "default": 20
                    },
                    "includeLatestFeed": {
                        "title": "Include latest feed",
                        "type": "boolean",
                        "description": "Start with the public CryptoPanic homepage/latest feed before coin-specific feeds.",
                        "default": true
                    },
                    "coinSlugs": {
                        "title": "Coin/news slugs",
                        "type": "array",
                        "description": "CryptoPanic /news/<slug>/ pages to scrape, for example bitcoin, ethereum, ripple, solana, cardano. Leave empty to use popular defaults.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "Custom CryptoPanic feed URLs",
                        "type": "array",
                        "description": "Optional explicit CryptoPanic feed URLs. When provided, these override latest/coin slug generation.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "resolveSourceUrls": {
                        "title": "Resolve original source URLs",
                        "type": "boolean",
                        "description": "Open each CryptoPanic detail page to extract the original publisher URL and article summary. Disable for the fastest feed-only monitoring.",
                        "default": true
                    },
                    "requestDelayMs": {
                        "title": "Delay between detail requests (ms)",
                        "minimum": 0,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Politeness delay used when resolving source URLs from detail pages.",
                        "default": 150
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Use Apify Proxy for reliable cloud access to CryptoPanic. Default datacenter proxy is usually enough; use residential only if your own tests require it.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
