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

Extract trending searches from Google Trends for any country and language. Provides real-time search trends with volume, growth metrics, status, and related searches.

- **URL**: https://apify.com/akash9078/google-trends-scraper.md
- **Developed by:** [Akash Kumar Naik](https://apify.com/akash9078) (community)
- **Categories:** SEO tools, Developer tools, Other
- **Stats:** 28 total users, 4 monthly users, 97.9% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.00005 / actor start

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Trending Searches Scraper

Extract **trending searches** from Google Trends for any country and language in real-time. This Actor provides search trends with **volume metrics**, **growth percentages**, **status indicators**, and **related searches** to help you understand what people are searching for right now.

### Why scrape Google Trends?

The Google Trending Searches Scraper extracts currently trending search queries from Google Trends - the data you see at https://trends.google.com/trending. It scrapes the live trending searches list for any country and provides detailed information including:

- 🔥 **Trending search terms** - Real-time search trends people are searching for
- 📊 **Search volume metrics** - Popularity indicators (e.g., 2M+, 500K)
- 📈 **Growth percentages** - How rapidly each trend is growing
- ⏰ **Time information** - When the trend started (Active/Lasted status)
- 🔄 **Related searches** - Variations and related queries
- 🌍 **Multi-country support** - Trends from any country (US, India, UK, etc.)
- 🗣️ **Multi-language support** - Results in major global languages

#### Business Use Cases for Google Trends Data

- **Trend tracking** - Monitor what's trending in your target market for content creation and SEO strategy
- **Competitor research** - Discover trending topics in your industry before competitors
- **Market research** - Understand consumer interests and search behavior across different countries
- **Social media insights** - Find trending topics to create engaging social content
- **News and content planning** - Identify trending stories for timely content creation

#### Platform Advantages

Your Actor runs on the **Apify platform**, which provides:

- 🚀 **Scalable infrastructure** - Automatic scaling and reliable performance
- 🔄 **Proxy rotation** - Built-in proxy support (note: Apify proxy may cause timeouts with Google Trends)
- 📊 **Monitoring and logging** - Real-time monitoring and detailed logs
- 🔄 **API access** - Use results via REST API for integration with your tools
- 📈 **Scheduling** - Automate runs on your preferred schedule
- 📥 **Multiple exports** - Download results as JSON, CSV, Excel, or HTML

### What data can you extract from Google Trends?

| Field | Description | Example |
|-------|-------------|---------|
| **title** | The trending search term | "t20 world cup" |
| **searchVolume** | Search popularity indicator | "2M+","500K+","100K+" |
| **growthPercentage** | Growth since trend started | 300, 1000 |
| **status** | Current trend status | "Active", "Lasted" |
| **startedAgo** | Time since trend started | "20 hours ago", "2 hours ago" |
| **relatedSearches** | Related search terms | ["india vs zimbabwe", "sanju samson"] |
| **country** | Country code used | "US", "IN", "GB" |
| **language** | Language code used | "en-US", "hi-IN" |

### How to use the Google Trending Searches Scraper

#### Quick Start Guide

1. Open the Actor in Apify Console
2. Select your **Country** from the dropdown (default: India)
3. Select your **Language** from the dropdown (default: English - US)
4. Choose **Category** if you want to filter (default: All Categories)
5. Select **Time Range** (default: Past 24 hours)
6. Set **Maximum Results** (default: 25)
7. Click **Start & Run**

The Actor will use Playwright browser automation to scrape Google Trends and save results to a dataset.

#### Configuration Options

- **Country** - Choose from 20+ countries including US, UK, Germany, Japan, Brazil, and more
- **Language** - Available in 15+ languages including English, Hindi, Spanish, French, German, Japanese, Korean, and more
- **Category** - Filter by topic: Sports, Entertainment, Business, Technology, Politics, Health, and more
- **Time Range** - Past 4 hours, Past 24 hours, Past 48 hours, or Past 7 days
- **Maximum Results** - Up to 100 results per run
- **Proxy Settings** - Disabled by default for better performance; may cause timeouts with Google Trends

### Input Example

```json
{
  "geo": "IN",
  "hl": "en-US",
  "category": "",
  "time": "Past 24 hours",
  "maxResults": 25,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

### Output Example

```json
[
  {
    "title": "t20 world cup",
    "searchVolume": "2M+",
    "growthPercentage": 300,
    "status": "Active",
    "startedAgo": "20 hours ago",
    "timeInfo": "20 hours ago",
    "relatedSearches": [
      "india national cricket team vs zimbabwe national cricket team match scorecard",
      "sanju samson"
    ],
    "additionalItemsCount": 228,
    "chartImageUrl": "chart_available",
    "country": "IN",
    "language": "en-US",
    "category": "all",
    "timeRange": "Past 24 hours",
    "scrapedAt": "2026-02-26T15:49:00.000Z"
  }
]
```

You can download the dataset extracted by Google Trending Searches Scraper in various formats such as JSON, HTML, CSV, or Excel.

### How much will it cost to extract Google Trends data?

The Google Trending Searches Scraper uses **Pay-Per-Event (PPE)** pricing. You only pay for what you actually get.

#### Event Pricing

| Event | Description | Price |
|-------|-------------|-------|
| `apify-actor-start` | Automatic startup event (covers first 5 seconds of compute) | $0.00005 per start |
| `trending-search` | One trending search item scraped | $0.005 per item ($5.00/1,000) |

#### Example Costs

**Small run (25 trending searches from India):**

- Startup: $0.00005
- Results: 25 × $0.005 = $0.125
- **Total: ~$0.13 per run**

**Medium run (50 trending searches):**

- Startup: $0.00005
- Results: 50 × $0.005 = $0.250
- **Total: ~$0.25 per run**

**Large run (100 trending searches):**

- Startup: $0.00005
- Results: 100 × $0.005 = $0.500
- **Total: ~$0.50 per run**

#### Free Tier

With Apify's free tier, you can extract limited trending searches at no cost. For example:

- A few runs with 10-20 results per run are typically free on Apify's free tier
- This allows you to test the scraper and understand trending patterns
- When you're ready for larger scale, the pay-per-event model makes costs predictable and transparent

*Note: Pricing is per event charged, not per compute minute. See the input tab for more details on pricing and usage limits.*

### Is scraping Google Trends free?

Google Trending Searches Scraper offers a free tier that allows you to extract trending searches at no cost. The pay-per-event pricing model means you only pay for the actual results you extract.

For most use cases:

- Small scale testing with 10-20 results per run: Free on Apify's free tier
- Professional use with regular runs: Predictable per-item costs at $0.005 each
- Large scale operations: $0.50 per 100 results without hidden charges

#### Is it legal to scrape Google Trends?

Our scraper extracts publicly available information from Google Trends, which displays aggregated search trends. The scraper:

- ❌ Does not extract private user data (email addresses, phone numbers, personal information)
- ❌ Does not access logged-in user accounts
- ✅ Only extracts publicly available trend data that anyone can see at trends.google.com
- ✅ Uses ethical scraping practices with proper delays and respect for the platform

We believe this scraper, when used for ethical purposes by Apify users, is compliant with Google's Terms of Service. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not use personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

### What are the limitations of Google Trends scraping?

#### Known Limitations

- The scraper extracts data that is publicly available on the Google Trends trending page
- Apify proxy may cause timeouts with Google Trends; proxy is disabled by default for better performance
- Maximum 100 results per run (you can run multiple times if needed)
- Trend data is only as recent as what Google Trends shows (typically up to 7 days)

#### Tips for Best Results

- ⏱️ Run at different times of day to capture varying trends
- 🔄 Schedule regular runs to track trends over time
- 🎯 Use category filters to focus on specific topics
- 💾 Export results to track historical trends
- 🌍 Test different countries to discover global trends

### FAQ about Google Trends Scraping

#### How many results can I extract per run?

You can get up to 100 results per run by setting `maxResults` parameter. You can run the Actor multiple times to get more results or different time periods.

#### Can I scrape historical trends data?

Google Trends trending page shows current and recent trends (typically up to 7 days). For historical trend data beyond what's shown on the trending page, you may need the official Google Trends API or specialized tools.

#### What's the difference between "Active" and "Lasted" status?

- **Active**: The trend is still actively gaining search volume
- **Lasted**: The trend was active but search volume has peaked and declined

#### Can I use custom country codes?

The dropdown includes 20+ popular countries. For other countries, contact us to discuss adding support.

#### How do I access Google Trends data via API?

The Actor provides results in a dataset that can be accessed via Apify's REST API. Download the data in JSON, CSV, Excel, or HTML format, or integrate directly using the API endpoints available in the Console.

### Support and Troubleshooting

If you encounter any issues or have questions:

- 📖 Check the **Input tab** in Apify Console for detailed field descriptions
- 🐛 Report bugs or request features via the **Issues** tab
- 💬 Contact us through Apify Console for custom integrations
- 📧 Want to discuss a custom solution? Reach out to explore tailored scraping solutions

# Actor input Schema

## `geo` (type: `string`):

Select the country for which to fetch trending searches. The scraper will return trending searches popular in that specific country.

## `hl` (type: `string`):

Select the display language for the trending searches interface and results. This affects how dates, labels and other text are shown.

## `category` (type: `string`):

Filter trending searches by category to focus on specific topics. Default shows trending searches from all categories.

## `time` (type: `string`):

Select the time period for which to show trending searches. This determines how recent the trending searches should be.

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

Maximum number of trending search items to extract. More results take longer to process and consume more compute units.

## `proxyConfiguration` (type: `object`):

Configure proxy settings for anti-bot protection and to avoid IP blocking. Note: Apify proxy may cause timeouts with Google Trends; disabled by default for better performance.

## Actor input object example

```json
{
  "geo": "IN",
  "hl": "en-US",
  "category": "",
  "time": "Past 24 hours",
  "maxResults": 25,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "geo": "IN",
    "hl": "en-US",
    "category": "",
    "time": "Past 24 hours",
    "maxResults": 25,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("akash9078/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 = {
    "geo": "IN",
    "hl": "en-US",
    "category": "",
    "time": "Past 24 hours",
    "maxResults": 25,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("akash9078/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 '{
  "geo": "IN",
  "hl": "en-US",
  "category": "",
  "time": "Past 24 hours",
  "maxResults": 25,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call akash9078/google-trends-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Trends Scraper",
        "description": "Extract trending searches from Google Trends for any country and language. Provides real-time search trends with volume, growth metrics, status, and related searches.",
        "version": "2.0",
        "x-build-id": "jLSGjVkGAvWNFkDJg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/akash9078~google-trends-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-akash9078-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/akash9078~google-trends-scraper/runs": {
            "post": {
                "operationId": "runs-sync-akash9078-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/akash9078~google-trends-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-akash9078-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": {
                    "geo": {
                        "title": "Country",
                        "enum": [
                            "US",
                            "IN",
                            "GB",
                            "CA",
                            "AU",
                            "DE",
                            "FR",
                            "BR",
                            "JP",
                            "KR",
                            "RU",
                            "MX",
                            "IT",
                            "ES",
                            "NL",
                            "ZA",
                            "SG",
                            "HK",
                            "AE",
                            ""
                        ],
                        "type": "string",
                        "description": "Select the country for which to fetch trending searches. The scraper will return trending searches popular in that specific country.",
                        "default": "IN"
                    },
                    "hl": {
                        "title": "Language",
                        "enum": [
                            "en-US",
                            "en-GB",
                            "en-CA",
                            "en-AU",
                            "hi-IN",
                            "es-ES",
                            "es-MX",
                            "fr-FR",
                            "de-DE",
                            "pt-BR",
                            "it-IT",
                            "ja-JP",
                            "ko-KR",
                            "ru-RU",
                            "zh-CN",
                            "ar-AE",
                            "nl-NL"
                        ],
                        "type": "string",
                        "description": "Select the display language for the trending searches interface and results. This affects how dates, labels and other text are shown.",
                        "default": "en-US"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "",
                            "Sports",
                            "Entertainment",
                            "Business",
                            "Technology",
                            "Politics",
                            "Health",
                            "Science",
                            "Shopping",
                            "Games",
                            "Food and Drink",
                            "Travel",
                            "News",
                            "Fashion",
                            "Autos and Vehicles",
                            "Jobs and Education",
                            "Law and Government",
                            "Weather",
                            "Home and Garden",
                            "Hobbies and Leisure"
                        ],
                        "type": "string",
                        "description": "Filter trending searches by category to focus on specific topics. Default shows trending searches from all categories.",
                        "default": ""
                    },
                    "time": {
                        "title": "Time Range",
                        "enum": [
                            "Past 4 hours",
                            "Past 24 hours",
                            "Past 48 hours",
                            "Past 7 days"
                        ],
                        "type": "string",
                        "description": "Select the time period for which to show trending searches. This determines how recent the trending searches should be.",
                        "default": "Past 24 hours"
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of trending search items to extract. More results take longer to process and consume more compute units.",
                        "default": 25
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Settings",
                        "type": "object",
                        "description": "Configure proxy settings for anti-bot protection and to avoid IP blocking. Note: Apify proxy may cause timeouts with Google Trends; disabled by default for better performance.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```