# Package Holiday Price Comparison - Pauschalreise, TUI, DERTOUR (`kamerozkan/dach-package-holiday-price-api`) Actor

Compare Pauschalreise offers & package holiday prices across five German travel sources - TUI, DERTOUR, weg.de, ab-in-den-urlaub.de and alltours - in one normalized dataset. GIATA hotel matching, departure airport comparison, 90-day price history & buy-or-wait signals. Pauschalreisen price API.

- **URL**: https://apify.com/kamerozkan/dach-package-holiday-price-api.md
- **Developed by:** [Kamer Ozkan](https://apify.com/kamerozkan) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 1,000 package offers

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Package Holiday Price Comparison - TUI, DERTOUR, weg.de

> Unofficial, independent price-monitoring tool. Not affiliated with, endorsed
> by, or sponsored by TUI, DERTOUR, weg.de, ab-in-den-urlaub.de, alltours, or
> any other travel provider.

Compare package-holiday prices from five German travel sources in one
normalized dataset. Enter a destination, travel window, occupancy, duration,
and departure airports to receive hotel + flight offers, same-hotel
comparisons, airport matrices, price histories, capacity signals, and
transparent buy/wait forecasts.

### Why use it?

- Find the cheapest source for the same GIATA hotel with `dachEntityId`.
- Compare Düsseldorf, Munich, Frankfurt, or other departure airports.
- Build a deduplicated 90-day price curve for each stable package.
- Detect narrowing market availability from repeated observations.
- Create explainable buy/wait signals from price trend, volatility, days to
  departure, and availability evidence.
- Send optional signed webhook alerts with cooldown and retry protection.
- Keep partial results when one source is temporarily unavailable.

The Actor is built for tour-operator pricing teams, OTAs, travel agencies, and
travel-market analysts. It collects observations, not bookings. A provider may
revalidate price or availability at checkout.

### Quick start

Use this minimum input:

```json
{
  "destination": "Antalya",
  "startDate": "8 weeks",
  "endDate": "10 weeks",
  "nights": 7,
  "adults": 2,
  "childAges": [],
  "departureAirports": ["DUS", "MUC"],
  "operators": ["tui", "dertour", "weg", "aidu", "alltours"],
  "outputMode": "comparisons",
  "maxResultsPerOperator": 20
}
````

Dates accept either an absolute `YYYY-MM-DD` value or a rolling relative value
such as `8 weeks`. The Store form is prefilled with a valid rolling window so a
new user can run the example without repairing stale calendar dates.

Results are written to the default dataset. `OUTPUT` in the default key-value
store contains run status, record counts, source health, quality indicators,
errors, feature summaries, cost telemetry, and billing operations.

### Live sources and evidence

| Source | Transport | Hotel identity | Notable evidence |
| --- | --- | --- | --- |
| TUI Germany | Direct JSON | GIATA | Price, date, duration, room, board, discount |
| DERTOUR Germany | Direct JSON | GIATA | Flight legs, transfer, availability, flex marker |
| weg.de | Browser + intercepted JSON | GIATA | Flight, transfer, deal/flex markers, old price |
| ab-in-den-urlaub.de | Direct JSON | GIATA | Price, room/board, flex text; cashback is separate |
| alltours | Persisted GraphQL | GIATA | Flight, package operator, free cancellation, old price |

Missing flight, baggage, transfer, cancellation, tax, or fee data remains
explicit. The Actor does not invent unavailable fields. Optional, bounded
weg.de detail enrichment can fill evidence-backed baggage, transfer, and
flexible-cancellation fields and uses a persistent positive/negative TTL cache.

### Comparison modes

- `lowest_offer_in_search_window` compares the cheapest hotel offer returned by
  every selected source.
- `like_for_like_package` additionally matches departure date, nights,
  occupancy, airport, normalized room class, and normalized board class.

Match-quality fields label exact, normalized, requested, mixed, and missing
dimensions so downstream systems can decide what is comparable.

### Dataset record types

- `offer`
- `comparison`
- `airport_matrix`
- `price_series`
- `market_signal`
- `buy_wait_forecast`
- `alert_delivery`
- `run_diagnostic` - emitted without a result charge when no primary rows can
  be written, so an empty search, partial source outage, and spending limit are
  immediately distinguishable.

#### Real records from live runs

The two records below are unedited engine output from live runs on 2026-07-28; only
image lists and one very long source ID are shortened.

A real cross-operator `comparison`: the same GIATA-identified hotel, like-for-like
window, three portals, and a real 27 EUR spread. `matchQuality` declares per dimension
what was matched exactly and what was normalized, so a like-for-like claim is auditable
instead of asserted:

```json
{
  "recordType": "comparison",
  "dachEntityId": "giata:631077",
  "comparisonKey": "cce446e2b76518acd0ef51ca",
  "comparisonBasis": "lowest_offer_in_search_window",
  "hotel": {
    "giataId": 631077,
    "operatorHotelId": "146711",
    "name": "Ersoy Aga Otel",
    "category": 2,
    "location": {
      "city": "Antalya",
      "region": "Türkische Riviera",
      "country": "Türkei",
      "countryCode": "TR",
      "latitude": 36.89492416381836,
      "longitude": 30.703243255615234
    },
    "recommendationPercent": 0,
    "reviewCount": 1,
    "images": "(10 hotel images, shortened here)"
  },
  "travel": {
    "searchWindowStart": "2026-09-22",
    "searchWindowEnd": "2026-10-06"
  },
  "offers": [
    {
      "operator": "weg",
      "operatorLabel": "weg.de",
      "tourOperator": "TUI Deutschland XTUI",
      "price": {
        "total": {
          "amount": 593,
          "currency": "EUR"
        },
        "perPerson": {
          "amount": 296.5,
          "currency": "EUR"
        },
        "originalTotal": null,
        "originalPerPerson": null,
        "savingPercent": null,
        "taxesIncluded": null,
        "mandatoryFees": [],
        "completeness": "unknown"
      },
      "room": "Doppelzimmer MIT GEMEINSCHAFTSBAD",
      "board": "nur Übernachtung",
      "departureDate": "2026-09-22",
      "note": "full offer record embedded, shortened here"
    },
    {
      "operator": "aidu",
      "operatorLabel": "ab-in-den-urlaub.de",
      "tourOperator": null,
      "price": {
        "total": {
          "amount": 593,
          "currency": "EUR"
        },
        "perPerson": null,
        "originalTotal": {
          "amount": 874,
          "currency": "EUR"
        },
        "originalPerPerson": null,
        "savingPercent": 32.2,
        "taxesIncluded": null,
        "mandatoryFees": [],
        "completeness": "unknown"
      },
      "room": "Doppelzimmer MIT GEMEINSCHAFTSBAD",
      "board": "Ohne Verpflegung",
      "departureDate": "2026-09-22",
      "note": "full offer record embedded, shortened here"
    },
    {
      "operator": "tui",
      "operatorLabel": "TUI Germany",
      "tourOperator": null,
      "price": {
        "total": {
          "amount": 620,
          "currency": "EUR"
        },
        "perPerson": {
          "amount": 310,
          "currency": "EUR"
        },
        "originalTotal": {
          "amount": 1028,
          "currency": "EUR"
        },
        "originalPerPerson": {
          "amount": 514,
          "currency": "EUR"
        },
        "savingPercent": 39.7,
        "taxesIncluded": null,
        "mandatoryFees": [],
        "completeness": "unknown"
      },
      "room": "Doppelzimmer MIT GEMEINSCHAFTSBAD",
      "board": "Ohne Verpflegung",
      "departureDate": "2026-09-22",
      "note": "full offer record embedded, shortened here"
    }
  ],
  "cheapestOperator": "weg",
  "cheapestTotalPrice": 593,
  "currency": "EUR",
  "priceSpread": 27,
  "matchQuality": {
    "score": 0.92,
    "likeForLike": true,
    "dimensions": {
      "hotel": "exact",
      "departureDate": "exact",
      "nights": "exact",
      "occupancy": "exact",
      "departureAirport": "requested",
      "room": "normalized",
      "board": "normalized"
    },
    "unavailableDimensions": [],
    "mixedDimensions": []
  },
  "observedAt": "2026-07-28T21:01:00.765Z"
}
```

A full `offer` record, including both flight legs as sold. Price honesty is structural:
`originalTotal`, `savingPercent`, and `taxesIncluded` stay `null` when the portal does
not publish them, and `price.completeness` says so explicitly. Hotel reputation fields
are passed through as the source states them, even when they are unflattering (this
2-star property shows its single review and 0 percent recommendation as-is):

```json
{
  "recordType": "offer",
  "operator": "weg",
  "operatorLabel": "weg.de",
  "tourOperator": "TUI Deutschland",
  "dachEntityId": "giata:631077",
  "comparisonKey": "f163d8be2fe4ca58b775f695",
  "offerKey": "b810135dc704cd25e66d3f91",
  "operatorOfferId": "C1M5AUCQKBIFAUCQKBIFBDQV2CHBZEKMSWIVVXIX... (shortened here)",
  "hotel": {
    "giataId": 631077,
    "operatorHotelId": "146711",
    "name": "Ersoy Aga Otel",
    "category": 2,
    "location": {
      "city": "Antalya",
      "region": "Türkische Riviera",
      "country": "Türkei",
      "countryCode": "TR",
      "latitude": 36.89492416381836,
      "longitude": 30.703243255615234
    },
    "recommendationPercent": 0,
    "reviewCount": 1,
    "images": "(10 hotel images, shortened here)"
  },
  "travel": {
    "searchWindowStart": "2026-09-22",
    "searchWindowEnd": "2026-10-06",
    "departureDate": "2026-09-22",
    "returnDate": "2026-09-29",
    "nights": 7
  },
  "occupancy": {
    "adults": 2,
    "childAges": [
      8
    ]
  },
  "departureAirport": {
    "iata": "MUC",
    "requested": [
      "MUC"
    ],
    "source": "offer"
  },
  "room": {
    "name": "Familienzimmer KAPAZITÄT 3",
    "type": "FZ",
    "codes": [
      "FZ"
    ]
  },
  "board": {
    "name": "nur Übernachtung",
    "type": "Ü",
    "codes": [
      "Ü"
    ]
  },
  "flight": {
    "outbound": {
      "departureAirport": "MUC",
      "arrivalAirport": "AYT",
      "departureAt": "2026-09-22T18:50",
      "arrivalAt": "2026-09-22T22:55",
      "carrier": "SunExpress",
      "carrierCode": "XQ",
      "durationMinutes": 185,
      "direct": true
    },
    "inbound": {
      "departureAirport": "AYT",
      "arrivalAirport": "MUC",
      "departureAt": "2026-09-29T07:00",
      "arrivalAt": "2026-09-29T09:25",
      "carrier": "SunExpress",
      "carrierCode": "XQ",
      "durationMinutes": 205,
      "direct": true
    },
    "baggage": null
  },
  "transfer": {
    "included": true,
    "optionalPrice": null,
    "evidence": "source"
  },
  "availability": {
    "status": "unknown"
  },
  "cancellation": {
    "refundable": null,
    "description": "FLEXIBEL",
    "deadline": null,
    "deadlineDaysBeforeDeparture": null,
    "feeBands": [],
    "flexProduct": "flexibleOfferData",
    "evidence": "source"
  },
  "discounts": [
    {
      "type": "deal",
      "label": "weg.de special deal",
      "amount": null,
      "percent": null
    }
  ],
  "price": {
    "total": {
      "amount": 919,
      "currency": "EUR"
    },
    "perPerson": {
      "amount": 306.33,
      "currency": "EUR"
    },
    "originalTotal": null,
    "originalPerPerson": null,
    "savingPercent": null,
    "taxesIncluded": null,
    "mandatoryFees": [],
    "completeness": "unknown"
  },
  "source": {
    "url": "https://www.weg.de/hotel/ersoy-aga-otel-cid_146711?from=2026-09-22&to=2026-10-06&rooms=25%2C25%2C8&duration=7&sort=price&departureAirport=MUC&city=930",
    "observedAt": "2026-07-28T10:17:05.574Z",
    "destination": {
      "id": "930",
      "name": "Antalya",
      "type": "city",
      "parentName": "Türkische Riviera"
    }
  },
  "matching": {
    "departureDate": "exact",
    "nights": "exact",
    "occupancy": "exact",
    "departureAirport": "exact",
    "room": "normalized",
    "board": "normalized",
    "roomClass": "family",
    "boardClass": "room_only"
  }
}
```

The full input is in `examples/INPUT.json`, a recurring watch is in
`examples/SCHEDULED_WATCH.json`, and a normalized output sample is in
`examples/OUTPUT_OFFER.json`.

### Reliability and limits

- Each source has typed errors, bounded retries, health summaries, and circuit
  breaking.
- Airport matrix fan-out has explicit airport, concurrency, and request limits.
- Explicit source-airport fallbacks are discarded when they do not match any
  requested IATA code, and the mismatch is reported in run diagnostics.
- Price history is sharded, deduplicated, retained for 90 days by default, and
  stable across transient offer or flight identifiers.
- Capacity scoring requires repeated observations and is suppressed when source
  coverage drops. It estimates market availability, not hotel occupancy.
- Forecasts are informational signals, not price or booking guarantees.
- HTTPS webhooks support HMAC signatures, idempotency keys, cooldowns, bounded
  retries, redirect blocking, and target-URL redaction.
- `alertSigningSecret` is a top-level encrypted input and is mapped into the
  webhook runtime configuration without being emitted.
- Pay-per-event guardrails stop work and output before the caller's maximum
  charge is exceeded.

The Store input defaults to one stable German residential Apify Proxy session
because several sources bind browser cookies, CSRF tokens, or availability to
one network identity. Browser-backed fallbacks activate only when a direct
source response is blocked or empty. Source APIs and persisted-query hashes can
change; source-specific schema drift is reported without discarding successful
sources.

### Pricing

This Actor uses pay per event. The primary event is one normalized package
offer. Separate named events transparently account for successful source
searches and optional comparisons, history, matrices, signals, forecasts,
enrichment, and alert delivery. Failed source searches, failed webhooks,
cooldown-suppressed alerts, and duplicate history observations are not charged
as successful events.

The Store headline shows the primary package-offer price; a five-source run can
also charge up to five successful-source-search events. Review the full Pricing
tab, set a maximum cost per run, and inspect `OUTPUT.billing` before increasing
result or airport-matrix limits. Platform usage is currently included in the
Store price, as shown on the public Pricing tab.

This Actor is also exposed to AI agents through Apify's MCP server
(mcp.apify.com): an agent can discover it by search and run it with the same
pay-per-event billing, with no separate integration.

### Privacy and lawful use

The Actor does not require traveller names, email addresses, payment details,
or booking personal data. Child ages are optional search parameters. Webhook
URLs and signing secrets remain within the caller's input and storage.

Users are responsible for lawful, proportionate use and compliance with
applicable website terms, robots policies, database rights, privacy law, and
contractual restrictions. Do not use the Actor to bypass access controls or
overload source systems.

### Support and versioning

For reproducible schema drift or source failures, include the run ID, redacted
input, affected source, and first error code. Target initial response is within
two business days. Upstream website changes are supported on a best-effort
basis unless a separate SLA exists.

Breaking output changes use a major version; additive fields use a minor
version; source fixes use a patch version. See `CHANGELOG.md` for release
history.

### Local development

Node.js 22.19 or newer is required.

```bash
npm install
npm run release:preflight
npm run release:live
```

For a local Apify run, place input at
`storage/key_value_stores/default/INPUT.json`, then run:

```bash
CRAWLEE_STORAGE_DIR="$PWD/storage" npm start
```

# Actor input Schema

## `destination` (type: `string`):

Country, region, or city, for example Antalya, Türkische Riviera, Mallorca, or Hurghada.

## `startDate` (type: `string`):

Beginning of the departure search window. Use YYYY-MM-DD or a relative value such as 8 weeks.

## `endDate` (type: `string`):

End of the departure search window. Use YYYY-MM-DD or a relative value such as 10 weeks.

## `nights` (type: `integer`):

Requested trip duration.

## `adults` (type: `integer`):

Number of adult travellers.

## `childAges` (type: `array`):

Age of each child on departure. Leave empty when travelling without children.

## `departureAirports` (type: `array`):

Three-letter IATA codes, for example DUS, MUC, FRA. Offers that explicitly return a different airport are discarded and reported as a source-contract error.

## `operators` (type: `array`):

Sources to query. Each selected source that completes a search bills one successful-source-search event ($0.015), so a five-source run can charge up to five of them plus $0.001 per normalized offer row; failed source searches are not charged.

## `outputMode` (type: `string`):

Offers returns one row per source offer. Comparisons returns one row per GIATA hotel with the cheapest offer of every source side by side, including matchQuality that declares per dimension what was matched exactly and what was normalized.

## `comparisonMode` (type: `string`):

Compare each source's cheapest offer for a hotel, or only packages with matching dates, duration, occupancy, airport, room class, and board class.

## `maxResultsPerOperator` (type: `integer`):

Caps the number of normalized offers emitted by each selected operator.

## `sort` (type: `string`):

Requests price ordering or the source's recommendation ordering.

## `includeRaw` (type: `boolean`):

Useful for debugging but increases dataset size.

## `history` (type: `object`):

Persist deduplicated observations and optionally emit 90-day price series.

## `enrichment` (type: `object`):

Optionally visit a bounded number of source offer pages to fill evidence-backed baggage, transfer, and flexible-cancellation fields. Successful lookups are cached.

## `airportMatrix` (type: `object`):

Fan out one search per airport and emit comparable package prices by departure point.

## `signals` (type: `object`):

Calculate explainable availability-narrowing and price-jump signals from stored observations.

## `forecast` (type: `object`):

Generate an explainable informational recommendation from price trend, volatility, departure timing, and capacity signals.

## `reliability` (type: `object`):

Per-source circuit breaker settings for repeated failures.

## `alerts` (type: `object`):

Send idempotent, cooldown-controlled price, capacity, and source-recovery notifications.

## `alertSigningSecret` (type: `string`):

Optional encrypted HMAC secret used to sign every webhook payload with SHA-256.

## `destinationOverrides` (type: `object`):

Optional source-specific IDs. Use only when automatic destination resolution is ambiguous.

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

Optional Apify Proxy configuration for higher-volume runs.

## Actor input object example

```json
{
  "destination": "Antalya",
  "startDate": "8 weeks",
  "endDate": "10 weeks",
  "nights": 7,
  "adults": 2,
  "childAges": [],
  "departureAirports": [
    "DUS"
  ],
  "operators": [
    "tui",
    "dertour",
    "weg",
    "aidu",
    "alltours"
  ],
  "outputMode": "offers",
  "comparisonMode": "lowest_offer_in_search_window",
  "maxResultsPerOperator": 20,
  "sort": "priceAsc",
  "includeRaw": false,
  "history": {
    "enabled": false,
    "storeName": "package-price-history",
    "retentionDays": 90,
    "observationIntervalHours": 24,
    "emitSeries": true
  },
  "enrichment": {
    "enabled": false,
    "storeName": "package-offer-enrichment",
    "ttlHours": 6,
    "maxOffersPerSource": 3
  },
  "airportMatrix": {
    "enabled": false,
    "maxAirports": 8,
    "concurrency": 3,
    "requestBudget": 50,
    "emitRows": true
  },
  "signals": {
    "enabled": false,
    "minimumSnapshots": 3,
    "evidenceWindowDays": 14,
    "emitRows": true
  },
  "forecast": {
    "enabled": false,
    "minimumObservations": 7,
    "horizonDays": 7,
    "emitRows": true
  },
  "reliability": {
    "circuitFailureThreshold": 3,
    "circuitCooldownSeconds": 120
  },
  "alerts": {
    "enabled": false,
    "webhookUrls": [],
    "types": [
      "price_drop",
      "price_rise",
      "availability_narrowing",
      "source_recovery"
    ],
    "priceChangePercent": 5,
    "capacityScore": 50,
    "cooldownHours": 24,
    "maxAlertsPerRun": 20,
    "emitRows": true
  },
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "countryCode": "DE"
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Default dataset containing offers, comparisons, airport matrices, price series, signals, forecasts, and alert delivery records selected by the input.

## `runSummary` (type: `string`):

Run status, counts, source health, data quality, errors, feature summaries, telemetry, and billing operations.

# 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 = {
    "destination": "Antalya",
    "startDate": "8 weeks",
    "endDate": "10 weeks",
    "departureAirports": [
        "DUS"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("kamerozkan/dach-package-holiday-price-api").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 = {
    "destination": "Antalya",
    "startDate": "8 weeks",
    "endDate": "10 weeks",
    "departureAirports": ["DUS"],
}

# Run the Actor and wait for it to finish
run = client.actor("kamerozkan/dach-package-holiday-price-api").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 '{
  "destination": "Antalya",
  "startDate": "8 weeks",
  "endDate": "10 weeks",
  "departureAirports": [
    "DUS"
  ]
}' |
apify call kamerozkan/dach-package-holiday-price-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=kamerozkan/dach-package-holiday-price-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Package Holiday Price Comparison - Pauschalreise, TUI, DERTOUR",
        "description": "Compare Pauschalreise offers & package holiday prices across five German travel sources - TUI, DERTOUR, weg.de, ab-in-den-urlaub.de and alltours - in one normalized dataset. GIATA hotel matching, departure airport comparison, 90-day price history & buy-or-wait signals. Pauschalreisen price API.",
        "version": "1.0",
        "x-build-id": "i1gS5FETa8RhJv4Vr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/kamerozkan~dach-package-holiday-price-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-kamerozkan-dach-package-holiday-price-api",
                "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/kamerozkan~dach-package-holiday-price-api/runs": {
            "post": {
                "operationId": "runs-sync-kamerozkan-dach-package-holiday-price-api",
                "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/kamerozkan~dach-package-holiday-price-api/run-sync": {
            "post": {
                "operationId": "run-sync-kamerozkan-dach-package-holiday-price-api",
                "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": [
                    "destination",
                    "startDate",
                    "endDate",
                    "departureAirports"
                ],
                "properties": {
                    "destination": {
                        "title": "Destination",
                        "minLength": 2,
                        "maxLength": 120,
                        "type": "string",
                        "description": "Country, region, or city, for example Antalya, Türkische Riviera, Mallorca, or Hurghada.",
                        "default": "Antalya"
                    },
                    "startDate": {
                        "title": "Earliest departure",
                        "pattern": "^(?:\\d{4}-\\d{2}-\\d{2}|\\d+\\s*(?:day|week|month|year)s?)$",
                        "type": "string",
                        "description": "Beginning of the departure search window. Use YYYY-MM-DD or a relative value such as 8 weeks."
                    },
                    "endDate": {
                        "title": "Latest departure",
                        "pattern": "^(?:\\d{4}-\\d{2}-\\d{2}|\\d+\\s*(?:day|week|month|year)s?)$",
                        "type": "string",
                        "description": "End of the departure search window. Use YYYY-MM-DD or a relative value such as 10 weeks."
                    },
                    "nights": {
                        "title": "Nights",
                        "minimum": 1,
                        "maximum": 42,
                        "type": "integer",
                        "description": "Requested trip duration.",
                        "default": 7
                    },
                    "adults": {
                        "title": "Adults",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of adult travellers.",
                        "default": 2
                    },
                    "childAges": {
                        "title": "Children's ages",
                        "maxItems": 8,
                        "type": "array",
                        "description": "Age of each child on departure. Leave empty when travelling without children.",
                        "items": {
                            "type": "integer",
                            "minimum": 0,
                            "maximum": 17
                        },
                        "default": []
                    },
                    "departureAirports": {
                        "title": "Departure airports",
                        "minItems": 1,
                        "maxItems": 20,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Three-letter IATA codes, for example DUS, MUC, FRA. Offers that explicitly return a different airport are discarded and reported as a source-contract error.",
                        "items": {
                            "type": "string",
                            "pattern": "^[A-Za-z]{3}$"
                        },
                        "default": [
                            "DUS"
                        ]
                    },
                    "operators": {
                        "title": "Operators",
                        "minItems": 1,
                        "maxItems": 5,
                        "uniqueItems": true,
                        "type": "array",
                        "description": "Sources to query. Each selected source that completes a search bills one successful-source-search event ($0.015), so a five-source run can charge up to five of them plus $0.001 per normalized offer row; failed source searches are not charged.",
                        "items": {
                            "type": "string",
                            "enum": [
                                "tui",
                                "dertour",
                                "weg",
                                "aidu",
                                "alltours"
                            ],
                            "enumTitles": [
                                "TUI Germany",
                                "DERTOUR Germany",
                                "weg.de",
                                "ab-in-den-urlaub.de",
                                "alltours"
                            ]
                        },
                        "default": [
                            "tui",
                            "dertour",
                            "weg",
                            "aidu",
                            "alltours"
                        ]
                    },
                    "outputMode": {
                        "title": "Output mode",
                        "enum": [
                            "offers",
                            "comparisons"
                        ],
                        "type": "string",
                        "description": "Offers returns one row per source offer. Comparisons returns one row per GIATA hotel with the cheapest offer of every source side by side, including matchQuality that declares per dimension what was matched exactly and what was normalized.",
                        "default": "offers"
                    },
                    "comparisonMode": {
                        "title": "Comparison basis",
                        "enum": [
                            "lowest_offer_in_search_window",
                            "like_for_like_package"
                        ],
                        "type": "string",
                        "description": "Compare each source's cheapest offer for a hotel, or only packages with matching dates, duration, occupancy, airport, room class, and board class.",
                        "default": "lowest_offer_in_search_window"
                    },
                    "maxResultsPerOperator": {
                        "title": "Maximum results per operator",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Caps the number of normalized offers emitted by each selected operator.",
                        "default": 20
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "priceAsc",
                            "recommended"
                        ],
                        "type": "string",
                        "description": "Requests price ordering or the source's recommendation ordering.",
                        "default": "priceAsc"
                    },
                    "includeRaw": {
                        "title": "Include raw source records",
                        "type": "boolean",
                        "description": "Useful for debugging but increases dataset size.",
                        "default": false
                    },
                    "history": {
                        "title": "Price history",
                        "type": "object",
                        "description": "Persist deduplicated observations and optionally emit 90-day price series.",
                        "properties": {
                            "enabled": {
                                "title": "Enable history",
                                "description": "Persist deduplicated observations in the selected store.",
                                "type": "boolean",
                                "default": false
                            },
                            "storeName": {
                                "title": "Key-value store name",
                                "description": "Named store containing sharded history and derived state.",
                                "type": "string",
                                "default": "package-price-history",
                                "pattern": "^[a-z0-9][a-z0-9-]*[a-z0-9]$",
                                "minLength": 3,
                                "maxLength": 63
                            },
                            "retentionDays": {
                                "title": "Retention days",
                                "description": "Delete observations older than this rolling window.",
                                "type": "integer",
                                "default": 90,
                                "minimum": 7,
                                "maximum": 365
                            },
                            "observationIntervalHours": {
                                "title": "Deduplication interval (hours)",
                                "description": "Keep at most one observation per exact offer and time bucket.",
                                "type": "integer",
                                "default": 24,
                                "minimum": 1,
                                "maximum": 24
                            },
                            "emitSeries": {
                                "title": "Emit price series",
                                "description": "Write updated series records to the default dataset.",
                                "type": "boolean",
                                "default": true
                            }
                        },
                        "default": {
                            "enabled": false,
                            "storeName": "package-price-history",
                            "retentionDays": 90,
                            "observationIntervalHours": 24,
                            "emitSeries": true
                        },
                        "additionalProperties": false
                    },
                    "enrichment": {
                        "title": "Offer detail enrichment",
                        "type": "object",
                        "description": "Optionally visit a bounded number of source offer pages to fill evidence-backed baggage, transfer, and flexible-cancellation fields. Successful lookups are cached.",
                        "properties": {
                            "enabled": {
                                "title": "Enable enrichment",
                                "description": "Visit detail pages when list responses omit useful package inclusions.",
                                "type": "boolean",
                                "default": false
                            },
                            "storeName": {
                                "title": "Enrichment cache store",
                                "description": "Named key-value store used for bounded detail-response caching.",
                                "type": "string",
                                "default": "package-offer-enrichment",
                                "pattern": "^[a-z0-9][a-z0-9-]*[a-z0-9]$",
                                "minLength": 3,
                                "maxLength": 63
                            },
                            "ttlHours": {
                                "title": "Cache lifetime (hours)",
                                "description": "How long verified detail evidence may be reused.",
                                "type": "integer",
                                "default": 6,
                                "minimum": 1,
                                "maximum": 72
                            },
                            "maxOffersPerSource": {
                                "title": "Maximum enriched offers per source",
                                "description": "Hard per-search cap on detail-page lookups.",
                                "type": "integer",
                                "default": 3,
                                "minimum": 1,
                                "maximum": 10
                            }
                        },
                        "default": {
                            "enabled": false,
                            "storeName": "package-offer-enrichment",
                            "ttlHours": 6,
                            "maxOffersPerSource": 3
                        },
                        "additionalProperties": false
                    },
                    "airportMatrix": {
                        "title": "Departure-airport matrix",
                        "type": "object",
                        "description": "Fan out one search per airport and emit comparable package prices by departure point.",
                        "properties": {
                            "enabled": {
                                "title": "Enable airport matrix",
                                "description": "Run one isolated search per requested departure airport.",
                                "type": "boolean",
                                "default": false
                            },
                            "maxAirports": {
                                "title": "Maximum airports",
                                "description": "Reject matrix inputs exceeding this number of airports.",
                                "type": "integer",
                                "default": 8,
                                "minimum": 1,
                                "maximum": 20
                            },
                            "concurrency": {
                                "title": "Concurrent searches",
                                "description": "Maximum parallel source searches; capped for browser memory safety.",
                                "type": "integer",
                                "default": 3,
                                "minimum": 1,
                                "maximum": 4
                            },
                            "requestBudget": {
                                "title": "Maximum source searches",
                                "description": "Hard limit on operator and airport search combinations.",
                                "type": "integer",
                                "default": 50,
                                "minimum": 1,
                                "maximum": 500
                            },
                            "emitRows": {
                                "title": "Emit matrix records",
                                "description": "Write airport-matrix records to the default dataset.",
                                "type": "boolean",
                                "default": true
                            }
                        },
                        "default": {
                            "enabled": false,
                            "maxAirports": 8,
                            "concurrency": 3,
                            "requestBudget": 50,
                            "emitRows": true
                        },
                        "additionalProperties": false
                    },
                    "signals": {
                        "title": "Capacity and price signals",
                        "type": "object",
                        "description": "Calculate explainable availability-narrowing and price-jump signals from stored observations.",
                        "properties": {
                            "enabled": {
                                "title": "Enable signals",
                                "description": "Calculate price and availability-narrowing signals from history.",
                                "type": "boolean",
                                "default": false
                            },
                            "minimumSnapshots": {
                                "title": "Minimum snapshots",
                                "description": "Minimum distinct time buckets required before scoring.",
                                "type": "integer",
                                "default": 3,
                                "minimum": 3,
                                "maximum": 30
                            },
                            "evidenceWindowDays": {
                                "title": "Evidence window (days)",
                                "description": "Rolling observation window used to calculate signals.",
                                "type": "integer",
                                "default": 14,
                                "minimum": 3,
                                "maximum": 90
                            },
                            "emitRows": {
                                "title": "Emit signal records",
                                "description": "Write market-signal records to the default dataset.",
                                "type": "boolean",
                                "default": true
                            }
                        },
                        "default": {
                            "enabled": false,
                            "minimumSnapshots": 3,
                            "evidenceWindowDays": 14,
                            "emitRows": true
                        },
                        "additionalProperties": false
                    },
                    "forecast": {
                        "title": "Buy/wait forecast",
                        "type": "object",
                        "description": "Generate an explainable informational recommendation from price trend, volatility, departure timing, and capacity signals.",
                        "properties": {
                            "enabled": {
                                "title": "Enable forecast",
                                "description": "Generate informational buy, wait, or neutral recommendations.",
                                "type": "boolean",
                                "default": false
                            },
                            "minimumObservations": {
                                "title": "Minimum observations",
                                "description": "Minimum series length required for a directional forecast.",
                                "type": "integer",
                                "default": 7,
                                "minimum": 3,
                                "maximum": 60
                            },
                            "horizonDays": {
                                "title": "Forecast horizon (days)",
                                "description": "Number of future days covered by the trend estimate.",
                                "type": "integer",
                                "default": 7,
                                "minimum": 1,
                                "maximum": 30
                            },
                            "emitRows": {
                                "title": "Emit forecast records",
                                "description": "Write forecast records to the default dataset.",
                                "type": "boolean",
                                "default": true
                            }
                        },
                        "default": {
                            "enabled": false,
                            "minimumObservations": 7,
                            "horizonDays": 7,
                            "emitRows": true
                        },
                        "additionalProperties": false
                    },
                    "reliability": {
                        "title": "Reliability controls",
                        "type": "object",
                        "description": "Per-source circuit breaker settings for repeated failures.",
                        "properties": {
                            "circuitFailureThreshold": {
                                "title": "Failures before opening circuit",
                                "description": "Consecutive failures required to pause one source.",
                                "type": "integer",
                                "default": 3,
                                "minimum": 1,
                                "maximum": 20
                            },
                            "circuitCooldownSeconds": {
                                "title": "Circuit cooldown (seconds)",
                                "description": "Wait time before a paused source may be tried again.",
                                "type": "integer",
                                "default": 120,
                                "minimum": 10,
                                "maximum": 3600
                            }
                        },
                        "default": {
                            "circuitFailureThreshold": 3,
                            "circuitCooldownSeconds": 120
                        },
                        "additionalProperties": false
                    },
                    "alerts": {
                        "title": "Webhook alerts",
                        "type": "object",
                        "description": "Send idempotent, cooldown-controlled price, capacity, and source-recovery notifications.",
                        "properties": {
                            "enabled": {
                                "title": "Enable alerts",
                                "description": "Send selected events to the configured webhook targets.",
                                "type": "boolean",
                                "default": false
                            },
                            "webhookUrls": {
                                "title": "Webhook URLs",
                                "description": "Up to five HTTPS endpoints that receive signed JSON payloads.",
                                "type": "array",
                                "editor": "stringList",
                                "default": [],
                                "maxItems": 5,
                                "uniqueItems": true,
                                "items": {
                                    "type": "string",
                                    "pattern": "^https://"
                                }
                            },
                            "types": {
                                "title": "Alert types",
                                "description": "Events eligible for webhook delivery.",
                                "type": "array",
                                "editor": "select",
                                "default": [
                                    "price_drop",
                                    "price_rise",
                                    "availability_narrowing",
                                    "source_recovery"
                                ],
                                "maxItems": 4,
                                "uniqueItems": true,
                                "items": {
                                    "type": "string",
                                    "enum": [
                                        "price_drop",
                                        "price_rise",
                                        "availability_narrowing",
                                        "source_recovery"
                                    ],
                                    "enumTitles": [
                                        "Price drop",
                                        "Price rise",
                                        "Availability narrowing",
                                        "Source recovery"
                                    ]
                                }
                            },
                            "priceChangePercent": {
                                "title": "Price-change threshold (%)",
                                "description": "Minimum absolute price movement required for an alert.",
                                "type": "number",
                                "default": 5,
                                "minimum": 0.1,
                                "maximum": 100
                            },
                            "capacityScore": {
                                "title": "Capacity-score threshold",
                                "description": "Minimum availability-narrowing score required for an alert.",
                                "type": "number",
                                "default": 50,
                                "minimum": 1,
                                "maximum": 100
                            },
                            "cooldownHours": {
                                "title": "Alert cooldown (hours)",
                                "description": "Suppress repeated alerts for the same subject and target.",
                                "type": "integer",
                                "default": 24,
                                "minimum": 1,
                                "maximum": 720
                            },
                            "maxAlertsPerRun": {
                                "title": "Maximum alert candidates per run",
                                "description": "Hard safety cap before multiplying candidates by webhook targets.",
                                "type": "integer",
                                "default": 20,
                                "minimum": 1,
                                "maximum": 100
                            },
                            "emitRows": {
                                "title": "Emit alert delivery rows",
                                "description": "Write redacted delivery outcomes to the default dataset.",
                                "type": "boolean",
                                "default": true
                            }
                        },
                        "default": {
                            "enabled": false,
                            "webhookUrls": [],
                            "types": [
                                "price_drop",
                                "price_rise",
                                "availability_narrowing",
                                "source_recovery"
                            ],
                            "priceChangePercent": 5,
                            "capacityScore": 50,
                            "cooldownHours": 24,
                            "maxAlertsPerRun": 20,
                            "emitRows": true
                        },
                        "additionalProperties": false
                    },
                    "alertSigningSecret": {
                        "title": "Alert signing secret",
                        "type": "string",
                        "description": "Optional encrypted HMAC secret used to sign every webhook payload with SHA-256."
                    },
                    "destinationOverrides": {
                        "title": "Advanced destination IDs",
                        "type": "object",
                        "description": "Optional source-specific IDs. Use only when automatic destination resolution is ambiguous.",
                        "properties": {
                            "tuiId": {
                                "title": "TUI destination ID",
                                "type": "integer",
                                "description": "Numeric TUI GIATA city or region ID."
                            },
                            "tuiType": {
                                "title": "TUI destination type",
                                "type": "string",
                                "description": "Whether the TUI ID represents a city or region.",
                                "enum": [
                                    "city",
                                    "region"
                                ]
                            },
                            "dertourId": {
                                "title": "DERTOUR destination ID",
                                "type": "string",
                                "description": "DERTOUR geo ID returned by its destination service."
                            },
                            "wegId": {
                                "title": "weg.de destination ID",
                                "type": "string",
                                "description": "weg.de city, region, or country ID returned by its destination service."
                            },
                            "wegType": {
                                "title": "weg.de destination type",
                                "type": "string",
                                "description": "Whether the weg.de ID represents a city, region, or country.",
                                "enum": [
                                    "city",
                                    "region",
                                    "country"
                                ]
                            },
                            "aiduId": {
                                "title": "ab-in-den-urlaub.de destination ID",
                                "type": "string",
                                "description": "Destination ID returned by the ab-in-den-urlaub.de autocomplete service."
                            },
                            "aiduType": {
                                "title": "ab-in-den-urlaub.de destination type",
                                "type": "string",
                                "description": "Whether the destination ID represents a city, region, or country.",
                                "enum": [
                                    "city",
                                    "region",
                                    "country"
                                ]
                            },
                            "alltoursId": {
                                "title": "alltours destination ID",
                                "type": "string",
                                "description": "Node ID returned by the alltours destination tree."
                            },
                            "alltoursType": {
                                "title": "alltours destination type",
                                "type": "string",
                                "description": "Whether the alltours node represents a city, region, or country.",
                                "enum": [
                                    "city",
                                    "region",
                                    "country"
                                ]
                            }
                        },
                        "additionalProperties": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy configuration for higher-volume runs.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "countryCode": "DE"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
