# Viator & GetYourGuide Tours Scraper (`devilscrapes/tours-activity-unified`) Actor

Scrape and unify tour and activity prices from Viator and GetYourGuide into one normalized schema — prices, duration, ratings, review counts, booking URLs per activity — export to JSON or CSV. A Viator / GetYourGuide API alternative 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, 0 monthly users, 56.5% runs succeeded, 0 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="Viator and GetYourGuide Scraper" />

## Viator & GetYourGuide Scraper

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

**$3.05 / 1,000 activity rows — pay only for results that land. No credit card to try.**

Viator and GetYourGuide list overlapping inventory with different SKUs and prices. Running two single-source scrapers and writing your own normalization layer costs 1–2 dev-weeks and still leaves you with mismatched schemas. This Actor hits both platforms in one run, absorbs the blocks and retries, and emits one flat `ResultRow` per activity — platform, price, rating, duration, booking URL — straight into your Apify dataset.

One run. One schema. Ready for your spreadsheet, BI tool, or warehouse.

### 🎯 What this scrapes

Two major tours-and-activities platforms, unified into one Pydantic-validated 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>` is gated by a JS challenge that requires full browser execution. Documented as a future upgrade behind Camoufox; v1 returns `[]` with a WARNING.

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; no per-platform normalization required.
- **We rotate browser fingerprints** — `curl-cffi` impersonates Chrome 131 / Chrome 124 / Firefox 147 at the TLS+HTTP/2 layer, so both platforms see real-browser traffic, not Python.
- **We retry with exponential backoff** — `408 / 429 / 503` responses trigger up to 5 attempts with doubling delays; `Retry-After` headers are honoured.
- **We rotate residential proxies** — `BUYPROXIES94952` routing is on by default; a fresh `session_id` and fresh exit IP are issued on every block.
- **Per-platform isolation** — one platform's failure does not abort the run; surviving platforms still produce data.
- **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"` → `7.0` (midpoint); `"30 minutes"` → `0.5`; `"1 day"` → `24.0`.
- **Pydantic v2 validation** — input and every output row are model-validated; invalid input fails fast with a clear error before any network call.
- **Clean dataset rows** — ISO-8601 timestamps, stable platform IDs, no half-parsed strings.
- **Configurable cap** — `maxPerPlatform` lets you cap each platform at 1–100 rows per run.

### 💡 Use cases

- **Tour operator competitive intelligence** — find every activity your competitors list in your destination, 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 the same destination.
- **Dynamic pricing strategy** — track how the same activity type is priced on each platform over time and adjust your own listings accordingly.
- **Destination intelligence reports** — schedule weekly runs for "Paris" or "Tokyo" into a named dataset and chart price drift.
- **Travel-blogger affiliate research** — surface high-rating, high-review-count activities for destination guides without manual browsing.
- **Inbound-tour-builder market research** — discover which experiences dominate the first-page results when entering a new destination.
- **Travel-tech investor diligence** — benchmark the 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 platforms throttle datacenter traffic.
6. Click **Start**. Results stream into the default dataset.

#### Quick examples

**Both supported platforms, default cap:**

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

**GetYourGuide only, 5 rows (fastest path to confirm output shape):**

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

**Viator only, 50 rows:**

```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 is made.

### 📤 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) — you pay only for results that land:

| 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**.

No results → no charge beyond the $0.05 start event. No subscription, no seat fee.

### 🚧 Limitations

- **Klook returns 0 rows in v1** — the search endpoint is gated by a JS challenge that `curl-cffi` cannot clear without a full browser. We document 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: Does Viator or GetYourGuide offer an official API I can use instead?**
A: Viator and GetYourGuide do publish partner APIs, but they require approved partner status, commercial agreements, and ongoing approval processes that most independent developers and analysts cannot access. This Actor scrapes the public search-results pages — no partner relationship needed. The output schema is compatible with what a partner API would return for the same fields.

**Q: Why is Klook in the schema but returns 0 rows?**
A: Klook gates every meaningful endpoint behind a JS challenge that `curl-cffi` cannot clear without a full browser. Adding Klook v2 requires Camoufox, which costs roughly 10× 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: How is `duration_hours` parsed?**
A: Viator and GetYourGuide write durations in several 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: Can I track an activity's price across multiple 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; a named dataset persists until you delete it.

**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.

**Q: Why default `useProxy: true`?**
A: Both platforms run behind edge protection and occasionally throttle datacenter IP ranges. The default-on posture trades a small latency overhead for materially higher first-page success rates. If you are running from a clean residential network, you can set it to `false`.

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

### 💬 Your feedback

Found a parser glitch, a missing platform, or a field that's broken? Open an issue on the Actor's Apify Store page. We read every report — the QA fixture for Paris keeps regressions locked, but real-world destination edge cases always surface new patterns.

# 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": "Viator & GetYourGuide Tours Scraper",
        "description": "Scrape and unify tour and activity prices from Viator and GetYourGuide into one normalized schema — prices, duration, ratings, review counts, booking URLs per activity — export to JSON or CSV. A Viator / GetYourGuide API alternative for tour operators and OTA analysts.",
        "version": "0.1",
        "x-build-id": "ndtlPd2yY90Pvmm0c"
    },
    "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```