# Google Trends Scraper 💎 (`scraperpro/google-trends-scraper`) Actor

Fastest and Cheapest Google Trends Scraper: All in one, 🔥real time trending searches, interest over time, interest by region, and Related queries and topics, and more

- **URL**: https://apify.com/scraperpro/google-trends-scraper.md
- **Developed by:** [ScraperPro](https://apify.com/scraperpro) (community)
- **Categories:** SEO tools, News, Developer tools
- **Stats:** 131 total users, 4 monthly users, 98.1% runs succeeded, 11 bookmarks
- **User rating**: 3.89 out of 5 stars

## Pricing

$12.00/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## 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 Trends Scraper

An Apify Actor that retrieves data from Google Trends: realtime trending searches, interest over time, interest by region, and related queries/topics.

#### 🚀 Quickstart (no input required)

Want to get started in a flash? ⚡️ The actor has smart defaults, so you can run it immediately and get the latest realtime trending searches for the US.

* **In the Apify UI:** Just click **Run**.

---

#### 🔍 What you can fetch

* **Trending now (realtime):** ⏰ Find out what's rapidly rising in searches in the last few hours.
* **Interest over time:** 📊 Get a timeline of search interest for one or more keywords.
* **Interest by region:** 🗺️ Discover where your keywords are searched the most.
* **Related queries/topics:** 💡 Explore new queries and topics related to your main keyword.

---

#### 💰 Pricing (rental)

- $12/month
- Recommended for ongoing tracking and monitoring workflows.
- You can configure inputs freely; heavy configurations (very long timeframes, CITY/DMA resolution, inc_low_vol) may take longer.


#### ⚙️ Input (overview)

The actor's UI is dynamically generated from the `.actor/INPUT_SCHEMA.json` file. Here are the key fields you'll interact with:

* **`scrape_type`** (select, default: `trending_now`)
* **`keywords`** (array, optional for `trending_now`; required for other types)
* **`gprop`** (select: `web`/`images`/`news`/`shopping`/`youtube`)
* **`timeframe_type`** (select: `predefined` or `custom`, default: `predefined`)
* **`predefined_timeframe`** (select, default: `today 12-m`)
* **`custom_timeframe`** (string, e.g. "2023-01-01 2023-06-30")
* **`geo_selection_type`** (select, default: `Common Countries`)
* **`common_geo`** (string country code, default: `US`)
* **`custom_geo_code`** (string for regions like `US-CA`)
* **`geo_resolution`** (`COUNTRY`/`REGION`/`DMA`/`CITY`; for `interest_by_region`)
* **`inc_low_vol`** (boolean; include low-volume regions; **Pro** recommended)
* **`trending_language`** (string, default: `en`)
* **`trending_hours`** (integer 1-191, default: `24`)

---

#### 📋 Example Inputs

Here are some common use cases to get you started!

1.  **Realtime trending (US, 24 hours)**
    ```json
    {
      "scrape_type": "trending_now",
      "common_geo": "US",
      "trending_hours": 24,
      "trending_language": "en"
    }
    ```
2.  **Interest over time for multiple keywords (US)**
    ```json
    {
      "scrape_type": "interest_over_time",
      "keywords": ["data science", "machine learning"],
      "timeframe_type": "predefined",
      "predefined_timeframe": "today 12-m",
      "geo_selection_type": "Common Countries",
      "common_geo": "US"
    }
    ```
3.  **Related queries for a single keyword (global)**
    ```json
    {
      "scrape_type": "related_queries",
      "keywords": ["python"],
      "timeframe_type": "predefined",
      "predefined_timeframe": "today 12-m"
    }
    ```

---

#### 💾 Output & Output tab UI

The actor writes exactly one item to the dataset per run, with fields:
- scrape_type
- data (the full results for the chosen type)
- error (boolean)
- error_message (string or null)
- input_summary (geo, timeframe, resolution, gprop, etc.)

Output tab UI
- The default view is All results and shows the full data JSON right away (no need to switch tabs).
- Extra views:
  - Trending now (table): A flattened table when scrape_type is trending_now
  - Summary: A quick summary of inputs and error status

Notes on data structures
- interest_over_time / interest_by_region: data is an array of objects (rows), similar to a table
- related_queries / related_topics: data is an array containing keyed lists like { "top": [...], "rising": [...] }
- trending_now: data is a list of trending keyword objects (keyword, geo, volume, topic_names, timestamps)

---

#### ⚠️ Reliability & Troubleshooting
 
Encounter common issues? Check this guide:
 
| Error Type | Symptom | Solution |
| :--- | :--- | :--- |
| **User Confusion** | "My results don't match my keywords!" | Check **Scrape Type**. If it's set to `Trending now`, it ignores keywords. Switch to `Interest over time`. |
| **Proxy Error** | `ProxyError`, `Connection refused` | Google blocked the IP. Enable **Apify Proxy** (Residential recommended) or rotate custom proxies. |
| **Rate Limit** | `429 Too Many Requests` | You are scraping too fast. Slow down, use more proxies, or verify your proxy configuration. |
| **Timeout** | `TimeoutError`, Actor hangs | The request took too long. Try a shorter **Timeframe**, lower **Geo Resolution**, or faster proxies. |
| **No Data** | `AttributeError`, Empty results | Keyword might be too niche for the selected region/timeframe. Try broadening the search (e.g., "Past 5 years"). |
| **Invalid URL** | `ValueError: Invalid Input` | You entered a non-Google Trends URL in keywords. Please enter search terms only. |
 
---
 
#### 🧰 Runtime defaults & limits
 
- Memory: 1024 MB (default)
- Timeout: 30 minutes (default)
- CPU: 1 (default)
- Dataset writes: The actor always writes at least one item per run. If no data is found, it pushes an informative item with input summary.
 
---
 
 ## ❓ FAQ & Common Mistakes
 
#### Why is my result showing general trending topics instead of my keywords?
You likely left the **Scrape Type** set to default (`Trending now`). 
- **Trending now:** Shows what is popular in the world right now (ignores your keywords).
- **Interest over time:** Shows data specific to **your** keywords.
 
**Fix:** Change the **Scrape Type** dropdown at the top of the input to `Interest over time` or `Related queries`.
 
#### Why am I getting "No data returned"?
1. **Check your Timeframe:** Very short timeframes (e.g., "Past hour") often have no data for niche keywords. Try `Past 12 months`.
2. **Check your Spelling:** Google Trends is sensitive to spelling.
3. **Geo Mismatch:** Searching for a local keyword (e.g., a specific German store) while Geo is set to "US" will return zero results.
 
#### 📄 Notes
 
* **Smart Logic:** The actor now detects if you provide keywords but select the wrong scrape type and will warn you in the logs.
* **Alias support:** You can use `"trending_searches"` as a supported alias for `"trending_now"`.

---

### Changelog

#### Version 0.2 (Major Update)
- **Enhanced UI/UX**: Grouped input fields for better clarity and added "Smart Logic" to warn about mismatched configurations (e.g., providing keywords for "Trending Now").
- **Smart Logic & Error Handling**:
  - Automatically validates URLs in keywords.
  - Fixes `400 Bad Request` issues by auto-switching to `REGION` resolution when a specific country is selected.
  - Implemented specific error messages for Proxy Errors, Timeouts, and Rate Limits.
  - The actor now exits with a proper error code on fatal failures to prevent hanging.
- **Documentation**: Added comprehensive troubleshooting guide and updated FAQ.

# Actor input Schema

## `scrape_type` (type: `string`):

Select the type of data to retrieve. 'Trending now' ignores keywords.
## `keywords` (type: `array`):

Enter the terms you want to analyze. REQUIRED for all types EXCEPT 'Trending now'.
## `gprop` (type: `string`):

Filter results by specific Google properties (e.g., specific to YouTube searches).
## `timeframe_type` (type: `string`):

Choose between a predefined range (easier) or a custom specific range.
## `predefined_timeframe` (type: `string`):

Select a standard time window.
## `custom_timeframe` (type: `string`):

Format: 'YYYY-MM-DD YYYY-MM-DD'. Example: '2023-01-01 2023-12-31'. Leave empty if using Predefined.
## `geo_selection_type` (type: `string`):

Choose how to specify the location.
## `common_geo` (type: `string`):

Select the country code.
## `custom_geo_code` (type: `string`):

Specific code like 'US-NY' (New York) or 'US-CA' (California).
## `geo_resolution` (type: `string`):

Level of detail for 'Interest by region'.
## `inc_low_vol` (type: `boolean`):

Get data even for regions with low search volume (slower).
## `trending_language` (type: `string`):

Language for 'Trending now' scrape type.
## `trending_hours` (type: `integer`):

Hours back for 'Trending now' (Max 191).
## `proxyConfiguration` (type: `object`):

Crucial for avoiding Google blocks. Use Apify Proxy (Residential) for best results.

## Actor input object example

```json
{
  "scrape_type": "trending_now",
  "keywords": [
    "OpenAI",
    "ChatGPT"
  ],
  "gprop": "web",
  "timeframe_type": "predefined",
  "predefined_timeframe": "today 12-m",
  "custom_timeframe": "2023-01-01 2023-12-31",
  "geo_selection_type": "Common Countries",
  "common_geo": "US",
  "custom_geo_code": "",
  "geo_resolution": "COUNTRY",
  "inc_low_vol": false,
  "trending_language": "en",
  "trending_hours": 24
}
````

# Actor output Schema

## `results` (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 = {
    "keywords": [
        "OpenAI",
        "ChatGPT"
    ],
    "custom_timeframe": "2023-01-01 2023-12-31",
    "common_geo": "US"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scraperpro/google-trends-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 = {
    "keywords": [
        "OpenAI",
        "ChatGPT",
    ],
    "custom_timeframe": "2023-01-01 2023-12-31",
    "common_geo": "US",
}

# Run the Actor and wait for it to finish
run = client.actor("scraperpro/google-trends-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 '{
  "keywords": [
    "OpenAI",
    "ChatGPT"
  ],
  "custom_timeframe": "2023-01-01 2023-12-31",
  "common_geo": "US"
}' |
apify call scraperpro/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Trends Scraper 💎",
        "description": "Fastest and Cheapest Google Trends Scraper: All in one, 🔥real time trending searches, interest over time, interest by region, and Related queries and topics, and more",
        "version": "0.2",
        "x-build-id": "Fk1bvxJKSaBt9DQ5K"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scraperpro~google-trends-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scraperpro-google-trends-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/scraperpro~google-trends-scraper/runs": {
            "post": {
                "operationId": "runs-sync-scraperpro-google-trends-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/scraperpro~google-trends-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-scraperpro-google-trends-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": {
                    "scrape_type": {
                        "title": "Scrape Type",
                        "enum": [
                            "trending_now",
                            "interest_over_time",
                            "interest_by_region",
                            "related_queries",
                            "related_topics",
                            "trending_searches"
                        ],
                        "type": "string",
                        "description": "Select the type of data to retrieve. 'Trending now' ignores keywords.",
                        "default": "trending_now"
                    },
                    "keywords": {
                        "title": "Search Terms / Keywords",
                        "type": "array",
                        "description": "Enter the terms you want to analyze. REQUIRED for all types EXCEPT 'Trending now'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "gprop": {
                        "title": "Google Property (Filter)",
                        "enum": [
                            "web",
                            "images",
                            "news",
                            "froogle",
                            "youtube"
                        ],
                        "type": "string",
                        "description": "Filter results by specific Google properties (e.g., specific to YouTube searches).",
                        "default": "web"
                    },
                    "timeframe_type": {
                        "title": "Timeframe Selection",
                        "enum": [
                            "predefined",
                            "custom"
                        ],
                        "type": "string",
                        "description": "Choose between a predefined range (easier) or a custom specific range.",
                        "default": "predefined"
                    },
                    "predefined_timeframe": {
                        "title": "Predefined Timeframe",
                        "enum": [
                            "now 1-H",
                            "now 4-H",
                            "now 1-d",
                            "now 7-d",
                            "today 1-m",
                            "today 3-m",
                            "today 12-m",
                            "today 5-y",
                            "all"
                        ],
                        "type": "string",
                        "description": "Select a standard time window.",
                        "default": "today 12-m"
                    },
                    "custom_timeframe": {
                        "title": "Custom Timeframe (Advanced)",
                        "type": "string",
                        "description": "Format: 'YYYY-MM-DD YYYY-MM-DD'. Example: '2023-01-01 2023-12-31'. Leave empty if using Predefined."
                    },
                    "geo_selection_type": {
                        "title": "Location Selection",
                        "enum": [
                            "Common Countries",
                            "Custom Geo Code"
                        ],
                        "type": "string",
                        "description": "Choose how to specify the location.",
                        "default": "Common Countries"
                    },
                    "common_geo": {
                        "title": "Country",
                        "type": "string",
                        "description": "Select the country code.",
                        "default": "US"
                    },
                    "custom_geo_code": {
                        "title": "Custom Geo Code (Region/City)",
                        "type": "string",
                        "description": "Specific code like 'US-NY' (New York) or 'US-CA' (California).",
                        "default": ""
                    },
                    "geo_resolution": {
                        "title": "Geographic Resolution",
                        "enum": [
                            "COUNTRY",
                            "REGION",
                            "DMA",
                            "CITY"
                        ],
                        "type": "string",
                        "description": "Level of detail for 'Interest by region'.",
                        "default": "COUNTRY"
                    },
                    "inc_low_vol": {
                        "title": "Include Low Volume Regions",
                        "type": "boolean",
                        "description": "Get data even for regions with low search volume (slower).",
                        "default": false
                    },
                    "trending_language": {
                        "title": "Trending Language",
                        "type": "string",
                        "description": "Language for 'Trending now' scrape type.",
                        "default": "en"
                    },
                    "trending_hours": {
                        "title": "Trending Hours",
                        "minimum": 1,
                        "maximum": 191,
                        "type": "integer",
                        "description": "Hours back for 'Trending now' (Max 191).",
                        "default": 24
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Crucial for avoiding Google blocks. Use Apify Proxy (Residential) for best results."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```