# Cointelegraph Scraper (`solidcode/cointelegraph-scraper`) Actor

\[💰 $4.0 / 1K] Collect cryptocurrency news from Cointelegraph — title, summary, full article text, author, tags, category, publish date, cover image, and view counts. Search by keyword, browse a topic tag (bitcoin, ethereum, regulation), or grab the latest headlines, across 15 language editions.

- **URL**: https://apify.com/solidcode/cointelegraph-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 $4.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

## Cointelegraph Scraper

Pull cryptocurrency news from Cointelegraph at scale — headlines, summaries, full article bodies, authors, topic tags, categories, publish timestamps, cover images, and view counts, across 15 native-language editions. Built for crypto analysts, quant and sentiment traders, and content teams who need a clean, structured news feed without copying articles out of the browser one at a time.

### Why This Scraper?

- **15 native-language editions** — English, German, Spanish, French, Italian, Japanese, Brazilian Portuguese, Arabic, Russian, Turkish, Korean, Chinese (Simplified & Traditional), Vietnamese, and Hindi — each returning native headlines, summaries, and bodies with the correct per-edition article URLs.
- **Three discovery modes in one actor** — grab the latest headlines feed, run a keyword search across the full archive, or browse every article under a topic tag (bitcoin, ethereum, regulation, defi, nft). Flip one dropdown to switch.
- **Full article body as clean plain text** — not a truncated preview. Every paragraph, heading, and list item is extracted and ready for sentiment models, summarization, or republishing.
- **View counts on every article** — a built-in engagement signal for ranking trending stories and weighting sentiment, included at no extra request.
- **Author name and profile URL on every row** — track specific journalists or build a contributor map across the publication.
- **Topic tags plus category on every article** — Markets, Bitcoin, Regulation, DeFi and the granular tag slugs, so you can filter and cluster news without re-reading the body.
- **Dual publish timestamps** — a machine-sortable ISO 8601 timestamp and a human-readable date on the same row, so dashboards and humans both get what they need.
- **Up to 100,000 articles per run** — set a cap or use 0 to sweep an entire feed until it's exhausted, for both real-time monitoring and deep historical archive pulls.

### Use Cases

**Market Research & Trend Analysis**
- Track which coins and narratives dominate the news cycle by tag volume
- Surface trending stories by view count to spot emerging market themes
- Compare coverage of a token across regulation, DeFi, and markets categories
- Build a historical archive of crypto news for back-testing market reactions

**Trading Signals & Sentiment**
- Feed full article bodies into sentiment models for directional signals
- Monitor the latest headlines feed in near real time for breaking news
- Weight sentiment by article view count to prioritize high-impact stories
- Flag regulation and enforcement news that moves specific assets

**Content & Media Monitoring**
- Watch a topic tag (e.g. `bitcoin`, `ethereum`) for every new article
- Track a specific author or contributor across all their published pieces
- Repurpose summaries and tags into newsletters and curated digests
- Benchmark your own coverage against Cointelegraph's by category

**Multilingual & Regional Research**
- Compare how the same story is framed across 15 language editions
- Pull the Japanese, Korean, Arabic, or Vietnamese editions for regional desks
- Localize a crypto newsletter with native-language summaries and headlines
- Study regional regulatory coverage in its original language

**Academic & Industry Intelligence**
- Assemble a labeled news dataset for crypto NLP and event studies
- Quantify media attention on a protocol over time using publish dates
- Map the tag co-occurrence graph to study how narratives connect
- Cite and link original articles with stable canonical URLs

### Getting Started

#### Latest Headlines

The simplest run — newest crypto news first, no search term needed:

```json
{
    "searchMode": "latest",
    "maxResults": 50
}
````

#### Keyword Search

Find every article matching your search words across the archive:

```json
{
    "searchMode": "search",
    "query": "bitcoin ETF",
    "language": "en",
    "maxResults": 200
}
```

#### Browse a Topic Tag (Headlines Only, Fast Sweep)

Pull every article filed under a tag, skipping full bodies for a fast, lightweight run:

```json
{
    "searchMode": "tag",
    "query": "ethereum",
    "includeFullText": false,
    "maxResults": 500
}
```

#### Full-Featured Example (Non-English Edition, Full Text)

A keyword search on the Spanish edition with complete article bodies:

```json
{
    "searchMode": "search",
    "query": "regulación cripto",
    "language": "es",
    "includeFullText": true,
    "maxResults": 1000
}
```

### Input Reference

#### What to Collect

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchMode` | select | `latest` | How to find articles: `latest` (newest headlines first), `search` (keyword search across the archive), or `tag` (every article under a topic tag). |
| `query` | string | `""` | Your search words for `search` mode, or the topic tag slug (e.g. `bitcoin`, `ethereum`, `regulation`, `defi`) for `tag` mode. Leave empty for `latest`. |

#### Language

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `language` | select | `en` | The Cointelegraph edition to collect from. 15 options: English, Spanish, Portuguese (Brazil), French, Italian, German, Turkish, Arabic, Russian, Japanese, Korean, Chinese (Simplified), Chinese (Traditional), Vietnamese, and Hindi. Results are in the chosen language. |

#### Output Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeFullText` | boolean | `true` | Collect the complete article body, not just the title and summary. Turn off for a faster, lighter run when you only need headlines, summaries, and metadata. |
| `maxResults` | integer | `100` | The most articles to collect in one run. Set to `0` for as many as the feed returns (up to 100,000). |

### Output

Each article is one flat row. Here's a representative result with full text enabled:

```json
{
    "id": "2065432",
    "url": "https://cointelegraph.com/news/bitcoin-etf-inflows-record-week",
    "title": "Bitcoin ETF inflows hit record week as institutions pile in",
    "leadText": "Spot Bitcoin ETFs notched their strongest week of inflows yet, signaling renewed institutional appetite.",
    "fullText": "Spot Bitcoin exchange-traded funds recorded their largest weekly inflows since launch...\n\nAnalysts attribute the surge to easing macro conditions...",
    "author": "Jane Crypto",
    "authorUrl": "https://cointelegraph.com/authors/jane-crypto",
    "category": "Markets",
    "tags": ["Bitcoin", "ETF", "Institutional Investors"],
    "publishedAt": "2026-06-12T12:03:23.914Z",
    "publishedHuman": "Jun 12, 2026",
    "coverImage": "https://images.cointelegraph.com/cdn-cgi/image/example.jpg",
    "views": 18452,
    "language": "en"
}
```

#### Core Article

| Field | Type | Description |
|-------|------|-------------|
| `id` | string | Unique Cointelegraph article identifier |
| `url` | string | Canonical article URL on the chosen edition's domain |
| `title` | string | Article headline |
| `language` | string | Edition the article came from (e.g. `en`, `es`, `jp`) |

#### Content

| Field | Type | Description |
|-------|------|-------------|
| `leadText` | string | Article summary / lead paragraph |
| `fullText` | string | null | Complete article body as clean plain text. `null` when `includeFullText` is off |
| `coverImage` | string | null | Cover image URL |

#### Authorship & Taxonomy

| Field | Type | Description |
|-------|------|-------------|
| `author` | string | null | Author display name |
| `authorUrl` | string | null | Author profile URL on the same edition |
| `category` | string | null | Section / category (Markets, Bitcoin, Regulation, etc.) |
| `tags` | string\[] | Topic tags applied to the article |

#### Dates & Engagement

| Field | Type | Description |
|-------|------|-------------|
| `publishedAt` | string | Publish date/time as an ISO 8601 timestamp |
| `publishedHuman` | string | null | Human-readable publish date (e.g. "Jun 12, 2026") |
| `views` | number | null | Article view count |

### Tips for Best Results

- **Use `latest` for monitoring, `tag` for coverage, `search` for topics.** Latest gives you the freshest feed, a tag pulls the full history under a theme, and search finds articles matching free-text words anywhere in the archive.
- **Sweep headlines first, then enrich the ones you care about.** Run with `includeFullText: false` to grab a fast, cheap list of titles, tags, and view counts, then re-run with full text on for just the stories worth reading in depth.
- **Match the tag slug to the URL form.** In `tag` mode, `query` is the slug exactly as it appears in a Cointelegraph tag URL — lowercase, hyphenated (e.g. `defi`, `nft`, `regulation`).
- **Pick the right edition up front.** Each language is a separate edition with its own articles and URLs — set `language` to the market you're studying rather than translating English output later.
- **Sort by `publishedAt`, rank by `views`.** The ISO timestamp gives you a clean time series for event studies, while the view count is your built-in popularity signal for surfacing what's trending.
- **Start small to validate, then scale.** Try `maxResults: 25` to confirm the mode and language return what you expect, then raise the cap — set `0` for an exhaustive pull.

### Pricing

**From $4.00 per 1,000 results** — undercuts the going rate for crypto news extraction while bundling full article bodies and view counts at no extra charge. 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.48 | $0.45 | $0.43 | $0.40 |
| 1,000 | $4.80 | $4.50 | $4.25 | $4.00 |
| 10,000 | $48.00 | $45.00 | $42.50 | $40.00 |
| 100,000 | $480.00 | $450.00 | $425.00 | $400.00 |

A "result" is any article row in the output dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### 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 APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate news monitoring, market research, sentiment analysis, and academic study. Users are responsible for complying with applicable laws and Cointelegraph's terms of service, including respecting content usage and copyright rules for any articles collected. Do not republish full article text without permission, and do not use collected data for spam, harassment, or any illegal purpose.

# Actor input Schema

## `searchMode` (type: `string`):

How to choose which articles to collect. 'Latest articles' grabs the newest news first. 'Keyword search' finds articles matching your search words. 'Browse a tag' pulls every article filed under a topic tag (e.g. bitcoin, ethereum, regulation).

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

What to look for. For 'Keyword search', type any words (e.g. "bitcoin ETF"). For 'Browse a tag', type the topic tag slug — lowercase and hyphenated (e.g. "bitcoin", "ethereum", "regulation", "defi"). Leave empty when collecting the latest articles.

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

Language edition of Cointelegraph to collect articles from. Defaults to English.

## `includeFullText` (type: `boolean`):

Collect the complete body text of each article, not just the title and summary. Turn this off for a faster, lighter run when you only need headlines, summaries, and metadata. Note: a small number of articles (for example, certain interviews) don't expose their full body text, so their full text will come back empty even with this turned on.

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

The most articles to collect in one run. Set to 0 to collect every article until the feed is exhausted — very large pulls take longer, especially with full article text turned on.

## Actor input object example

```json
{
  "searchMode": "latest",
  "language": "en",
  "includeFullText": true,
  "maxResults": 100
}
```

# Actor output Schema

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

Table of news articles with title, author, category, tags, publish date, views, and summary.

# 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 = {
    "searchMode": "latest",
    "query": "",
    "language": "en",
    "includeFullText": true,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/cointelegraph-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 = {
    "searchMode": "latest",
    "query": "",
    "language": "en",
    "includeFullText": True,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/cointelegraph-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 '{
  "searchMode": "latest",
  "query": "",
  "language": "en",
  "includeFullText": true,
  "maxResults": 100
}' |
apify call solidcode/cointelegraph-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Cointelegraph Scraper",
        "description": "[💰 $4.0 / 1K] Collect cryptocurrency news from Cointelegraph — title, summary, full article text, author, tags, category, publish date, cover image, and view counts. Search by keyword, browse a topic tag (bitcoin, ethereum, regulation), or grab the latest headlines, across 15 language editions.",
        "version": "1.0",
        "x-build-id": "XjLp3sIoBVVDzvd56"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~cointelegraph-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-cointelegraph-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~cointelegraph-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-cointelegraph-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~cointelegraph-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-cointelegraph-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": {
                    "searchMode": {
                        "title": "What to collect",
                        "enum": [
                            "latest",
                            "search",
                            "tag"
                        ],
                        "type": "string",
                        "description": "How to choose which articles to collect. 'Latest articles' grabs the newest news first. 'Keyword search' finds articles matching your search words. 'Browse a tag' pulls every article filed under a topic tag (e.g. bitcoin, ethereum, regulation).",
                        "default": "latest"
                    },
                    "query": {
                        "title": "Search term or tag",
                        "type": "string",
                        "description": "What to look for. For 'Keyword search', type any words (e.g. \"bitcoin ETF\"). For 'Browse a tag', type the topic tag slug — lowercase and hyphenated (e.g. \"bitcoin\", \"ethereum\", \"regulation\", \"defi\"). Leave empty when collecting the latest articles."
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "es",
                            "br",
                            "fr",
                            "it",
                            "de",
                            "tr",
                            "ar",
                            "ru",
                            "jp",
                            "kr",
                            "cn",
                            "tw",
                            "vn",
                            "in"
                        ],
                        "type": "string",
                        "description": "Language edition of Cointelegraph to collect articles from. Defaults to English.",
                        "default": "en"
                    },
                    "includeFullText": {
                        "title": "Include full article text",
                        "type": "boolean",
                        "description": "Collect the complete body text of each article, not just the title and summary. Turn this off for a faster, lighter run when you only need headlines, summaries, and metadata. Note: a small number of articles (for example, certain interviews) don't expose their full body text, so their full text will come back empty even with this turned on.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Maximum articles",
                        "minimum": 0,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "The most articles to collect in one run. Set to 0 to collect every article until the feed is exhausted — very large pulls take longer, especially with full article text turned on.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
