# Google News Scraper (`fetch_cat/google-news-scraper`) Actor

Track Google News mentions by keyword, country, language, and recency. Export article titles, publishers, dates, snippets, and URLs.

- **URL**: https://apify.com/fetch\_cat/google-news-scraper.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** News
- **Stats:** 2 total users, 1 monthly users, 0.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

## Google News Scraper

Track news mentions, headlines, publishers, dates, and article links from Google News by keyword, country, language, and recency.

### What does Google News Scraper do?

Google News Scraper helps you monitor news coverage for brands, competitors, markets, people, products, and topics.

It turns keyword searches into a clean Apify dataset with article titles, publisher names, publication times, descriptions, Google News links, and source URLs when available.

Use it when you need repeatable news monitoring without manually checking Google News every day.

### Who is it for?

- 🗞️ PR teams tracking brand mentions and campaign pickup.
- 📈 Market intelligence teams monitoring competitors and industries.
- 🔎 SEO teams watching content trends and news demand.
- 🧑‍💼 Founders tracking investor, competitor, and category news.
- 🧪 Researchers collecting time-bounded news samples.
- 🤖 Automation builders feeding news data into dashboards and alerts.

### Why use this actor?

- ✅ Search multiple keywords in one run.
- ✅ Select country and language editions.
- ✅ Limit results per query for predictable cost.
- ✅ Add recency filters such as `when:7d` or date windows.
- ✅ Remove duplicate articles across overlapping searches.
- ✅ Export results as JSON, CSV, Excel, XML, or HTML.
- ✅ Connect results to Zapier, Make, webhooks, or your own API pipeline.

### Common use cases

- Brand monitoring for company, product, and executive names.
- Competitor monitoring by company and category keywords.
- Industry trend tracking for recurring newsletters.
- Media intelligence dashboards for PR reporting.
- Lead discovery for journalists and publishers covering your niche.
- SEO topic research around news-heavy keywords.
- Crisis monitoring for sudden changes in coverage.

### What data can you extract?

| Field | Description |
| --- | --- |
| `query` | Original query supplied in the input. |
| `title` | Article headline shown in Google News. |
| `googleNewsUrl` | Google News article URL. |
| `sourceUrl` | Publisher/source URL when available. |
| `sourceName` | Publisher name. |
| `publishedAt` | Publication timestamp in ISO format when available. |
| `descriptionHtml` | Original formatted description snippet. |
| `descriptionText` | Plain-text description snippet. |
| `guid` | Stable Google News item identifier when available. |
| `language` | Language setting used for the run. |
| `country` | Country/edition setting used for the run. |
| `position` | Position within the query result set. |
| `scrapedAt` | Timestamp when the result was collected. |

### How much does it cost to scrape Google News?

The actor uses pay-per-event pricing.

- A small start event is charged once per run.
- A result event is charged for each saved article.
- The default first run is intentionally small so you can test cheaply.

For example, a run with two queries and 20 articles per query saves up to 40 article rows.

### Input overview

| Input | Type | Default | Notes |
| --- | --- | --- | --- |
| `queries` | array | required | Keywords or search expressions. |
| `maxItemsPerQuery` | integer | `20` | Maximum articles saved for each query. |
| `dateRange` | string | `when:7d` | Optional recency or date filter. |
| `country` | string | `US` | Google News country edition. |
| `language` | string | `en-US` | Google News language setting. |
| `ceid` | string | derived | Optional advanced edition override. |
| `dedupe` | boolean | `true` | Removes duplicate articles across queries. |

### Query examples

Use simple keywords:

```json
{
  "queries": ["apify", "openai"],
  "maxItemsPerQuery": 20,
  "dateRange": "when:7d"
}
````

Use quoted phrases:

```json
{
  "queries": ["\"artificial intelligence startup\""],
  "maxItemsPerQuery": 20
}
```

Use date windows:

```json
{
  "queries": ["electric vehicles"],
  "dateRange": "after:2026-01-01 before:2026-02-01",
  "country": "US",
  "language": "en-US"
}
```

Use multiple markets:

```json
{
  "queries": ["fintech funding"],
  "country": "GB",
  "language": "en-GB",
  "maxItemsPerQuery": 20
}
```

### How to run it

1. Open the actor on Apify.
2. Enter one or more queries.
3. Choose country, language, and optional date range.
4. Set the maximum articles per query.
5. Start the run.
6. Download the dataset or connect it to an integration.

### Output example

```json
{
  "query": "apify",
  "title": "Example headline - Example Publisher",
  "googleNewsUrl": "https://news.google.com/...",
  "sourceUrl": "https://www.example.com",
  "sourceName": "Example Publisher",
  "publishedAt": "2026-02-01T08:00:00.000Z",
  "descriptionHtml": "<a href=\"...\">Example headline</a>",
  "descriptionText": "Example headline",
  "guid": "example-guid",
  "language": "en-US",
  "country": "US",
  "position": 1,
  "scrapedAt": "2026-06-16T20:00:00.000Z"
}
```

### Tips for better results

- Use exact brand names in quotes when names are ambiguous.
- Add product, executive, or category terms for better precision.
- Use `when:1d`, `when:7d`, or `when:30d` for monitoring workflows.
- Use `after:` and `before:` for historical research windows.
- Keep `maxItemsPerQuery` moderate for scheduled runs.
- Use separate runs for very different countries or languages.

### Country and language examples

| Market | country | language |
| --- | --- | --- |
| United States | `US` | `en-US` |
| United Kingdom | `GB` | `en-GB` |
| Canada | `CA` | `en-CA` |
| Germany | `DE` | `de-DE` |
| France | `FR` | `fr-FR` |
| Spain | `ES` | `es-ES` |
| India | `IN` | `en-IN` |
| Australia | `AU` | `en-AU` |

### Scheduling and monitoring

You can schedule this actor to run hourly, daily, weekly, or monthly.

Common schedules:

- Daily brand mention report.
- Weekly competitor coverage summary.
- Monthly market trend export.
- Hourly crisis monitoring for sensitive topics.

### Integrations

Send Google News results to:

- Google Sheets for analyst review.
- Slack for daily mention alerts.
- Airtable for PR databases.
- Notion for research libraries.
- Webhooks for custom pipelines.
- BigQuery, Snowflake, or S3 for analytics.

### 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('fetch_cat/google-news-scraper').call({
  queries: ['apify', 'web scraping'],
  dateRange: 'when:7d',
  maxItemsPerQuery: 20,
  country: 'US',
  language: 'en-US',
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])

run = client.actor('fetch_cat/google-news-scraper').call(run_input={
    'queries': ['apify', 'web scraping'],
    'dateRange': 'when:7d',
    'maxItemsPerQuery': 20,
    'country': 'US',
    'language': 'en-US',
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### API usage with cURL

```bash
curl -X POST \
  'https://api.apify.com/v2/acts/fetch_cat~google-news-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{
    "queries": ["apify", "web scraping"],
    "dateRange": "when:7d",
    "maxItemsPerQuery": 20,
    "country": "US",
    "language": "en-US"
  }'
```

### MCP usage

Use this actor from MCP-compatible tools through Apify MCP Server.

MCP URL:

```text
https://mcp.apify.com/?tools=fetch_cat/google-news-scraper
```

Claude Code CLI setup:

```bash
claude mcp add apify-google-news https://mcp.apify.com/?tools=fetch_cat/google-news-scraper
```

MCP JSON configuration:

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

Example prompts:

- "Run Google News Scraper for my company name and summarize the newest articles."
- "Find the last 7 days of news about AI regulation in the US."
- "Track competitor mentions and create a table with publisher, date, and headline."

### Claude Desktop setup

Add Apify MCP Server to Claude Desktop and include the actor-specific tools URL.

Example MCP JSON configuration:

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

Then ask Claude to run the actor with a query list, inspect the dataset, and summarize the results.

### Claude Code setup

Use the actor-specific MCP URL in your Claude Code MCP configuration.

```bash
claude mcp add apify-google-news https://mcp.apify.com/?tools=fetch_cat/google-news-scraper
```

This lets you trigger news monitoring directly while working on research, marketing, or reporting scripts.

### Data quality notes

Google News results can change quickly.

The same query may return different articles at different times.

Publication timestamps and source names are provided as available from Google News.

Some publishers may provide limited snippets.

### Limits

- Maximum `maxItemsPerQuery` is 100.
- Very narrow queries may return fewer results than requested.
- Country and language combinations should be valid Google News editions.
- The actor is designed for monitoring and research, not high-frequency bulk crawling.

### FAQ

#### Can I run this actor on a schedule?

Yes. Use Apify schedules for daily monitoring, weekly competitor summaries, or hourly alerts during time-sensitive news cycles.

#### Can I search more than one keyword at once?

Yes. Add multiple values to `queries`; the actor saves the original query on every output row.

### Troubleshooting

#### Why did I get fewer articles than requested?

The query may have fewer matching news results in the selected locale or date range. Try broadening the query or increasing the date window.

#### Why are some source URLs missing?

Some items may not expose a publisher URL. The actor still saves the Google News URL and publisher name when available.

#### Why do results change between runs?

Google News ranking and availability are dynamic. Use scheduled runs and dataset snapshots when you need historical comparisons.

### Legality and responsible use

This actor collects publicly visible Google News result metadata. Make sure your use case complies with applicable laws, platform terms, and privacy requirements.

Do not use the data for spam, harassment, or unlawful profiling.

### Related scrapers

You may also find these Apify actors useful:

- https://apify.com/fetch\_cat/reddit-scraper
- https://apify.com/fetch\_cat/craigslist-classifieds-scraper
- https://apify.com/fetch\_cat/apple-app-store-reviews-scraper
- https://apify.com/fetch\_cat/y-combinator-companies-scraper

### Support

If a run does not produce the result you expected, check the input query, date range, country, and language first.

For repeatable issues, share the run ID and a short description of the expected results.

### Changelog

Initial version:

- Keyword-based Google News monitoring.
- Country and language settings.
- Recency and date-range query support.
- Duplicate removal across queries.
- Clean article dataset output.

# Actor input Schema

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

Keywords or Google News query expressions to monitor. You can use operators such as quoted phrases, OR, when:7d, after:YYYY-MM-DD, and before:YYYY-MM-DD.

## `maxItemsPerQuery` (type: `integer`):

Maximum number of Google News results to save for each query.

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

Optional Google News date filter appended to queries that do not already include one, for example when:7d, when:30d, after:2026-01-01, or before:2026-02-01.

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

Google News country edition code, such as US, GB, DE, FR, IN, or CA.

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

Google News language code, such as en-US, en-GB, de-DE, fr-FR, or es-ES.

## `ceid` (type: `string`):

Optional Google News edition identifier. Leave blank to derive it from country and language, for example US:en.

## `dedupe` (type: `boolean`):

Avoid saving the same article more than once across all queries.

## Actor input object example

```json
{
  "queries": [
    "apify",
    "artificial intelligence startup"
  ],
  "maxItemsPerQuery": 20,
  "dateRange": "when:7d",
  "country": "US",
  "language": "en-US",
  "dedupe": true
}
```

# Actor output Schema

## `articles` (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": [
        "apify",
        "artificial intelligence startup"
    ],
    "dateRange": "when:7d",
    "country": "US",
    "language": "en-US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/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": [
        "apify",
        "artificial intelligence startup",
    ],
    "dateRange": "when:7d",
    "country": "US",
    "language": "en-US",
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/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": [
    "apify",
    "artificial intelligence startup"
  ],
  "dateRange": "when:7d",
  "country": "US",
  "language": "en-US"
}' |
apify call fetch_cat/google-news-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google News Scraper",
        "description": "Track Google News mentions by keyword, country, language, and recency. Export article titles, publishers, dates, snippets, and URLs.",
        "version": "0.1",
        "x-build-id": "hzC60zdq1M76pZQla"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~google-news-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-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/fetch_cat~google-news-scraper/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-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/fetch_cat~google-news-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-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",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Queries",
                        "type": "array",
                        "description": "Keywords or Google News query expressions to monitor. You can use operators such as quoted phrases, OR, when:7d, after:YYYY-MM-DD, and before:YYYY-MM-DD.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItemsPerQuery": {
                        "title": "Maximum articles per query",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of Google News results to save for each query.",
                        "default": 20
                    },
                    "dateRange": {
                        "title": "Date range query filter",
                        "type": "string",
                        "description": "Optional Google News date filter appended to queries that do not already include one, for example when:7d, when:30d, after:2026-01-01, or before:2026-02-01."
                    },
                    "country": {
                        "title": "Country / edition",
                        "type": "string",
                        "description": "Google News country edition code, such as US, GB, DE, FR, IN, or CA.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Google News language code, such as en-US, en-GB, de-DE, fr-FR, or es-ES.",
                        "default": "en-US"
                    },
                    "ceid": {
                        "title": "CEID override",
                        "type": "string",
                        "description": "Optional Google News edition identifier. Leave blank to derive it from country and language, for example US:en."
                    },
                    "dedupe": {
                        "title": "Remove duplicates",
                        "type": "boolean",
                        "description": "Avoid saving the same article more than once across all queries.",
                        "default": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
