# Google News Scraper — Search & Topics RSS API (`bovi/google-news-scraper`) Actor

Scrape Google News by keyword or topic. Returns title, source, published date, direct RSS link, and parse\_confidence. No proxy needed. Pay per result.

- **URL**: https://apify.com/bovi/google-news-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** News, Marketing
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.87 / 1,000 news items

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 — RSS Search & Topics | from $0.90/1K | No Proxy

**For media monitoring agencies, market researchers, and AI news pipelines** that need structured, multi-language news data at volume without managing proxy infrastructure.

**$0.90 per 1,000 articles returned. No proxy cost — Google News RSS is public and free.** Most news scrapers charge for proxy usage on top; this one doesn't. No proxy, no API key, 25+ languages, 35+ country editions.

**German tech news? Japanese business news? Russian politics?** Set `language` + `country` and get country-edition Google News in any language — same structured schema.

| Tool | Price | Proxy required | Languages |
|---|---|---|---|
| **This actor** | $0.90/1k | No | 25+ |
| NewsCatcher API | $49/mo (commercial) | N/A | Limited |
| SerpAPI Google News | $50/mo (100 searches/mo) | N/A | Yes |
| Apify google-search-scraper (news filter) | more expensive | Yes (SERP proxy) | Limited |

Extract structured news data from Google News by keyword or topic category.
No proxy needed. No API key. Pay only per result.

**Pricing example:** 200 articles (1 run, 2 queries × 100 each) = **$0.18**. 1,000 articles = **$0.90**. 10,000 articles = **$9.00**.

---

### What you get

| Field | Description |
|---|---|
| `title` | Clean article headline (source suffix stripped) |
| `source_name` | Publisher name (e.g. "The Washington Post") |
| `source_url` | Publisher homepage URL |
| `source_domain` | Bare domain (e.g. `washingtonpost.com`) |
| `published_at` | ISO 8601 UTC timestamp (e.g. `2026-05-29T18:30:00Z`) |
| `pub_date_raw` | Original RFC 822 date from RSS |
| `rss_link` | Google News redirect link (`news.google.com/rss/articles/CBM...`) |
| `article_id` | Unique Google article token (CBM...) for deduplication |
| `query` | Which search query or topic produced this result |
| `feed_type` | `"search"` or `"topic"` |
| `language` | Language code used |
| `country` | Country code used |
| `scraped_at` | ISO 8601 timestamp of the run |
| `parse_confidence` | 0.0–1.0 quality score; 1.0 = all fields present |
| `warnings` | Machine-readable list of any quality issues |

---

### How to use (4 steps)

**1. Choose your input type**

- Search queries: `["artificial intelligence", "climate change"]`
- Named topics: `["TECHNOLOGY", "BUSINESS", "WORLD"]`
- Or both at once.

**2. Set language and country** (defaults: `en-US` / `US`)

Supports 25+ languages and 35+ country editions. Match them for best results:
`language: "de"` + `country: "DE"` for German news.

**3. Optionally filter by time** (search queries only)

`when: "7d"` for the last week. Options: `1h`, `7d`, `30d`, `1y`.

**4. Run and export**

Results stream in real time. Export as JSON, CSV, or Excel.

---

### Output sample

```json
{
  "title": "Opinion | How America can remain the world's AI superpower",
  "source_name": "The Washington Post",
  "source_url": "https://www.washingtonpost.com",
  "source_domain": "washingtonpost.com",
  "published_at": "2026-05-29T18:30:00Z",
  "pub_date_raw": "Fri, 29 May 2026 18:30:00 GMT",
  "rss_link": "https://news.google.com/rss/articles/CBMiwwFBVV95...",
  "article_id": "CBMiwwFBVV95cUxP...",
  "query": "artificial intelligence",
  "feed_type": "search",
  "language": "en-US",
  "country": "US",
  "scraped_at": "2026-05-31T10:00:00Z",
  "parse_confidence": 1.0,
  "warnings": []
}
````

***

### Input examples

#### Search by keyword

```json
{
  "queries": ["artificial intelligence", "climate tech"],
  "language": "en-US",
  "country": "US",
  "maxItems": 200
}
```

#### Browse topic sections

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

#### German tech news last 7 days

```json
{
  "queries": ["künstliche intelligenz"],
  "language": "de",
  "country": "DE",
  "when": "7d"
}
```

#### Combined queries + topics

```json
{
  "queries": ["Tesla", "SpaceX"],
  "topics": ["BUSINESS"],
  "language": "en-US",
  "country": "US",
  "maxItems": 300
}
```

***

### FAQ

**Why does `rss_link` point to `news.google.com` and not the original article?**

Google News RSS returns encoded redirect links, not direct article URLs. This is by design — it keeps our actor zero-cost and zero-proxy. To get the final article URL, follow the redirect in your own code. The `article_id` field uniquely identifies the article for deduplication.

**Can I get the article full text?**

Not from this actor. Google News RSS does not include article body text — only metadata. Use a separate article-scraping actor on the destination URLs.

**What does `parse_confidence` mean?**

A quality score from 0.0 to 1.0. Score 1.0 means all fields are present and valid. Deductions happen for missing title (−0.50), missing date (−0.15), missing source (−0.10). The `warnings` array lists which specific issues occurred. This lets you filter low-quality records programmatically.

**Does this need a proxy?**

No. Google News RSS is a public, officially-supported endpoint. It returns clean XML with no CAPTCHA, no IP blocking, and no authentication required.

**How many results can I get per query?**

Up to 100 articles per query (Google News RSS limit). For more results, use multiple queries with different `when` filters, or use the `topics` feeds.

**What languages and countries are supported?**

All locales that Google News supports. Tested: en-US, de/DE, fr/FR, ja/JP and others. Set `language` to the language code and `country` to the two-letter country code.

***

### Honest limits

- Maximum 100 articles per query (RSS feed limit; no pagination in RSS).
- No article body text — metadata only.
- No images (RSS does not include thumbnail URLs).
- `rss_link` is a Google redirect, not the final article URL.
- `parse_confidence` tracks RSS field completeness, not article content quality.

***

### Use cases

- **Media monitoring** — track brand or keyword mentions across news sources
- **Competitive intelligence** — follow competitors' press coverage by country
- **Market research** — monitor industry news sentiment in any language
- **News aggregation** — feed newsletters, dashboards, or alerts with structured data
- **Academic research** — bulk-collect dated news article metadata

***

### parse\_confidence trust score

Every record carries a `parse_confidence` score (0.0–1.0). Score 1.0 means all fields are present and valid. Deductions happen for missing title, date, or source — the `warnings` array lists specific issues for programmatic filtering.

### Use with AI agents (MCP)

Feed live news into your AI agent. This actor works as an MCP tool for any MCP-compatible agent (Claude, GPT-4o). Query by keyword, topic, language, and country — structured JSON back in seconds.

Config: https://mcp.apify.com/?tools=bovi/google-news-scraper

*Not affiliated with Google. Data is from Google News public RSS feeds.*

### Integrations

Built for media-monitoring agencies and AI news pipelines collecting structured multi-language news at volume — the JSON/dataset output drops into the tools you already run, no glue code:

- **n8n / Make / Zapier** — trigger a run or pipe every new dataset item into 500+ apps (Google Sheets, Airtable, Slack, HubSpot, your database) with no code: [n8n](https://docs.apify.com/platform/integrations/n8n), [Make](https://docs.apify.com/platform/integrations/make), [Zapier](https://docs.apify.com/platform/integrations/zapier).
- **Webhooks** — fire your own endpoint the moment a run finishes, to push results straight into your pipeline ([docs](https://docs.apify.com/platform/integrations/webhooks)).
- **MCP server** — expose this actor as a tool to Claude, Cursor, or any [MCP client](https://mcp.apify.com) so an AI agent can pull this data mid-conversation ([guide](https://blog.apify.com/how-to-use-mcp/)).
- **API & SDKs** — fetch the dataset as JSON, CSV, or Excel through the Apify REST API or the Python / JS SDKs.

See all [Apify integrations](https://apify.com/integrations).

### Use it from your existing tools

#### Use with Claude Desktop / Cursor / Cline (MCP)

Load this actor as a tool in your AI assistant. Call it directly from your AI assistant via the Apify MCP server — no Store browsing needed. Paste this into your MCP client config (e.g. `claude_desktop_config.json`) and restart the client:

```json
{
  "mcpServers": {
    "apify-google-news-scraper": {
      "command": "npx",
      "args": [
        "-y",
        "@apify/actors-mcp-server",
        "--tools",
        "bovi/google-news-scraper"
      ],
      "env": {
        "APIFY_TOKEN": "YOUR_APIFY_TOKEN"
      }
    }
  }
}
```

Replace `YOUR_APIFY_TOKEN` with your own Apify API token (free at apify.com → Settings → Integrations). Curated to a handful of tools so the agent selects reliably.

#### Works with Clay

Run this actor as an HTTP enrichment step inside a Clay table:

- **Method:** `POST`
- **URL:** `https://api.apify.com/v2/acts/bovi~google-news-scraper/run-sync-get-dataset-items?token={{apify_token}}`
- **Body (JSON):** map your Clay columns to the actor input (see the Input section above), e.g. `{"queries": "{{clay_column}}"}`

The run finishes synchronously and returns the dataset rows straight into your Clay table. It runs on Apify's cloud under your own token and usage. Synchronous runs must complete within 300 seconds.

# Actor input Schema

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

List of keyword queries to search on Google News. Supports operators: site:, intitle:, -exclude, "exact phrase", AND/OR.

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

Predefined Google News topic sections. Allowed values: WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SPORTS, SCIENCE, HEALTH.

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

Language and locale code, e.g. en-US, de, fr, es, ja. Affects search query language and results.

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

Two-letter country code for regional edition, e.g. US, GB, DE, FR, JP.

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

Maximum total articles to return across all queries and topics. 0 = no limit (up to 100 per feed).

## `topicsHashed` (type: `array`):

Raw hashed topic IDs from Google News URLs (e.g. CAAqJggK...). Supports topic/section paths: \<TOPIC\_ID>/sections/\<SECTION\_ID>.

## `when` (type: `string`):

Restrict search results to a time window. Examples: 1h (last hour), 7d (last week), 30d (last month), 1y (last year). Leave blank for no time filter. Only applies to search queries, not named topics.

## Actor input object example

```json
{
  "queries": [
    "artificial intelligence",
    "climate change"
  ],
  "topics": [],
  "language": "en-US",
  "country": "US",
  "maxItems": 200,
  "topicsHashed": [],
  "when": "7d"
}
```

# Actor output Schema

## `results` (type: `string`):

Dataset containing Google News Scraper records (title, source\_name, source\_domain, published\_at, rss\_link, query, feed\_type, language, country, parse\_confidence, warnings).

# 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",
        "climate change"
    ],
    "topics": [],
    "language": "en-US",
    "country": "US",
    "maxItems": 200,
    "topicsHashed": [],
    "when": "7d"
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/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",
        "climate change",
    ],
    "topics": [],
    "language": "en-US",
    "country": "US",
    "maxItems": 200,
    "topicsHashed": [],
    "when": "7d",
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/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",
    "climate change"
  ],
  "topics": [],
  "language": "en-US",
  "country": "US",
  "maxItems": 200,
  "topicsHashed": [],
  "when": "7d"
}' |
apify call bovi/google-news-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google News Scraper — Search & Topics RSS API",
        "description": "Scrape Google News by keyword or topic. Returns title, source, published date, direct RSS link, and parse_confidence. No proxy needed. Pay per result.",
        "version": "0.1",
        "x-build-id": "MR0PEcwSyNU5x14dd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bovi~google-news-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bovi-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/bovi~google-news-scraper/runs": {
            "post": {
                "operationId": "runs-sync-bovi-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/bovi~google-news-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-bovi-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": "List of keyword queries to search on Google News. Supports operators: site:, intitle:, -exclude, \"exact phrase\", AND/OR.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "topics": {
                        "title": "Named topics",
                        "type": "array",
                        "description": "Predefined Google News topic sections. Allowed values: WORLD, NATION, BUSINESS, TECHNOLOGY, ENTERTAINMENT, SPORTS, SCIENCE, HEALTH.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Language and locale code, e.g. en-US, de, fr, es, ja. Affects search query language and results."
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Two-letter country code for regional edition, e.g. US, GB, DE, FR, JP."
                    },
                    "maxItems": {
                        "title": "Max items total",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum total articles to return across all queries and topics. 0 = no limit (up to 100 per feed)."
                    },
                    "topicsHashed": {
                        "title": "Hashed topic IDs",
                        "type": "array",
                        "description": "Raw hashed topic IDs from Google News URLs (e.g. CAAqJggK...). Supports topic/section paths: <TOPIC_ID>/sections/<SECTION_ID>.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "when": {
                        "title": "Time filter (search only)",
                        "type": "string",
                        "description": "Restrict search results to a time window. Examples: 1h (last hour), 7d (last week), 30d (last month), 1y (last year). Leave blank for no time filter. Only applies to search queries, not named topics."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
