# Google News Scraper + Article Extractor (`phantom_coder/google-news-scraper`) Actor

Search Google News by keyword or browse 8 built-in topics - World, Business, Technology, Sports, Science, Health and more. Add-on: extract full article text for NLP and sentiment. Near-zero start fee ($0.00005/run). Site filter, date range, 50+ languages. From $0.004/result.

- **URL**: https://apify.com/phantom\_coder/google-news-scraper.md
- **Developed by:** [Phantom Coder](https://apify.com/phantom_coder) (community)
- **Categories:** News, Automation, Agents
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.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

## Google News Scraper + Article Extractor

Extract structured news data from Google News by keyword search or topic feed - headlines, publishers, timestamps, article links, and optionally the full article body text, ready for export to JSON, CSV, or any downstream pipeline.

### What you get

- **Title** - article headline, cleaned (no publisher suffix)
- **URL** - Google News article link that redirects to the full article
- **Source** - publisher name (e.g., Reuters, BBC, TechCrunch)
- **Source URL** - publisher homepage (e.g., reuters.com)
- **Published at** - ISO 8601 timestamp
- **Snippet** - article summary shown on Google News
- **Query** - the keyword or topic that surfaced this article
- **Article URL** *(with extractFullText add-on)* - direct publisher URL, resolved from the Google News redirect
- **Text** *(with extractFullText add-on)* - full article body text extracted from the publisher page

Results are deduplicated automatically across multiple queries and topics in a single run.

### How to use

<ol>
<li>Go to the <strong>Input</strong> tab and enter one or more search queries, select topics, or both.</li>
<li>Set optional filters: date range, site restriction, exclude words, language, and country.</li>
<li>To get the full article text (for NLP, sentiment analysis, or content pipelines), enable <strong>Extract full article text</strong> in the Add-on section.</li>
<li>Click <strong>Start</strong>. A typical run of 100 articles finishes in under 10 seconds (or ~15 minutes with full text extraction enabled).</li>
<li>Download results from the <strong>Output</strong> tab as JSON, CSV, or XLSX - or connect directly via the Apify API.</li>
</ol>

> **Note:** Google News RSS returns up to 100 articles per query. To get broader coverage, run multiple focused queries (e.g., `"Tesla earnings"` and `"Tesla stock"`) rather than one broad query.

### Input configuration

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `queries` | string[] | — | Search keywords. Each query runs separately and results are deduplicated. |
| `topics` | enum[] | — | Browse predefined Google News topic feeds. Can be combined with keyword queries. |
| `maxResultsPerQuery` | integer | 100 | Max articles per query or topic (1–100). |
| `extractFullText` | boolean | `false` | Fetch and extract full article body text from each publisher page. Adds `articleUrl` and `text` fields. Memory is set automatically. Charged separately per successful extraction. |
| `dateRange` | enum | `anytime` | Filter by recency. Applies to keyword searches only. |
| `siteFilter` | string | — | Restrict results to one domain, e.g. `reuters.com`. |
| `excludeWords` | string[] | — | Words to exclude from search results, e.g. `["opinion", "sponsored"]`. |
| `language` | string | `en` | ISO 639-1 language code (e.g. `en`, `de`, `fr`, `ja`). |
| `country` | string | `US` | ISO 3166-1 country code (e.g. `US`, `GB`, `DE`, `JP`). |

Example input - keyword search with filters:

```json
{
    "queries": ["artificial intelligence regulation", "OpenAI GPT"],
    "maxResultsPerQuery": 50,
    "dateRange": "past_week",
    "excludeWords": ["opinion", "sponsored"],
    "language": "en",
    "country": "US"
}
````

Example input - topic browsing:

```json
{
    "topics": ["TECHNOLOGY", "BUSINESS", "SCIENCE"],
    "maxResultsPerQuery": 100,
    "language": "en",
    "country": "US"
}
```

Example input - full article text extraction:

```json
{
    "queries": ["climate change policy"],
    "maxResultsPerQuery": 50,
    "extractFullText": true
}
```

### Available topics

| Value | Google News feed |
|-------|-----------------|
| `WORLD` | Top world headlines |
| `NATION` | US national news |
| `BUSINESS` | Business and finance |
| `TECHNOLOGY` | Tech and science |
| `ENTERTAINMENT` | Entertainment and culture |
| `SPORTS` | Sports news |
| `SCIENCE` | Science and environment |
| `HEALTH` | Health and medicine |

> **Note:** `siteFilter`, `excludeWords`, and `dateRange` apply to keyword queries only. Topic feeds are curated by Google and have no query string to modify, so those filters have no effect when using topics.

### Output format

Each article is a flat JSON record:

```json
{
    "title": "OpenAI releases GPT-5 with improved reasoning",
    "url": "https://news.google.com/rss/articles/CBMi...",
    "source": "The Verge",
    "sourceUrl": "https://www.theverge.com",
    "publishedAt": "2026-06-09T14:30:00.000Z",
    "snippet": "OpenAI releases GPT-5 with improved reasoning The Verge",
    "query": "OpenAI GPT"
}
```

For topic results, the `query` field is prefixed with `topic:`:

```json
{
    "query": "topic:BUSINESS",
    ...
}
```

### Full article text extraction

When `extractFullText: true` is set, the Actor launches a browser for each article, resolves the Google News redirect to the real publisher URL, fetches the article page, and extracts the main body text. Two additional fields are added to each result where extraction succeeds:

```json
{
    "title": "OpenAI releases GPT-5 with improved reasoning",
    "url": "https://news.google.com/rss/articles/CBMi...",
    "source": "The Verge",
    "sourceUrl": "https://www.theverge.com",
    "publishedAt": "2026-06-09T14:30:00.000Z",
    "snippet": "OpenAI releases GPT-5 with improved reasoning The Verge",
    "query": "OpenAI GPT",
    "articleUrl": "https://www.theverge.com/2026/6/9/openai-gpt5",
    "text": "OpenAI has released GPT-5, its most capable language model to date..."
}
```

**What to expect:**

- **~60% success rate** across mixed publishers. Open-access sites (BBC, Reuters, TechCrunch) extract reliably. Paywalled content (WSJ, FT, NYT) is attempted but returns no text.
- **Only successful extractions are charged** - paywalled and inaccessible articles are not charged.
- **Memory is set automatically** to 1,024 MB when this option is enabled.
- **Performance:** ~8 seconds per article. A run of 50 articles with extraction takes roughly 7 minutes total.

> **Note:** If extraction fails for a specific article (paywall, geo-block, or timeout), that article is still returned in the dataset - it just won't have `articleUrl` or `text` fields, and won't be charged for the add-on.

### Use cases and scheduling

**Brand monitoring** - run every hour to catch news as it breaks:

```
0 * * * *
```

Input: `{ "queries": ["your brand name", "your competitor"], "dateRange": "past_hour" }`

**Daily industry digest** - aggregate tech and business headlines every morning:

```
0 8 * * *
```

Input: `{ "topics": ["TECHNOLOGY", "BUSINESS"], "maxResultsPerQuery": 100 }`

**NLP and sentiment analysis pipeline** - extract full article text for downstream processing:

```json
{
    "queries": ["electric vehicles", "EV market"],
    "maxResultsPerQuery": 50,
    "dateRange": "past_week",
    "extractFullText": true
}
```

Feed the `text` field into your sentiment model, summarizer, or LLM — no need to follow and scrape each article separately.

**Weekly research report** - broad keyword sweep once a week:

```
0 9 * * 1
```

Input: `{ "queries": ["your topic"], "dateRange": "past_week", "maxResultsPerQuery": 100 }`

**Site-specific monitoring** - track what one publication says about a topic:

```json
{
    "queries": ["climate change"],
    "siteFilter": "nytimes.com",
    "dateRange": "past_day"
}
```

Connect results to a Google Sheet or Slack channel via Apify integrations for zero-code delivery.

### Pricing

This Actor uses pay-per-event pricing — you only pay for what you scrape.

#### Base results

| Tier | Price per article | Per 1,000 articles |
|------|------------------|--------------------|
| Free | $0.004 | $4.00 |
| Starter | $0.003 | $3.00 |
| Scale | $0.002 | $2.00 |
| Business | $0.001 | $1.00 |

#### Full text extraction add-on (`extractFullText: true`)

Charged in addition to the base result price, only when text is successfully extracted. Paywalled and inaccessible articles are not charged.

| Tier | Price per extracted article | Per 1,000 extractions |
|------|----------------------------|-----------------------|
| Free | $0.010 | $10.00 |
| Starter | $0.008 | $8.00 |
| Scale | $0.006 | $6.00 |
| Business | $0.004 | $4.00 |

**Example:** 100 articles with extraction on the Free tier = (100 × $0.004) + (100 × $0.010) = $1.40 total.

The per-run start fee is $0.00005 - effectively negligible. Most competitors in this category charge $0.05–$0.09 just to start a run, which adds up fast if you run the Actor frequently for monitoring. At 100 runs per month, that is $5–$9 in start fees alone before counting results.

**Cost example (no extraction):** 500 articles/day × 30 days = 15,000 articles/month. At the Free tier: $60. At the Business tier: $15.

### Limitations

1. Google News RSS caps at 100 articles per query - this is a Google-imposed limit, not a scraper limitation. Use multiple focused queries to get broader coverage.
2. The `url` field is a Google News redirect link. It opens the full article in a browser but requires JavaScript to resolve to the final publisher URL programmatically. Enable `extractFullText` to get the resolved `articleUrl`.
3. The date range filter applies to keyword searches only - topic feeds always return the latest articles regardless of this setting.
4. Article `snippet` is the summary shown on Google News, which is often just the title and publisher name for individual articles.
5. Proxy rotation is used for reliable RSS access - this is handled automatically, no setup needed.

### Privacy and ethical use

This Actor scrapes Google News RSS feeds, a publicly available data source designed for programmatic access. It does not access publisher paywalls, user accounts, or private content. Use in accordance with Google's Terms of Service and applicable data protection regulations.

# Actor input Schema

## `queries` (type: `array`):

One or more keywords to search on Google News. Each query runs separately. Results are deduplicated across all queries.

## `topics` (type: `array`):

Browse Google News predefined topic feeds instead of or in addition to keyword searches.

## `maxResultsPerQuery` (type: `integer`):

Maximum number of articles to return per search query or topic. Google News RSS returns up to 100 articles.

## `extractFullText` (type: `boolean`):

Fetch and extract the full article body text from each publisher page. Adds <code>articleUrl</code> and <code>text</code> fields to results. Memory is set automatically to 1024 MB when enabled. Charged per successful extraction — paywalled articles are not charged.

## `dateRange` (type: `string`):

Filter articles by how recently they were published. Applies to keyword searches only, not topic feeds.

## `siteFilter` (type: `string`):

Only return articles from this domain (e.g. reuters.com, bbc.com). Applies to keyword searches only.

## `excludeWords` (type: `array`):

Words or phrases to exclude from keyword search results (e.g. sponsored, opinion).

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

ISO 639-1 language code for the Google News interface and results (e.g. en, de, fr, es, ja).

## `country` (type: `string`):

ISO 3166-1 alpha-2 country code for Google News edition (e.g. US, GB, DE, JP).

## Actor input object example

```json
{
  "queries": [
    "artificial intelligence"
  ],
  "topics": [],
  "maxResultsPerQuery": 100,
  "extractFullText": false,
  "dateRange": "anytime",
  "language": "en",
  "country": "US"
}
```

# Actor output Schema

## `dataset` (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 = {
    "queries": [
        "artificial intelligence"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("phantom_coder/google-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 = { "queries": ["artificial intelligence"] }

# Run the Actor and wait for it to finish
run = client.actor("phantom_coder/google-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 '{
  "queries": [
    "artificial intelligence"
  ]
}' |
apify call phantom_coder/google-news-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google News Scraper + Article Extractor",
        "description": "Search Google News by keyword or browse 8 built-in topics - World, Business, Technology, Sports, Science, Health and more. Add-on: extract full article text for NLP and sentiment. Near-zero start fee ($0.00005/run). Site filter, date range, 50+ languages. From $0.004/result.",
        "version": "0.1",
        "x-build-id": "MaASPyfmZlIxzUtId"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/phantom_coder~google-news-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-phantom_coder-google-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/phantom_coder~google-news-scraper/runs": {
            "post": {
                "operationId": "runs-sync-phantom_coder-google-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/phantom_coder~google-news-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-phantom_coder-google-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": {
                    "queries": {
                        "title": "🔍 Search queries",
                        "type": "array",
                        "description": "One or more keywords to search on Google News. Each query runs separately. Results are deduplicated across all queries.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "topics": {
                        "title": "📰 Topics",
                        "type": "array",
                        "description": "Browse Google News predefined topic feeds instead of or in addition to keyword searches.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "WORLD",
                                "NATION",
                                "BUSINESS",
                                "TECHNOLOGY",
                                "ENTERTAINMENT",
                                "SPORTS",
                                "SCIENCE",
                                "HEALTH"
                            ]
                        },
                        "default": []
                    },
                    "maxResultsPerQuery": {
                        "title": "📄 Max results per query / topic",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of articles to return per search query or topic. Google News RSS returns up to 100 articles.",
                        "default": 100
                    },
                    "extractFullText": {
                        "title": "📰 Extract full article text ($)",
                        "type": "boolean",
                        "description": "Fetch and extract the full article body text from each publisher page. Adds <code>articleUrl</code> and <code>text</code> fields to results. Memory is set automatically to 1024 MB when enabled. Charged per successful extraction — paywalled articles are not charged.",
                        "default": false
                    },
                    "dateRange": {
                        "title": "📅 Date range",
                        "enum": [
                            "anytime",
                            "past_hour",
                            "past_day",
                            "past_week",
                            "past_month",
                            "past_year"
                        ],
                        "type": "string",
                        "description": "Filter articles by how recently they were published. Applies to keyword searches only, not topic feeds.",
                        "default": "anytime"
                    },
                    "siteFilter": {
                        "title": "🌐 Restrict to site",
                        "type": "string",
                        "description": "Only return articles from this domain (e.g. reuters.com, bbc.com). Applies to keyword searches only."
                    },
                    "excludeWords": {
                        "title": "🚫 Exclude words",
                        "type": "array",
                        "description": "Words or phrases to exclude from keyword search results (e.g. sponsored, opinion).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "🌍 Language",
                        "type": "string",
                        "description": "ISO 639-1 language code for the Google News interface and results (e.g. en, de, fr, es, ja).",
                        "default": "en"
                    },
                    "country": {
                        "title": "🗺️ Country",
                        "type": "string",
                        "description": "ISO 3166-1 alpha-2 country code for Google News edition (e.g. US, GB, DE, JP).",
                        "default": "US"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
