# CruiseMapper Port Schedules Scraper (`automation-lab/cruisemapper-port-schedules-scraper`) Actor

Extract ship arrivals, departures, cruise lines, and dates from public CruiseMapper port schedules for tourism planning and itinerary analysis.

- **URL**: https://apify.com/automation-lab/cruisemapper-port-schedules-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Travel
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 Port Schedules Scraper

Extract structured cruise ship arrivals and departures from public CruiseMapper port schedules.

Use this Apify Actor to turn monthly port calendars into a clean dataset for destination planning, cruise analysis, transport operations, itinerary apps, or recurring traffic monitoring.

Provide one or more CruiseMapper port URLs and choose specific months or a continuous month range. The Actor saves one row per ship call with the port, date, vessel, cruise line, arrival, departure, and source links.

### What does CruiseMapper Port Schedules Scraper do?

The Actor reads server-rendered CruiseMapper port schedule pages over HTTP.

It extracts:

- ⚓ port name and region
- 📅 call date and weekday
- 🚢 ship name and ship page URL
- 🏢 cruise line when displayed
- 🕐 arrival and departure times
- 🌙 an overnight indicator
- 🔗 canonical port and source URLs
- 🧾 requested month and scrape timestamp

Results are available as JSON, CSV, Excel, XML, RSS, and other Apify Dataset exports.

### Who is it for?

#### Destination management organizations

Estimate visitor peaks and coordinate local services around expected ship calls.

#### Ground-tour and transport vendors

Plan staffing, vehicles, guides, and pickup capacity using arrival and departure windows.

#### Port and maritime analysts

Create repeatable snapshots of scheduled calls across ports and months.

#### Travel application developers

Feed structured port schedules into itinerary tools, dashboards, alerts, or internal APIs.

#### Cruise researchers

Compare ship presence, line activity, seasonality, and port traffic without manually copying calendars.

### Why use this Actor?

- **Structured output:** each port call becomes one consistent record.
- **Multi-port runs:** process several destination pages together.
- **Flexible periods:** request explicit months or an inclusive month range.
- **Source traceability:** retain links back to the exact schedule and ship.
- **Automation ready:** schedule recurring runs or trigger them through the API.
- **Cost efficient:** HTTP extraction avoids browser startup overhead.
- **Resilient:** bounded retries, validation, deduplication, and optional proxies are built in.

### How to scrape CruiseMapper port schedules

1. Open the Actor input page.
2. Add one or more CruiseMapper port URLs.
3. Enter months in `YYYY-MM` format.
4. Choose a maximum number of port calls.
5. Click **Start**.
6. Open the Dataset when the run finishes.
7. Export or integrate the records in your preferred format.

A small first run can use Ajaccio and one month.

### Input

| Field | Type | Description |
|---|---|---|
| `portUrls` | array | Public CruiseMapper port page URLs. |
| `months` | string array | Explicit months in `YYYY-MM` format. |
| `startMonth` | string | Optional first month of an inclusive range. |
| `endMonth` | string | Optional last month of an inclusive range. |
| `maxItems` | integer | Global maximum number of saved port calls. |
| `requestDelaySecs` | number | Delay between monthly schedule requests. |
| `proxyConfiguration` | object | Optional Apify Proxy settings. |

When `months` contains values, it takes precedence over `startMonth` and `endMonth`.

A date range may contain up to 36 months.

### Example input

```json
{
  "portUrls": [
    { "url": "https://www.cruisemapper.com/ports/ajaccio-port-67" }
  ],
  "months": ["2026-07", "2026-08"],
  "maxItems": 250,
  "requestDelaySecs": 0.5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

For a continuous period, leave `months` empty:

```json
{
  "portUrls": [
    { "url": "https://www.cruisemapper.com/ports/ajaccio-port-67" }
  ],
  "months": [],
  "startMonth": "2026-07",
  "endMonth": "2026-12",
  "maxItems": 1000
}
```

### Output data

| Field | Type | Meaning |
|---|---|---|
| `portName` | string | Port title shown by CruiseMapper. |
| `portUrl` | string | Canonical port page URL. |
| `region` | string or null | CruiseMapper region label. |
| `callDate` | string | Port-call date in `YYYY-MM-DD` format. |
| `weekday` | string or null | Displayed weekday. |
| `shipName` | string | Vessel name. |
| `shipUrl` | string | CruiseMapper ship page URL. |
| `cruiseLine` | string or null | Cruise line when exposed by the schedule. |
| `arrival` | string or null | Displayed local arrival time. |
| `departure` | string or null | Displayed local departure time. |
| `overnight` | boolean | Whether departure appears to roll into the next day. |
| `requestedMonth` | string | Month used to fetch this schedule. |
| `sourceUrl` | string | Exact monthly schedule source. |
| `scrapedAt` | string | UTC extraction timestamp. |

### Example output

```json
{
  "portName": "Ajaccio (Corsica France)",
  "portUrl": "https://www.cruisemapper.com/ports/ajaccio-port-67",
  "region": "Mediterranean - Black Sea",
  "callDate": "2026-07-01",
  "weekday": "Wednesday",
  "shipName": "AIDAcosma",
  "shipUrl": "https://www.cruisemapper.com/ships/AIDAcosma-2076",
  "cruiseLine": "AIDA Cruises",
  "arrival": "09:00",
  "departure": "22:00",
  "overnight": false,
  "requestedMonth": "2026-07",
  "sourceUrl": "https://www.cruisemapper.com/ports/ajaccio-port-67?month=2026-07#schedule",
  "scrapedAt": "2026-07-13T03:00:00.000Z"
}
```

### How much does it cost to scrape cruise port schedules?

This Actor uses pay-per-event pricing.

A **$0.005 run-start fee** is charged once, followed by a per-port-call event for records produced.

| Apify tier | Price per port call |
|---|---:|
| FREE | $0.000026595 |
| BRONZE | $0.000023126 |
| SILVER | $0.000018038 |
| GOLD | $0.000013875 |
| PLATINUM | $0.00001 |
| DIAMOND | $0.00001 |

For example, 1,000 calls cost about **$0.03160 on FREE** or **$0.02813 on BRONZE**, including one start fee.

Tier discounts reduce the unit price for higher Apify plans. The Console displays the exact current price before every run.

To reduce cost:

- group several months into one run
- avoid repeatedly requesting unchanged historical periods
- use `maxItems` for previews
- keep proxy use disabled unless it is needed

### Schedule monthly port monitoring

Create an Apify Schedule to refresh future calls weekly or monthly.

A common workflow is:

1. save one Actor Task per region or destination group
2. use a rolling set of future months
3. run the task every week
4. export the Dataset to your warehouse
5. compare new rows with the previous snapshot
6. notify operations teams when schedules change

Cruise schedules can change, so downstream systems should treat each extraction as a snapshot.

### Integrations

#### Google Sheets

Use the Dataset export URL or an Apify integration to refresh planning spreadsheets.

#### Make and Zapier

Trigger workflows after successful runs and route new calls into calendars, CRMs, or notifications.

#### Webhooks

Send run-completion events to your own service, then fetch the Dataset through the API.

#### Data warehouses

Load JSON or CSV exports into BigQuery, Snowflake, PostgreSQL, or another analytics store.

#### Slack and email alerts

Compare snapshots and notify teams about newly listed vessels or revised times.

### API usage

#### JavaScript API example

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('automation-lab/cruisemapper-port-schedules-scraper').call({
  portUrls: [{ url: 'https://www.cruisemapper.com/ports/ajaccio-port-67' }],
  months: ['2026-07'],
  maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/cruisemapper-port-schedules-scraper').call(run_input={
    'portUrls': [{'url': 'https://www.cruisemapper.com/ports/ajaccio-port-67'}],
    'months': ['2026-07'],
    'maxItems': 100,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

### cURL API example

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~cruisemapper-port-schedules-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "portUrls": [{"url": "https://www.cruisemapper.com/ports/ajaccio-port-67"}],
    "months": ["2026-07"],
    "maxItems": 100
  }'
```

### Use with Apify MCP

Connect the Actor to AI assistants through Apify MCP. The hosted endpoint is:

```text
https://mcp.apify.com?tools=automation-lab/cruisemapper-port-schedules-scraper
```

#### Claude Code

Add the hosted MCP server from a terminal:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/cruisemapper-port-schedules-scraper"
```

#### Claude Desktop, Cursor, and VS Code

Add this hosted HTTP server to the MCP configuration in Claude Desktop, Cursor, or VS Code. Each client accepts the same server definition:

```json
{
  "mcpServers": {
    "apify-cruisemapper-port-schedules": {
      "url": "https://mcp.apify.com?tools=automation-lab/cruisemapper-port-schedules-scraper"
    }
  }
}
```

Restart or reload the client after saving the configuration, then select `apify-cruisemapper-port-schedules` when prompted to enable tools.

If your client only supports local stdio servers, use the Apify MCP package instead:

```bash
npx -y @apify/actors-mcp-server \
  --tools automation-lab/cruisemapper-port-schedules-scraper
```

Example prompts:

- “Extract July arrivals for this CruiseMapper port.”
- “Create a CSV of expected ship calls for the next three months.”
- “Which cruise lines call at this port most often?”
- “Find days with multiple ships arriving before 10:00.”

### Data quality notes

Times are copied as displayed by CruiseMapper and should be interpreted in the port's local context.

Cruise line is nullable because not every row is guaranteed to expose a line label.

The Actor deduplicates records using port, date, ship, arrival, and departure.

The `overnight` field is inferred when a valid departure time is earlier than or equal to arrival.

Always retain `sourceUrl` when auditability matters.

### Tips for reliable runs

- Use canonical URLs containing `/ports/...-port-ID`.
- Start with one port and one month.
- Increase `maxItems` only after reviewing sample output.
- Keep a modest request delay for larger month ranges.
- Enable Apify Proxy if direct requests become unreliable.
- Split very large portfolios into region-based tasks.
- Store snapshots instead of overwriting historical datasets.

### Limitations

- The Actor extracts schedules that CruiseMapper publicly displays.
- It does not predict cancellations or operational changes.
- It does not enrich records with live AIS positions.
- It does not convert displayed local times into UTC.
- Empty months produce no records.
- Markup changes can temporarily affect extraction.
- The Actor accepts port URLs rather than free-text destination search.

### Troubleshooting

#### “Not a CruiseMapper port URL”

Use a URL shaped like `https://www.cruisemapper.com/ports/ajaccio-port-67`.

Remove schedule tabs, hotel links, and unrelated CruiseMapper pages.

#### The Dataset is empty

Check that the requested month has published calls on the source page.

Open the `sourceUrl` manually and confirm a schedule table exists.

Try a future high-season month or another port.

#### Requests fail intermittently

Increase `requestDelaySecs` and enable Apify Proxy.

Review logs for response status and retry details.

#### The run stops before all months

Increase `maxItems`; the limit applies across all ports and months.

### Legality

This Actor accesses publicly available pages without login.

Web scraping laws and website terms vary by jurisdiction and use case.

You are responsible for ensuring that your collection, storage, and use of data is lawful and respects applicable terms, privacy rules, and intellectual-property rights.

Avoid collecting personal data that you do not need.

Use conservative request rates and do not disrupt the target service.

### FAQ

#### Can I scrape several ports in one run?

Yes. Add multiple canonical pages to `portUrls`.

#### Can I request a whole season?

Yes. Set `months` to an empty array and provide `startMonth` and `endMonth`.

#### How far can the range extend?

One run accepts up to 36 months.

#### Are arrival and departure times UTC?

No. They are the times displayed for the port schedule and normally represent local context.

#### Does it extract every CruiseMapper port automatically?

No. You choose the port URLs, which keeps runs focused and predictable.

#### Can I run it every week?

Yes. Save the input as an Actor Task and attach an Apify Schedule.

#### Why is cruise line sometimes null?

The line is emitted only when the schedule row exposes a usable label.

#### How do I export to CSV?

Open the run Dataset, select **Export**, then choose CSV.

### Related scrapers

Explore other travel and location data tools from [Automation Lab](https://apify.com/automation-lab).

Combine this Actor with itinerary, hotel, or destination datasets when those sources fit your workflow.

Only use related Actors that match the lawful purpose and data quality requirements of your project.

### Support

If you encounter an unexpected result, include:

- the Actor run URL
- a sample port URL
- the requested month
- the expected record
- the observed output or error

That context makes investigation faster and reproducible.

# Actor input Schema

## `portUrls` (type: `array`):

CruiseMapper port pages, such as the Ajaccio port page.

## `months` (type: `array`):

Months to extract in YYYY-MM format. Takes precedence over the month range.

## `startMonth` (type: `string`):

Optional first month in a continuous YYYY-MM range.

## `endMonth` (type: `string`):

Optional last month in a continuous YYYY-MM range (maximum 36 months).

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

Stop after saving this many port-call records.

## `requestDelaySecs` (type: `number`):

Polite delay between monthly schedule requests.

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

Optional Apify Proxy settings for larger or scheduled runs.

## Actor input object example

```json
{
  "portUrls": [
    {
      "url": "https://www.cruisemapper.com/ports/ajaccio-port-67"
    }
  ],
  "months": [
    "2026-07"
  ],
  "maxItems": 20,
  "requestDelaySecs": 0.5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "portUrls": [
        {
            "url": "https://www.cruisemapper.com/ports/ajaccio-port-67"
        }
    ],
    "months": [
        "2026-07"
    ],
    "maxItems": 20,
    "requestDelaySecs": 0.5
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/cruisemapper-port-schedules-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 = {
    "portUrls": [{ "url": "https://www.cruisemapper.com/ports/ajaccio-port-67" }],
    "months": ["2026-07"],
    "maxItems": 20,
    "requestDelaySecs": 0.5,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/cruisemapper-port-schedules-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 '{
  "portUrls": [
    {
      "url": "https://www.cruisemapper.com/ports/ajaccio-port-67"
    }
  ],
  "months": [
    "2026-07"
  ],
  "maxItems": 20,
  "requestDelaySecs": 0.5
}' |
apify call automation-lab/cruisemapper-port-schedules-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CruiseMapper Port Schedules Scraper",
        "description": "Extract ship arrivals, departures, cruise lines, and dates from public CruiseMapper port schedules for tourism planning and itinerary analysis.",
        "version": "0.1",
        "x-build-id": "j1SNyQds6QbYDCvmR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~cruisemapper-port-schedules-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-cruisemapper-port-schedules-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/automation-lab~cruisemapper-port-schedules-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-cruisemapper-port-schedules-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/automation-lab~cruisemapper-port-schedules-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-cruisemapper-port-schedules-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "portUrls"
                ],
                "properties": {
                    "portUrls": {
                        "title": "⚓ Cruise port URLs",
                        "type": "array",
                        "description": "CruiseMapper port pages, such as the Ajaccio port page.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "months": {
                        "title": "📅 Specific months",
                        "type": "array",
                        "description": "Months to extract in YYYY-MM format. Takes precedence over the month range.",
                        "default": [
                            "2026-07"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "startMonth": {
                        "title": "Start month",
                        "pattern": "^\\d{4}-(0[1-9]|1[0-2])$",
                        "type": "string",
                        "description": "Optional first month in a continuous YYYY-MM range."
                    },
                    "endMonth": {
                        "title": "End month",
                        "pattern": "^\\d{4}-(0[1-9]|1[0-2])$",
                        "type": "string",
                        "description": "Optional last month in a continuous YYYY-MM range (maximum 36 months)."
                    },
                    "maxItems": {
                        "title": "Maximum port calls",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Stop after saving this many port-call records.",
                        "default": 20
                    },
                    "requestDelaySecs": {
                        "title": "Delay between schedule pages (seconds)",
                        "minimum": 0,
                        "maximum": 30,
                        "type": "number",
                        "description": "Polite delay between monthly schedule requests.",
                        "default": 0.5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings for larger or scheduled runs.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
