# Tours and Activity Unified (`devilscrapes/tours-activity-unified`) Actor

Cross-platform tour and activity price scraper. Unify Viator and GetYourGuide search results into one normalized schema with prices, duration, ratings, review counts, and booking URLs per activity. Built for tour operators and OTA analysts.

- **URL**: https://apify.com/devilscrapes/tours-activity-unified.md
- **Developed by:** [DevilScrapes](https://apify.com/devilscrapes) (community)
- **Categories:** Travel, E-commerce
- **Stats:** 2 total users, 1 monthly users, 33.3% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

<img src=".actor/icon.svg" width="160" alt="Tours and Activity Unified" />

## Tours and Activity Unified

_We do the dirty work so your dataset stays clean._ 😈

**$3.05 / 1,000 activity rows — Viator and GetYourGuide normalized into one schema.** Scrape activity search results across two major experience-booking platforms (Viator and GetYourGuide) for any destination, normalize the data into one Pydantic-validated `ResultRow`, and push it straight into the Apify dataset. One run gives you a side-by-side view of how each platform prices and ranks the same destination — work that today requires running two single-source scrapers and writing your own normalization layer.

This Actor hits each platform's universal search endpoint, parses the live HTML with `parsel`, and emits one flat row per activity with `platform`, `activity_id`, `activity_title`, `price_original`, `currency_original`, `duration_hours`, `rating`, `review_count`, `booking_url`, and `image_url`. Per-platform failure is non-fatal — a block on one platform does not abort the run.

### 🎯 What this scrapes
Two major tours-and-activities platforms, one schema:

1. **Viator** — `viator.com/searchResults/all?text=<query>` (server-rendered HTML, 24 cards per page, `data-automation` test attributes)
2. **GetYourGuide** — `getyourguide.com/s/?q=<query>` (Vue.js shell with SSR card content, 24 cards per page)
3. **Klook** *(v2 upgrade — currently returns 0 rows)* — `klook.com/search/?keyword=<query>` (gated by DataDome; requires browser rendering. Documented as a future upgrade behind Camoufox.)

Output rows carry every field needed for cross-platform comparison:

| Field | Type | Description |
|---|---|---|
| `platform` | string | Platform literal (`viator`, `getyourguide`, `klook`) |
| `activity_id` | string | Platform-canonical activity ID |
| `activity_title` | string | Card title text |
| `location_query` | string | Echo of the user input — useful when batching cities |
| `location_city` | string \| null | Best-effort city parsed from URL or query |
| `location_country` | string \| null | Best-effort country |
| `price_usd` | number \| null | USD price when the platform itself displays USD |
| `currency_original` | string \| null | ISO 4217 code parsed from the price symbol |
| `price_original` | number \| null | Numeric price in the displayed currency |
| `duration_hours` | number \| null | Activity duration in hours; midpoint for ranges |
| `rating` | number \| null | Star rating, 0-5 scale |
| `review_count` | integer \| null | Number of reviews |
| `operator_name` | string \| null | Tour operator/supplier when surfaced |
| `category` | string \| null | Card tag (`tour`, `experience`, ...) |
| `booking_url` | string | Absolute URL to the activity page |
| `image_url` | string \| null | Absolute URL to the primary thumbnail |
| `scraped_at` | string | ISO 8601 UTC timestamp |

### 🔥 Features
- **Two platforms, one schema** — drop the dataset straight into a spreadsheet or BI tool with no per-platform normalization.
- **Currency-aware** — symbol-to-ISO mapping (€/$/£/¥ -> EUR/USD/GBP/JPY); `price_usd` is populated only when the platform itself displays USD.
- **Duration parser handles ranges** — `"5 to 9 hours"` becomes `7.0` (midpoint); `"30 minutes"` becomes `0.5`; `"1 day"` becomes `24.0`.
- **Per-platform isolation** — one platform's failure (Cloudflare block, page restructure) does not abort the run; the others still produce data.
- **No browser** — pure HTTP with `curl-cffi` browser TLS fingerprint impersonation; low compute footprint and fast runs.
- **Pydantic v2 validation** — input and output are model-validated; invalid input fails fast with a clear error before any network call.
- **Optional Apify Proxy** — `BUYPROXIES94952` routing on by default to clear GetYourGuide's Cloudflare-fronted edge.
- **Exponential backoff** on `408` / `429` / `503` with `Retry-After` honoured.
- **Configurable cap** — `maxPerPlatform` lets you cap each platform at 1-100 rows per run.

### 💡 Use cases
- **Tour operator competitive intelligence** — find every tour your competitors list in your city, compare prices, ratings, and durations side-by-side.
- **OTA cross-platform analyst dashboards** — feed a BI tool with snapshots of how Viator and GetYourGuide each rank a destination.
- **Dynamic pricing strategy** — track how the same `activity_id` is priced on each platform and adjust your own listings.
- **Destination intelligence reports** — pull "Paris" or "Tokyo" weekly into a named dataset and chart price drift over time.
- **Inbound-tour-builder market research** — discover which experiences dominate the first-page search results in a new destination.
- **Travel-blogger affiliate research** — surface high-rating, high-review-count activities to feature in destination guides.
- **Travel-tech investor diligence** — track top-of-funnel pricing across the experience-booking layer of the travel stack.

### ⚙️ How to use it
1. Open the Actor input form.
2. Type a **Destination** (`Paris`, `New York`, `Tokyo`, `Bali`, ...).
3. (Optional) Pick **Platforms** — leave empty to scrape all three, or list a subset like `["viator"]` or `["getyourguide"]`. Klook returns 0 rows in v1 (documented limitation).
4. (Optional) Set **Max rows per platform** — default 20, max 100.
5. Leave **Use Apify Proxy** on (default) for cleaner exit IPs when GetYourGuide is fronted by Cloudflare.
6. Click **Start**. Results stream into the default dataset.

#### Quick examples

**Both supported platforms, default cap:**

```json
{
  "locationQuery": "Paris"
}
````

**GetYourGuide only, 5 rows (the QA fixture — fastest path to confirm output shape):**

```json
{
  "locationQuery": "Paris",
  "platforms": ["getyourguide"],
  "maxPerPlatform": 5,
  "useProxy": false
}
```

**Viator only, 50 rows, direct routing:**

```json
{
  "locationQuery": "Tokyo",
  "platforms": ["viator"],
  "maxPerPlatform": 50,
  "useProxy": false
}
```

### 📥 Input

| JSON key | Type | Default | Description |
|---|---|---|---|
| `locationQuery` | string | *(required)* | Destination text query (e.g. `"Paris"`) |
| `platforms` | array of literal | `[]` (= all 3) | Subset of `viator` / `getyourguide` / `klook` |
| `maxPerPlatform` | integer | `20` | Cap on rows per platform (1-100) |
| `useProxy` | boolean | `true` | Route via Apify Proxy `BUYPROXIES94952` |

`locationQuery` is the only required field. Whitespace is stripped; blank values are rejected up-front by Pydantic before any network call.

### 📤 Output

One row per activity. See the **What this scrapes** table above for the full schema.

```json
{
  "platform": "getyourguide",
  "activity_id": "508441",
  "activity_title": "Paris: Le Marais Guided Food Tour with Tastings",
  "location_query": "Paris",
  "location_city": "Paris",
  "location_country": null,
  "price_usd": null,
  "currency_original": "EUR",
  "price_original": 69.0,
  "duration_hours": 3.0,
  "rating": 4.9,
  "review_count": 506,
  "operator_name": null,
  "category": "experience",
  "booking_url": "https://www.getyourguide.com/paris-l16/no-diet-club-unique-local-food-tour-in-paris-le-marais-t508441/",
  "image_url": "https://cdn.getyourguide.com/image/.../tour_img/7b9edf635985a601.jpeg",
  "scraped_at": "2026-05-16T22:00:00.000Z"
}
```

### 💰 Pricing

Pay-Per-Event (PPE):

| Event | Rate | Trigger |
|---|---|---|
| `actor-start` | $0.05 | Once per run at Actor boot |
| `result-row` | $0.003 | Per activity row emitted |

**Typical run cost** (default `maxPerPlatform=20`, 2 working platforms, ~40 rows): **~$0.17**.
**Per 1,000 rows extrapolated**: **~$3.05**.

### 🚧 Limitations

- **Klook returns 0 rows in v1** — the search endpoint is gated by DataDome anti-bot, which requires full browser execution to clear. We documented this up front and ship without it rather than over-promise; v2 will add a Camoufox path behind a feature flag.
- **First page only** — no pagination across multiple result pages. Each platform returns ~20-24 cards on the first page; the default cap is 20.
- **No detail-page scraping** — we scrape the search-results surface only. Itineraries, photo galleries, availability calendars, and meeting points are out of scope for v1.
- **Currency follows the platform's display** — `price_usd` is populated only when the platform itself displays USD. We do not run our own FX conversion.
- **Search relevance is the platform's** — "Paris" can include cards for Versailles or nearby destinations, depending on each platform's relevance engine.
- **Apify free-tier residential proxy is limited** — `BUYPROXIES94952` is the only proxy group provisioned on this account; works for our scale.

### ❓ FAQ

**Q: Why is Klook in the schema but returns 0 rows?**
A: Klook gates every meaningful endpoint behind DataDome JS challenges that `curl-cffi` cannot clear without a full browser. Adding Klook would require Camoufox, which costs ~10x the compute of HTTP scraping. We kept the platform literal in the schema so v2 can land without breaking the dataset shape — but for v1, every Klook call returns `[]` with a WARNING. Use `platforms: ["viator", "getyourguide"]` to skip the wasted call entirely.

**Q: Why default `useProxy: true`?**
A: GetYourGuide is fronted by Cloudflare and occasionally throttles datacenter IPs. The default-on posture trades a tiny bit of latency for materially higher first-page success rate. If you are running on a clean residential network, you can set it to `false`.

**Q: How is `duration_hours` parsed?**
A: Viator and GetYourGuide write durations in a handful of formats: `"3 hours"`, `"1 hour"`, `"30 minutes"`, `"5 to 9 hours"`, `"1 day"`, `"2.5 hours"`. We parse all of them. For ranges, we use the midpoint (`"5 to 9 hours"` -> 7.0). Anything unparseable stays `null` rather than crashing the row.

**Q: Will the Actor re-query the same activity across runs?**
A: Yes — each run is independent. To track an activity over time, schedule periodic runs and write to a named dataset (`Actor.open_dataset(name=...)`) or export to your warehouse. The Apify default dataset retention is 7 days.

**Q: Why no detail-page scraping?**
A: Each detail page is a heavier scrape (cancellation policy, photos, availability), and many are Cloudflare-protected. v1 ships the breadth-first surface-level price intel that 80% of buyers actually need; detail-page scraping is on the v2 roadmap.

**Q: Can I batch multiple cities in one run?**
A: Not in v1 — one `locationQuery` per run. To batch, schedule one Actor task per city (Apify supports unlimited parallel tasks on the free tier up to the concurrent-run cap). Each result row carries `location_query` so downstream pivots stay correct.

### 💬 Your feedback

Found a parser glitch or want a platform added? Open an issue on the Actor's Apify Store page. Pull requests welcome via the source code repository linked in the Actor's metadata.

# Actor input Schema

## `locationQuery` (type: `string`):

Destination text query sent to each platform's search endpoint. Examples: <code>Paris</code>, <code>New York</code>, <code>Tokyo</code>.

## `platforms` (type: `array`):

List of platforms to scrape. Valid values: <code>viator</code>, <code>getyourguide</code>, <code>klook</code>. Leave empty to scrape all three (order: viator, getyourguide, klook). Note: Klook returns 0 rows in v1 due to DataDome anti-bot.

## `maxPerPlatform` (type: `integer`):

Cap on activity rows emitted per platform per run.

## `useProxy` (type: `boolean`):

Route requests through Apify Proxy (<code>BUYPROXIES94952</code>). Recommended on by default since GetYourGuide is Cloudflare-fronted.

## Actor input object example

```json
{
  "locationQuery": "Paris",
  "platforms": [],
  "maxPerPlatform": 20,
  "useProxy": true
}
```

# Actor output Schema

## `datasetItems` (type: `string`):

All dataset items as JSON.

## `datasetItemsCsv` (type: `string`):

Same data exported to CSV.

## `datasetView` (type: `string`):

Open the run dataset in the Console.

# 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 = {
    "locationQuery": "Paris"
};

// Run the Actor and wait for it to finish
const run = await client.actor("devilscrapes/tours-activity-unified").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 = { "locationQuery": "Paris" }

# Run the Actor and wait for it to finish
run = client.actor("devilscrapes/tours-activity-unified").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 '{
  "locationQuery": "Paris"
}' |
apify call devilscrapes/tours-activity-unified --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Tours and Activity Unified",
        "description": "Cross-platform tour and activity price scraper. Unify Viator and GetYourGuide search results into one normalized schema with prices, duration, ratings, review counts, and booking URLs per activity. Built for tour operators and OTA analysts.",
        "version": "0.1",
        "x-build-id": "ndYpFgn8AlYZXZPg1"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/devilscrapes~tours-activity-unified/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-devilscrapes-tours-activity-unified",
                "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/devilscrapes~tours-activity-unified/runs": {
            "post": {
                "operationId": "runs-sync-devilscrapes-tours-activity-unified",
                "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/devilscrapes~tours-activity-unified/run-sync": {
            "post": {
                "operationId": "run-sync-devilscrapes-tours-activity-unified",
                "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": [
                    "locationQuery"
                ],
                "properties": {
                    "locationQuery": {
                        "title": "Destination",
                        "type": "string",
                        "description": "Destination text query sent to each platform's search endpoint. Examples: <code>Paris</code>, <code>New York</code>, <code>Tokyo</code>."
                    },
                    "platforms": {
                        "title": "Platforms",
                        "type": "array",
                        "description": "List of platforms to scrape. Valid values: <code>viator</code>, <code>getyourguide</code>, <code>klook</code>. Leave empty to scrape all three (order: viator, getyourguide, klook). Note: Klook returns 0 rows in v1 due to DataDome anti-bot.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPerPlatform": {
                        "title": "Max rows per platform",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Cap on activity rows emitted per platform per run.",
                        "default": 20
                    },
                    "useProxy": {
                        "title": "Use Apify Proxy",
                        "type": "boolean",
                        "description": "Route requests through Apify Proxy (<code>BUYPROXIES94952</code>). Recommended on by default since GetYourGuide is Cloudflare-fronted.",
                        "default": true
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```