# GetYourGuide Scraper | Tours and Activities (`parseforge/getyourguide-scraper`) Actor

Scrape tours and activities from GetYourGuide including titles, prices, durations, ratings, review counts, locations, categories and availability. Build datasets of travel experiences for price comparison, destination research and tourism market analysis

- **URL**: https://apify.com/parseforge/getyourguide-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Travel, E-commerce, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🗺️ GetYourGuide Scraper

> 🚀 **Export GetYourGuide tours and activities in seconds.** Search any destination, get prices, ratings, durations, and reviews - no API key needed.

> 🕒 **Last updated:** 2026-05-22 · **📊 14 fields** per record · **500+ results per query** · **Global coverage**

Extract structured data from GetYourGuide's search results for any destination worldwide. This scraper collects all publicly visible activity listings - prices, ratings, review counts, durations, badges, and direct booking URLs - without requiring authentication.

GetYourGuide hosts over 300,000 experiences in 190+ countries. This dataset is refreshed in real-time on every run, ensuring you always get current pricing and availability data.

### Coverage

- 190+ countries and 10,000+ destinations
- 300,000+ activities and experiences
- 14 structured fields per record including images, ratings, prices, and badges
- Live pricing in USD (or local currency based on your proxy location)

### Target Audience / Use Cases

| User Type | Use Case |
|-----------|----------|
| Travel agencies | Monitor competitor pricing and offerings |
| Market researchers | Analyze tour pricing trends by destination |
| Data analysts | Build destination attraction databases |
| Travel bloggers | Curate ranked activity lists for any city |
| OTA developers | Populate travel comparison tools |
| Entrepreneurs | Source data for travel recommendation apps |

### 📋 What the GetYourGuide Scraper does

- Searches GetYourGuide for any destination, city, or keyword
- Collects activity listings with full structured data
- Extracts activity ID, title, price, rating, review count, duration, and badges
- Captures CDN image URLs for every activity
- Paginates automatically to collect more results
- Exports to CSV, Excel, JSON, or XML via Apify datasets

> 💡 **Why it matters:** GetYourGuide is the world's largest tours and activities marketplace. Monitoring it gives you real-time insight into pricing, demand signals (review counts), and popular experiences for any destination on Earth.

### 🎬 Full Demo

🚧 Coming soon

### ⚙️ Input

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `searchQuery` | string | `"Paris"` | Destination, city, or keyword to search |
| `maxItems` | integer | `10` | Maximum number of activities to collect |

**Example - Search for Rome tours:**
```json
{
  "searchQuery": "Rome",
  "maxItems": 50
}
````

**Example - Search for specific experiences:**

```json
{
  "searchQuery": "Eiffel Tower skip the line",
  "maxItems": 20
}
```

> ⚠️ **Good to Know:** Free users are limited to 10 activities per run. Paid users can collect up to 1,000,000 activities. Each GetYourGuide search page contains ~24 activities. Pagination is automatic.

### 📊 Output

| Field | Type | Description |
|-------|------|-------------|
| 🖼️ `imageUrl` | string | CDN image URL for the activity thumbnail |
| 🆔 `activityId` | string | GetYourGuide internal activity ID |
| 📌 `title` | string | Activity name |
| 📝 `description` | string | Short description (null - requires detail page) |
| ⭐ `rating` | number | Average rating (0-5) |
| 💬 `reviewCount` | integer | Total number of reviews |
| 💰 `price` | number | Price per person (from price) |
| 💱 `currency` | string | Currency code (e.g. USD, EUR) |
| ⏱️ `duration` | string | Activity duration (e.g. "3 hours", "1 day") |
| 📍 `location` | string | Destination city or area |
| 🏷️ `categories` | array | Category tags (from search listings) |
| 🎖️ `badges` | array | Badges like "Top rated", "Likely to sell out" |
| 🔗 `url` | string | Direct link to the booking page |
| 🕒 `scrapedAt` | string | ISO timestamp of when the item was collected |
| ❌ `error` | string | Error message if scraping failed |

**Sample records:**

```json
[
  {
    "imageUrl": "https://cdn.getyourguide.com/image/.../tour_img/558abca8...jpg",
    "activityId": "44309",
    "title": "Normandy D-Day Sites Guided Day Trip with Lunch",
    "description": null,
    "rating": 4.7,
    "reviewCount": 1248,
    "price": 116,
    "currency": "USD",
    "duration": "14 hours",
    "location": "Paris",
    "categories": [],
    "badges": ["Top pick"],
    "url": "https://www.getyourguide.com/paris-l16/paris-normandy-d-day-sites-guided-day-trip-with-lunch-t44309/",
    "scrapedAt": "2026-05-22T01:19:38.734Z"
  },
  {
    "imageUrl": "https://cdn.getyourguide.com/image/.../tour_img/926695a4...jpg",
    "activityId": "51059",
    "title": "3-Course-Dinner Cruise on the Seine with live music",
    "description": null,
    "rating": 4.7,
    "reviewCount": 7861,
    "price": 134,
    "currency": "USD",
    "duration": "2.5 hours",
    "location": "Paris",
    "categories": [],
    "badges": ["Likely to sell out"],
    "url": "https://www.getyourguide.com/paris-l16/bateaux-parisiens-dinner-cruise-t51059/",
    "scrapedAt": "2026-05-22T01:19:38.734Z"
  },
  {
    "imageUrl": "https://cdn.getyourguide.com/image/.../tour_img/2dea3428...jpeg",
    "activityId": "529663",
    "title": "Catacombs Entry & Seine River Cruise with Audio Guide",
    "description": null,
    "rating": 4.4,
    "reviewCount": 1297,
    "price": 134,
    "currency": "USD",
    "duration": "3 hours",
    "location": "Paris",
    "categories": [],
    "badges": ["Optional audio guide"],
    "url": "https://www.getyourguide.com/paris-l16/paris-catacombs-entry-seine-river-cruise-with-audio-guide-t529663/",
    "scrapedAt": "2026-05-22T01:19:38.735Z"
  }
]
```

### ✨ Why choose this Actor

| Feature | Benefit |
|---------|---------|
| 🌍 Global coverage | Search any destination in 190+ countries |
| ⚡ Real-time data | Live pricing, ratings, and badge status |
| 🖼️ Images included | CDN image URLs for every activity |
| 🔗 Direct URLs | Booking links for each activity |
| 📊 Structured output | Clean JSON ready for analysis or integration |
| 🤖 Anti-bot bypass | Uses real browser fingerprinting via camoufox |

### 📈 How it compares to alternatives

| Feature | This Actor | Manual scraping | GetYourGuide API |
|---------|-----------|-----------------|-----------------|
| No API key required | ✅ | ✅ | ❌ Requires partner program |
| Structured data | ✅ | ❌ | ✅ |
| Scalable | ✅ 1M+ items | ❌ | Limited |
| Free tier | ✅ 10 items | ✅ | ❌ |

### 🚀 How to use

1. [Create a free Apify account](https://console.apify.com/sign-up?fpr=vmoqkp) with $5 credit
2. Navigate to the [GetYourGuide Scraper](https://apify.com/parseforge/getyourguide-scraper) page
3. Enter your search query (destination or keyword)
4. Set `maxItems` to how many activities you want
5. Click **Save & Run**
6. Download results as CSV, Excel, JSON, or XML

### 💼 Business use cases

#### Travel Agency Competitive Intelligence

Monitor prices and offerings from GetYourGuide to benchmark your own tours. Track which activities are gaining reviews (rising demand) and which are losing ground.

#### Market Research & Destination Analysis

Build comprehensive attraction databases for any destination. Analyze what types of activities command premium prices, how review counts correlate with pricing, and what badges indicate best-sellers.

#### OTA and Comparison Platform Development

Populate your travel comparison tool with real GetYourGuide data. Keep prices current by scheduling periodic runs.

#### Travel Content Creation

Curate ranked lists of the best activities in any city, backed by real ratings and review counts from one of the world's largest booking platforms.

### 🔌 Automating GetYourGuide Scraper

Connect this scraper to thousands of apps:

- **Make (Integromat)** - Trigger on a schedule, push data to Google Sheets
- **Zapier** - Auto-export new activities to Airtable or Notion
- **Slack** - Get alerts when new high-rated activities appear
- **n8n** - Build custom travel data pipelines
- **Google Sheets** - Direct CSV export from Apify datasets

### 🌟 Beyond business use cases

#### Academic Research

Analyze global tourism pricing patterns. Study how activity pricing varies by destination, season, and category across 190+ countries.

#### Personal Travel Planning

Quickly scrape and compare all activities in your destination before booking - see what's popular, highly rated, and competitively priced.

#### Non-profit Travel Programs

Build open databases of local experiences for community travel programs or tourism development initiatives.

#### Developer Experiments

Use GetYourGuide data to train recommendation models, build travel chatbots, or prototype destination guides.

### 🤖 Ask an AI assistant about this scraper

You can ask Claude, ChatGPT, or any AI assistant:

- "What fields does the GetYourGuide Scraper return?"
- "How do I export Paris tours to Excel from GetYourGuide?"
- "What's the difference between the badges on GetYourGuide activities?"

### ❓ Frequently Asked Questions

**❓ Is this scraper legal?**
Yes. It only accesses publicly available data visible to any visitor without logging in. No authentication or bypass of paywalls is involved.

**❓ How many activities can I get per search?**
GetYourGuide shows approximately 24 activities per page. The scraper paginates automatically. A single search for "Paris" can return 500+ results.

**❓ What is the `description` field always null?**
Descriptions are only available on individual activity detail pages, not in search listings. A future version may optionally scrape detail pages.

**❓ Why is `categories` always empty?**
GetYourGuide search card listings do not include category tags in their HTML. The data is only available on detail pages.

**❓ What does "Top pick" badge mean?**
GetYourGuide assigns "Top pick" to activities with exceptional ratings and review counts relative to their category.

**❓ What currencies are returned?**
Prices are shown in the currency of your proxy location. Default runs use USD via US residential proxies.

**❓ How current is the data?**
All data is scraped in real-time on each run. There are no cached responses.

**❓ Can I search by category?**
Yes - use keywords like "cooking class Paris", "food tour Rome", or "boat cruise Amsterdam" for category-specific results.

**❓ What if the site changes its structure?**
The actor uses URL-based ID extraction which is robust to minor HTML changes. Major structural changes may require an update.

**❓ Can I run this on a schedule?**
Yes. Use Apify's scheduler to run this actor daily or weekly for ongoing monitoring.

**❓ How long does a 100-item run take?**
Approximately 60-90 seconds, as GetYourGuide serves about 24 items per page and requires 4-5 pages with brief waits between requests.

### 🔌 Integrate with any app

Export results directly from the Apify platform to:
CSV - Excel - JSON - XML - Google Sheets - Airtable - Make - Zapier - n8n - REST API - Webhooks - Slack - Notion

### 🔗 Recommended Actors

| Actor | Description |
|-------|-------------|
| [Viator Scraper](https://apify.com/parseforge/viator-scraper) | Scrape Viator tours and activities |
| [Trustpilot Reviews Scraper](https://apify.com/parseforge/trustpilot-reviews-scraper) | Extract business reviews |
| [Yelp Reviews Scraper](https://apify.com/parseforge/yelp-reviews-scraper) | Get local business reviews |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for scrapers covering hundreds of platforms.

***

**Disclaimer:** This actor is provided for legitimate data research and analysis purposes. Users are responsible for ensuring their use complies with GetYourGuide's Terms of Service and applicable laws. This actor accesses only publicly available, non-authenticated data. ParseForge is not affiliated with GetYourGuide.

# Actor input Schema

## `searchQuery` (type: `string`):

Destination or search term (e.g. 'Paris', 'Rome', 'Eiffel Tower')

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "searchQuery": "Paris",
  "maxItems": 10
}
```

# 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 = {
    "searchQuery": "Paris",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/getyourguide-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 = {
    "searchQuery": "Paris",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/getyourguide-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 '{
  "searchQuery": "Paris",
  "maxItems": 10
}' |
apify call parseforge/getyourguide-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "GetYourGuide Scraper | Tours and Activities",
        "description": "Scrape tours and activities from GetYourGuide including titles, prices, durations, ratings, review counts, locations, categories and availability. Build datasets of travel experiences for price comparison, destination research and tourism market analysis",
        "version": "0.1",
        "x-build-id": "Qb6AKyspwlWoTRD27"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~getyourguide-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-getyourguide-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/parseforge~getyourguide-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-getyourguide-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/parseforge~getyourguide-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-getyourguide-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "searchQuery"
                ],
                "properties": {
                    "searchQuery": {
                        "title": "Search / Destination",
                        "type": "string",
                        "description": "Destination or search term (e.g. 'Paris', 'Rome', 'Eiffel Tower')"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
