# CruiseMapper Cruises Scraper (`crawlerbros/cruisemapper-cruises-scraper`) Actor

Search CruiseMapper.com for cruise itineraries by destination, ship, cruise line, departure port, length, and date. Returns ship name, dates, route, duration, and starting price per cruise.

- **URL**: https://apify.com/crawlerbros/cruisemapper-cruises-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Travel, Automation, Developer tools
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 8 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## CruiseMapper Cruises Scraper

Search [CruiseMapper.com](https://www.cruisemapper.com) — the largest free public cruise database — by destination, ship, cruise line, length, type, and date. Returns one structured record per cruise with departure date, ship, duration, route, title, and starting price. HTTP-only — no proxy, no cookies, no API key.

### What it does

You set any combination of filters; the actor:

1. Submits the search to `cruisemapper.com/cruise-search` with your filters mapped to the site's form params.
2. Walks paginated result pages (15 cruises per page) until `maxResults` is reached.
3. Parses each result row into a flat record with date, ship, duration, route type, title, price, and ship-detail URL.
4. Optionally narrows results by an `endDate` upper bound and `cruiseLength` bucket (client-side validation).

Empty fields are omitted (no nulls). Cruises without a published price still emit a record with `priceFrom`/`currency` absent.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `departureFrom` | string | – | Earliest cruise departure date `YYYY-MM-DD`. Empty = no lower bound. |
| `endDate` | string | – | Latest cruise departure date `YYYY-MM-DD`. Empty = no upper bound. Client-side filter. |
| `cruiseLength` | enum | `any` | One of `any`, `1-2`, `3-5`, `6-10`, `11-14`, `15+`. |
| `destination` | enum | `any` | Cruise region (e.g. `alaska`, `mediterranean-black-sea`, `bahamas-caribbean-bermuda`, `nile-river`, `arctic-antarctica`, `asia`). 24 regions supported. |
| `cruiseType` | enum | `any` | Theme / category (e.g. `transatlantic`, `christmas`, `food-wine`, `northern-lights`, `panama-canal`, `world`). 25 types supported. |
| `shipName` | string | – | Substring match against the ship name (e.g. `Symphony of the Seas`). |
| `cruiseLine` | string | – | Filter by cruise line (e.g. `Royal Caribbean`, `Carnival`). |
| `departurePort` | string | – | Filter by embarkation port (e.g. `Miami`, `Barcelona`). |
| `portOfCall` | string | – | Filter by intermediate port-of-call (e.g. `Cozumel`). |
| `maxPrice` | integer | `10000` (100–100000) | Drop cruises with starting price above this USD amount. |
| `maxResults` | integer | `50` (1–500) | Hard cap on records emitted across all pages. |
| `enrichWithShipData` | boolean | `false` | When true, fetch the ship-detail page for each unique ship and add a `shipDetails` block (year built, builder, gross tonnage, passenger capacity, length, decks, cabins). Adds ~1 extra HTTP request per unique ship. |
| `startUrls` | array of strings | `[]` | Paste full CruiseMapper search URLs (e.g. `https://www.cruisemapper.com/cruise-search?finder=cruise&portRegion=22`). Each URL's query params become a search; results merge + dedup with the main filter inputs. |
| `pageConcurrency` | integer | `1` (1–10) | Number of pages to fetch in parallel per query. Higher values speed up bulk runs; may trigger rate-limits. |

#### Example input

```json
{
  "departureFrom": "2026-06-01",
  "endDate": "2026-09-30",
  "cruiseLength": "6-10",
  "destination": "alaska",
  "cruiseType": "any",
  "maxResults": 100
}
````

### Output

One record per cruise. Empty fields are omitted (no nulls).

```json
{
  "departureDate": "2026-06-15",
  "departureDateText": "2026 Jun 15",
  "daysUntilDeparture": 14,
  "shipName": "AmaLilia",
  "shipUrl": "https://www.cruisemapper.com/ships/AmaLilia-1340",
  "duration": 11,
  "routeType": "round-trip",
  "title": "Secrets of Egypt the Nile",
  "priceFrom": 6334,
  "currency": "USD",
  "shipDetails": {
    "yearBuilt": 2024,
    "builder": "Maasara Shipyard (Cairo, Egypt)",
    "shipClass": "Nile River cruiser",
    "speed": "9 kn / 17 km/h / 10 mph",
    "lengthMeters": 72,
    "beamMeters": 13,
    "passengerCapacity": 68,
    "crewCount": 62,
    "deckCount": 5,
    "cabinCount": 34
  },
  "scrapedAt": "2024-12-16T14:23:11+00:00"
}
```

#### Output fields

- **`departureDate`** — ISO date `YYYY-MM-DD` of departure (parsed from the table's free-form text).
- **`departureDateText`** — original date string from the page (e.g. `"2026 Apr 27"`) — useful for QA / verification.
- **`daysUntilDeparture`** — derived integer: days from now (UTC) to `departureDate`. Negative for departures in the past.
- **`shipName`** — vessel name as listed by CruiseMapper.
- **`shipUrl`** — direct link to the ship's CruiseMapper detail page (deck plans, photos, cabin info).
- **`duration`** — cruise length in days (parsed from `"N days, ..."`).
- **`routeType`** — `round-trip`, `one-way`, `open-jaw`, or `transatlantic` when present in the title prefix.
- **`title`** — cruise itinerary title (e.g. `"Secrets of Egypt the Nile"`, `"Western Caribbean"`).
- **`priceFrom`** — starting USD price as integer; absent when CruiseMapper doesn't publish a price for the cruise.
- **`currency`** — `USD` / `EUR` / `GBP`; absent when `priceFrom` is absent.
- **`shipDetails`** — (only when `enrichWithShipData: true`) flat dict with `yearBuilt`, `builder`, `shipClass`, `flagState`, `speed`, `lengthMeters`, `beamMeters`, `draftMeters`, `grossTonnage`, `passengerCapacity`, `crewCount`, `deckCount`, `cabinCount`, `decksWithCabins`, `engines`, etc. Each ship is fetched once per run and cached.
- **`scrapedAt`** — ISO-8601 UTC timestamp.

### Use cases

- **Travel-planning aggregation** — feed your travel app with fresh CruiseMapper inventory.
- **Price-monitoring** — track starting-price trends for specific ships / cruise lines / destinations over time.
- **Competitive research** — see what competitors are pricing for the same routes.
- **Content / editorial** — generate weekly "Cruises departing this month from Miami" digests.
- **Inventory enrichment** — combine with a cruise-line site scraper to triangulate pricing across sources.

### FAQ

**Does it need a proxy or cookies?**
No. CruiseMapper search results are public and the actor connects directly with a Chrome-impersonated TLS fingerprint.

**Why is `priceFrom` missing on some records?**
Roughly 30–40% of CruiseMapper listings don't publish a starting price (they require contacting the cruise line). The actor follows an omit-empty contract — fields not present on the source are simply absent from the record (no nulls).

**Are the date / duration filters server-side or client-side?**
Mixed. `departureFrom`, `cruiseLength`, `destination`, `cruiseType`, `shipName`, `cruiseLine`, `departurePort`, `portOfCall`, and `maxPrice` are submitted as form params (server-side). `endDate` and the duration-bucket boundary check are applied client-side after parsing each result row, since CruiseMapper's form has no end-date field.

**How many results can I get in one run?**
Up to `maxResults` (max 500). CruiseMapper paginates ~15 cruises per page; 500 records ≈ 34 pages × ~1.5s = under a minute on a clean run.

**Can I scrape ship-detail pages too?**
This actor focuses on the search results table. Use the `shipUrl` field with a downstream actor (or a follow-up run) for ship deck plans, cabin layouts, and photos.

**What if my filters return zero cruises?**
You get a single sentinel record `{type: "cruisemapper_scraper_error", reason: "no_results"}`. The run still completes successfully — empty datasets aren't treated as failures.

**Why is the route type sometimes empty?**
CruiseMapper only embeds `round-trip`/`one-way`/`open-jaw`/`transatlantic` in the title for ~70% of cruises. When the title doesn't start with a known route-type prefix, the field is omitted.

# Actor input Schema

## `departureFrom` (type: `string`):

Earliest cruise departure date (`YYYY-MM-DD`). Cruises before this date are dropped. Optional.

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

Latest cruise departure date (`YYYY-MM-DD`). Cruises after this date are dropped (filtered after fetch). Optional.

## `cruiseLength` (type: `string`):

Trip duration in days.

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

Cruise destination region (matches CruiseMapper's port-region taxonomy).

## `cruiseType` (type: `string`):

Cruise theme / category (e.g. transatlantic, christmas, food-wine).

## `shipName` (type: `string`):

Filter by ship name (substring match, e.g. `Symphony of the Seas`).

## `cruiseLine` (type: `string`):

Filter by cruise line (e.g. `Royal Caribbean`, `Carnival`).

## `departurePort` (type: `string`):

Filter by embarkation port (e.g. `Miami`, `Barcelona`).

## `portOfCall` (type: `string`):

Filter by intermediate port-of-call (e.g. `Cozumel`).

## `maxPrice` (type: `integer`):

Drop cruises whose starting price exceeds this amount. Default = 10000.

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

Hard cap on cruises emitted across all pages.

## `enrichWithShipData` (type: `boolean`):

When true, fetch the ship-detail page for each unique ship and add a `shipDetails` block (year built, builder, gross tonnage, passenger capacity, length, decks, cabins, etc.). Adds ~1 extra HTTP request per unique ship.

## `startUrls` (type: `array`):

Paste full CruiseMapper search URLs (e.g. `https://www.cruisemapper.com/cruise-search?finder=cruise&portRegion=22&duration=3`). Each URL's query params become a search; results are merged and deduped with the main filter inputs.

## `pageConcurrency` (type: `integer`):

Number of pages to fetch in parallel per query. Higher values speed up bulk runs but may trigger rate-limits.

## Actor input object example

```json
{
  "cruiseLength": "any",
  "destination": "any",
  "cruiseType": "any",
  "maxPrice": 10000,
  "maxResults": 50,
  "enrichWithShipData": false,
  "startUrls": [],
  "pageConcurrency": 1
}
```

# 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 = {
    "departureFrom": "",
    "endDate": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/cruisemapper-cruises-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "departureFrom": "",
    "endDate": "",
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/cruisemapper-cruises-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "departureFrom": "",
  "endDate": ""
}' |
apify call crawlerbros/cruisemapper-cruises-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CruiseMapper Cruises Scraper",
        "description": "Search CruiseMapper.com for cruise itineraries by destination, ship, cruise line, departure port, length, and date. Returns ship name, dates, route, duration, and starting price per cruise.",
        "version": "0.1",
        "x-build-id": "U9fb5OrYu3X3tcDoT"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~cruisemapper-cruises-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-cruisemapper-cruises-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~cruisemapper-cruises-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-cruisemapper-cruises-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~cruisemapper-cruises-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-cruisemapper-cruises-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "departureFrom": {
                        "title": "Earliest departure date",
                        "type": "string",
                        "description": "Earliest cruise departure date (`YYYY-MM-DD`). Cruises before this date are dropped. Optional."
                    },
                    "endDate": {
                        "title": "Latest departure date (client-side filter)",
                        "type": "string",
                        "description": "Latest cruise departure date (`YYYY-MM-DD`). Cruises after this date are dropped (filtered after fetch). Optional."
                    },
                    "cruiseLength": {
                        "title": "Cruise length",
                        "enum": [
                            "any",
                            "1-2",
                            "3-5",
                            "6-10",
                            "11-14",
                            "15+"
                        ],
                        "type": "string",
                        "description": "Trip duration in days.",
                        "default": "any"
                    },
                    "destination": {
                        "title": "Destination region",
                        "enum": [
                            "any",
                            "alaska",
                            "amazon-river",
                            "arctic-antarctica",
                            "asia",
                            "asia-rivers",
                            "australia-new-zealand-pacific",
                            "bahamas-caribbean-bermuda",
                            "baltic-norwegian-fjords-russia",
                            "canada-usa-rivers",
                            "east-coast-usa-canada",
                            "europe-rivers",
                            "africa-indian-ocean",
                            "france-rivers",
                            "galapagos-islands",
                            "hawaii-mexico-panama",
                            "iceland-greenland-faroe",
                            "ireland-uk-british-isles",
                            "mediterranean-black-sea",
                            "nile-river",
                            "russia-rivers",
                            "south-america",
                            "west-coast-usa-canada",
                            "western-europe-azores-canary"
                        ],
                        "type": "string",
                        "description": "Cruise destination region (matches CruiseMapper's port-region taxonomy).",
                        "default": "any"
                    },
                    "cruiseType": {
                        "title": "Cruise type",
                        "enum": [
                            "any",
                            "easter",
                            "christmas",
                            "new-year",
                            "chinese-new-year",
                            "halloween",
                            "thanksgiving",
                            "independence-day",
                            "food-wine",
                            "music",
                            "sport",
                            "party",
                            "northern-lights",
                            "uk-school-breaks",
                            "world",
                            "nowhere",
                            "mini",
                            "christmas-new-year",
                            "transatlantic",
                            "transpacific",
                            "suez-canal",
                            "panama-canal",
                            "reposition-spring",
                            "reposition-summer",
                            "reposition-autumn",
                            "reposition-winter"
                        ],
                        "type": "string",
                        "description": "Cruise theme / category (e.g. transatlantic, christmas, food-wine).",
                        "default": "any"
                    },
                    "shipName": {
                        "title": "Ship name",
                        "type": "string",
                        "description": "Filter by ship name (substring match, e.g. `Symphony of the Seas`)."
                    },
                    "cruiseLine": {
                        "title": "Cruise line",
                        "type": "string",
                        "description": "Filter by cruise line (e.g. `Royal Caribbean`, `Carnival`)."
                    },
                    "departurePort": {
                        "title": "Departure port",
                        "type": "string",
                        "description": "Filter by embarkation port (e.g. `Miami`, `Barcelona`)."
                    },
                    "portOfCall": {
                        "title": "Port of call",
                        "type": "string",
                        "description": "Filter by intermediate port-of-call (e.g. `Cozumel`)."
                    },
                    "maxPrice": {
                        "title": "Max starting price (USD)",
                        "minimum": 100,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Drop cruises whose starting price exceeds this amount. Default = 10000.",
                        "default": 10000
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on cruises emitted across all pages.",
                        "default": 50
                    },
                    "enrichWithShipData": {
                        "title": "Enrich with ship-detail data",
                        "type": "boolean",
                        "description": "When true, fetch the ship-detail page for each unique ship and add a `shipDetails` block (year built, builder, gross tonnage, passenger capacity, length, decks, cabins, etc.). Adds ~1 extra HTTP request per unique ship.",
                        "default": false
                    },
                    "startUrls": {
                        "title": "Start URLs (optional)",
                        "type": "array",
                        "description": "Paste full CruiseMapper search URLs (e.g. `https://www.cruisemapper.com/cruise-search?finder=cruise&portRegion=22&duration=3`). Each URL's query params become a search; results are merged and deduped with the main filter inputs.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "pageConcurrency": {
                        "title": "Parallel pages",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of pages to fetch in parallel per query. Higher values speed up bulk runs but may trigger rate-limits.",
                        "default": 1
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```