# CruiseMapper Scraper (`solidcode/cruisemapper-scraper`) Actor

\[💰 $1.5 / 1K] Extract cruise itineraries, passenger ships, and ports from CruiseMapper — itinerary stops with dates, ship specs (capacity, year built, tonnage), and port schedules. Filter cruises by destination, dates, line, length, and price.

- **URL**: https://apify.com/solidcode/cruisemapper-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Travel, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## CruiseMapper Scraper

Pull cruise itineraries, ship specs, and port schedules from CruiseMapper at scale — with per-port arrival and departure times, multi-region voyage filters, full vessel specifications, and optional upcoming-arrivals schedules per port. Built for travel agencies, cruise content creators, route analysts, and travel-data teams who need fresh CruiseMapper data without paying for stale APIs or building a parser from scratch.

### Why This Scraper?

- **Three search modes in one actor** — cruise itineraries, passenger ships, and ports. Flip the `What to Scrape` dropdown to switch; results land in one dataset keyed by a `recordType` discriminator (`cruise`, `ship`, `port`) so downstream tools can fan out into three tables.
- **23 cruise destination regions** — Caribbean, Mediterranean, Alaska, Norwegian Fjords, Arctic and Antarctica, Galapagos, Hawaii and Panama Canal, plus river itineraries on the Nile, Amazon, Rhine, Danube, and Mekong.
- **Per-stop arrival and departure times** — each cruise row includes a structured `ports[]` array with date, port name, arrival time, departure time, country flag, and the link to the port's detail page. No positional `stop_1`, `stop_2` columns; one clean array per cruise.
- **Eight cruise filters wired through one input** — destination region, departure port, port of call, ship name, cruise line, length tier (1–2 / 3–5 / 6–10 / 11–14 / 15+ days), date range, and price ceiling. All optional.
- **Full ship specifications** — gross tonnage, year built, length and beam in meters, deck count, passenger and crew capacity, builder, ship class, flag state, sister ships, and former names. Plus a built-in `futureItineraries[]` array of every published voyage on that vessel (over 100 entries for active liners).
- **Port pages with precise lat/lon** — every port returns coordinates pulled from CruiseMapper's inline map widget, plus region, country, subtitle, and a clean summary paragraph.
- **Opt-in upcoming-arrivals schedule** — toggle `includeUpcomingArrivals` on Ports mode and each port returns up to 100 scheduled ship calls across the next 3 months: date, ship, cruise line, arrival time, and departure time.
- **Paste any cruisemapper.com URL** — drop cruise-search results, ship detail pages, or port detail pages straight into `startUrls` and the actor auto-detects the record type. No URL building required.
- **Pay only per result** — flat per-row pricing, no compute meter on top of the result count.

### Use Cases

**Travel Agency Operations**
- Build a weekly digest of new Caribbean and Mediterranean sailings under $1,500 for client newsletters
- Surface every Norwegian Fjords departure between June and September for shoulder-season promotions
- Track ship deployment changes — which vessels just shifted itineraries to Alaska for summer
- Compare per-night pricing across cruise lines at the same length tier

**Route & Fleet Analytics**
- Map every active cruise ship by gross tonnage, deck count, and passenger capacity
- Track river-cruise fleet growth on the Rhine, Danube, and Nile year over year
- Benchmark new-build specs (Excel-class, Edge-class, World-class) against existing fleet
- Quantify port traffic by counting scheduled arrivals per major hub

**Port Authority & Destination Marketing**
- Pull the 3-month forward schedule of arrivals at any port for terminal capacity planning
- Identify cruise lines that have never called at a port for outreach campaigns
- Map shore-excursion demand by counting itineraries that include each port of call
- Compare Caribbean port traffic month over month

**Cruise Content & Editorial**
- Generate "Top 10 cruises departing this month from Miami" articles with live data
- Build a database of every world cruise and grand voyage of 60+ nights
- Auto-update fleet pages with current ship specs and itineraries
- Source itinerary maps showing every stop on a multi-leg sailing

**Lead Generation & Affiliate Programs**
- Feed affiliate cruise-booking widgets with fresh inventory across destinations
- Build alerting on new ultra-luxury voyages (Silversea, Seabourn, Regent) under a price ceiling
- Compile cruise-line catalogs by operator for B2B partner pitches

### Getting Started

#### Cruise Itineraries — Caribbean Sailings

The simplest possible run — let the destination filter handle the rest:

```json
{
    "searchType": "cruises",
    "destination": "caribbean",
    "maxResults": 50
}
````

#### Filtered Cruise Search — Mediterranean, 6–10 Days, Under $3,000

```json
{
    "searchType": "cruises",
    "destination": "mediterranean",
    "cruiseLength": "6-10",
    "startDate": "2026-06-01",
    "endDate": "2026-09-30",
    "priceMax": 3000,
    "maxResults": 200
}
```

#### Ships by Cruise Line

```json
{
    "searchType": "ships",
    "cruiseLine": "Carnival-Cruise-Line-9",
    "maxResults": 50
}
```

#### Ports with Upcoming Arrivals

Pull port records with the next 3 months of scheduled ship calls:

```json
{
    "searchType": "ports",
    "portName": "Miami",
    "includeUpcomingArrivals": true,
    "maxResults": 10
}
```

#### Direct URL Input

Mix any combination of cruise-search results, ship pages, and port pages:

```json
{
    "startUrls": [
        "https://www.cruisemapper.com/cruise-search?portRegion=8&duration=3",
        "https://www.cruisemapper.com/ships/Symphony-of-the-Seas-1305",
        "https://www.cruisemapper.com/ports/miami-port-65"
    ],
    "maxResults": 100
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchType` | select | `Cruise Itineraries` | Choose the type of CruiseMapper data to collect. Cruise itineraries are the most common choice. Options: Cruise Itineraries, Ships, Ports. |
| `startUrls` | string\[] | `[]` | Paste CruiseMapper URLs directly (cruise search results, individual ship pages, or individual port pages). When provided, these override the filter fields below. |

#### Cruise Filters

Optional — narrow the cruise search. Ignored when scraping ships or ports, and ignored when Start URLs are provided.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `destination` | select | `Bahamas - Caribbean - Bermuda` | Cruise destination region. 23 options including Mediterranean, Alaska, Norwegian Fjords, Arctic-Antarctica, Galapagos, Hawaii-Panama, plus river itineraries on the Nile, Amazon, and European, Asian, French, and Russian rivers. |
| `departurePort` | string | null | Filter by embarkation port (e.g. "Miami", "Barcelona"). |
| `portOfCall` | string | null | Filter to cruises that include this intermediate port. |
| `shipName` | string | null | Filter by ship name. Works in all three modes. |
| `cruiseLine` | string | null | Filter by operator (e.g. "Royal Caribbean", "Carnival", "Viking"). |
| `cruiseLength` | select | null | Voyage duration tier. Options: 1-2 days, 3-5 days, 6-10 days, 11-14 days, 15+ days. |
| `startDate` | date | null | Earliest departure date (YYYY-MM-DD). |
| `endDate` | date | null | Latest departure date (YYYY-MM-DD). |
| `priceMin` | integer | null | Only include cruises at or above this per-person price (USD). |
| `priceMax` | integer | null | Only include cruises at or below this per-person price (USD). |

#### Port Filters

Used in Ports mode only.

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `portName` | string | null | Filter ports by name (e.g. "Miami", "Barcelona"). |
| `includeUpcomingArrivals` | boolean | `false` | When scraping ports, also fetch each port's upcoming-ship-arrivals schedule. Each port is capped at the first 3 months from today and 100 arrivals total to keep runs predictable. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `maxResults` | integer | `100` | Maximum number of results to collect. Set to 0 for unlimited. The actor never trims mid-page — it stops requesting new pages once the cap is reached, so the final count may slightly overshoot. |

### Output

Every row carries a `recordType` field — `cruise`, `ship`, or `port` — so you can route cleanly downstream into separate tables.

#### Cruise (`recordType: "cruise"`)

```json
{
    "recordType": "cruise",
    "id": "4874386",
    "url": "https://www.cruisemapper.com/cruise-search?portRegion=8&finder=cruise#cruise-4874386",
    "title": "7 days, Western Caribbean cruise",
    "shipName": "Symphony of the Seas",
    "shipUrl": "https://www.cruisemapper.com/ships/Symphony-of-the-Seas-1305",
    "cruiseLine": "Royal Caribbean",
    "departureDate": "2026-05-23",
    "returnDate": "2026-05-30",
    "durationNights": 7,
    "departurePort": "Miami",
    "returnPort": "Miami",
    "priceFromUsd": 879,
    "currency": "USD",
    "ports": [
        { "date": "23 May 17:00", "portName": "Miami", "country": "United States", "arrivalTime": null, "departureTime": "17:00", "portUrl": "https://www.cruisemapper.com/ports/miami-port-65", "role": "departure" },
        { "date": "25 May 08:00 - 17:00", "portName": "CocoCay", "country": "Bahamas", "arrivalTime": "08:00", "departureTime": "17:00", "portUrl": "https://www.cruisemapper.com/ports/cococay-port-1124", "role": "call" },
        { "date": "26 May 09:00 - 17:00", "portName": "Cozumel", "country": "Mexico", "arrivalTime": "09:00", "departureTime": "17:00", "portUrl": "https://www.cruisemapper.com/ports/cozumel-port-92", "role": "call" }
    ],
    "scrapedAt": "2026-05-20T14:30:00Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"cruise"` |
| `id` | string | CruiseMapper internal cruise identifier |
| `url` | string | Canonical cruise URL (anchored into the search results page) |
| `title` | string | Itinerary title (e.g. "7 days, Western Caribbean cruise") |
| `shipName` | string | Vessel name |
| `shipUrl` | string | Direct link to the ship detail page |
| `shipId` | string | CruiseMapper internal ship identifier |
| `cruiseLine` | string | Operator |
| `departureDate` | string | Embarkation date (YYYY-MM-DD) |
| `returnDate` | string | Disembarkation date (YYYY-MM-DD) |
| `durationNights` | number | Voyage length in nights |
| `departurePort` | string | Port of embarkation |
| `returnPort` | string | Port of disembarkation (may equal `departurePort`) |
| `priceFromUsd` | number | Lowest published per-person price in USD |
| `currency` | string | Currency of `priceFromUsd` (default `"USD"`) |
| `ports` | object\[] | Stops as `{ date, portName, portUrl, arrivalTime, departureTime, country, role }`. Role is `departure`, `call`, or `arrival`. |
| `scrapedAt` | string | ISO 8601 extraction timestamp |

#### Ship (`recordType: "ship"`)

```json
{
    "recordType": "ship",
    "id": "1305",
    "url": "https://www.cruisemapper.com/ships/Symphony-of-the-Seas-1305",
    "name": "Symphony of the Seas",
    "cruiseLine": "Royal Caribbean",
    "shipType": "ocean",
    "passengerCapacity": 6680,
    "crewCapacity": 2200,
    "yearBuilt": 2018,
    "lengthMeters": 362,
    "beamMeters": 47,
    "grossTonnage": 228081,
    "speedKnots": 22,
    "decks": 18,
    "cabins": 2759,
    "flagState": "Bahamas",
    "builder": "STX France (Saint-Nazaire, France)",
    "shipClass": "RCI Oasis",
    "sisterShips": ["Oasis of the Seas", "Allure of the Seas", "Harmony of the Seas"],
    "formerNames": [],
    "futureItineraries": [
        { "id": "4874386", "title": "7 days, Western Caribbean cruise", "departureDate": "2026-05-23", "durationNights": 7, "priceFromUsd": 879 }
    ],
    "scrapedAt": "2026-05-20T14:30:00Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"ship"` |
| `id` | string | CruiseMapper internal ship identifier |
| `url` | string | Canonical ship detail URL |
| `name` | string | Ship name |
| `cruiseLine` | string | Operator |
| `shipType` | string | Vessel classification — `ocean`, `river`, `expedition`, or `luxury` |
| `passengerCapacity` | number | Maximum passenger count |
| `crewCapacity` | number | Crew count |
| `yearBuilt` | number | Build year |
| `lengthMeters` | number | Hull length in meters |
| `beamMeters` | number | Hull beam (width) in meters |
| `grossTonnage` | number | Gross registered tonnage |
| `speedKnots` | number | Service speed in knots |
| `decks` | number | Deck count |
| `cabins` | number | Cabin count |
| `flagState` | string | Country of registry |
| `builder` | string | Shipyard that built the vessel |
| `shipClass` | string | Vessel class (e.g. "RCI Oasis", "CCL EXCEL (XL)") |
| `owner` | string | Registered owner of the vessel (may be null) |
| `operator` | string | Commercial operator of the vessel (may be null) |
| `sisterShips` | string\[] | Vessels in the same class |
| `formerNames` | string\[] | Previous names if the ship was renamed |
| `futureItineraries` | object\[] | Published forward sailings on this vessel — up to 100+ entries on active liners |
| `scrapedAt` | string | ISO 8601 extraction timestamp |

#### Port (`recordType: "port"`)

```json
{
    "recordType": "port",
    "id": "65",
    "url": "https://www.cruisemapper.com/ports/miami-port-65",
    "name": "Miami",
    "country": "United States",
    "region": "Hawaii - Mexico - Panama Canal",
    "latitude": 25.7765,
    "longitude": -80.1755,
    "subtitle": "PortMiami, Florida",
    "summary": "PortMiami (Dodge Island) is the busiest cruise port in the world...",
    "terminals": [],
    "upcomingArrivals": [
        { "date": "2026-05-23", "shipName": "Symphony of the Seas", "shipUrl": "https://www.cruisemapper.com/ships/Symphony-of-the-Seas-1305", "shipId": "1305", "cruiseLine": "Royal Caribbean", "arrivalTime": "07:00", "departureTime": "17:00" }
    ],
    "scrapedAt": "2026-05-20T14:30:00Z"
}
```

| Field | Type | Description |
|-------|------|-------------|
| `recordType` | string | Always `"port"` |
| `id` | string | CruiseMapper internal port identifier |
| `url` | string | Canonical port detail URL |
| `name` | string | Port name |
| `country` | string | Country |
| `region` | string | Cruise region (e.g. "Bahamas - Caribbean - Bermuda") |
| `regionId` | number | CruiseMapper internal region identifier |
| `latitude` | number | Latitude in decimal degrees |
| `longitude` | number | Longitude in decimal degrees |
| `subtitle` | string | Short alternative title (e.g. "PortMiami, Florida") |
| `summary` | string | Editorial description of the port |
| `terminals` | object\[] | Cruise terminals (empty when not listed on the source page) |
| `upcomingArrivals` | object\[] | Scheduled ship calls when `includeUpcomingArrivals: true` — capped at 100 entries across the next 3 months. Each entry: `{ date, shipName, shipUrl, shipId, cruiseLine, arrivalTime, departureTime }` |
| `scrapedAt` | string | ISO 8601 extraction timestamp |

### Tips for Best Results

- **Pick the right mode first.** `cruises` is the highest-volume mode (15 itineraries per page across the whole catalog). Switch to `ships` for fleet analytics and `ports` for terminal-level planning.
- **Always set a destination or a date range in Cruises mode.** A naked cruise search will default to Caribbean — explicit filters cut runtime and return a tighter dataset.
- **Use the URL input for surgical pulls.** When you only need one ship's full spec sheet or one port's arrival schedule, paste the URL directly instead of running a filtered listing.
- **Leave `includeUpcomingArrivals` off for broad port runs.** Each port with arrivals enabled adds up to three extra requests for the monthly schedule. Turn it on only when you need the schedule data, or run with a small `maxResults` to keep cost predictable.
- **Use `cruiseLength` to find world cruises.** The `15+ days` tier surfaces every grand voyage, world cruise, and trans-ocean repositioning sailing on CruiseMapper.
- **Mix sources in `startUrls`.** A single run can combine cruise-search URLs, ship pages, and port pages — they all land in the same dataset, tagged by `recordType`.
- **Treat `priceFromUsd` as a floor.** CruiseMapper reports the lowest published interior-cabin price; balcony, suite, and concierge fares are typically 1.5–3× higher.
- **Filtering by ship or port name scans the full CruiseMapper catalog.** Runs with a `shipName` or `portName` filter walk every listing page until a match is found — expect 1–3 minutes of runtime. For a single known ship or port, paste its URL into Start URLs instead for an instant targeted pull.

### Pricing

**$1.50 per 1,000 results** — pay only for what we successfully return. No compute charges, no per-run fees, no minimum.

| Results | Estimated Cost |
|---------|----------------|
| 100 | $0.15 |
| 1,000 | $1.50 |
| 10,000 | $15.00 |
| 100,000 | $150.00 |

A "result" is any row in the output dataset — a cruise, a ship, or a port. Platform fees (compute, storage) are additional and depend on your Apify plan.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate travel research, market analysis, and cruise-content workflows. Users are responsible for complying with applicable laws and CruiseMapper's terms of service. Do not use extracted data for spam, harassment, misrepresentation, or any illegal purpose. All cruise schedules, prices, and itineraries are subject to change by the operating cruise line — always confirm critical details with the cruise line before booking.

# Actor input Schema

## `searchType` (type: `string`):

Choose the type of CruiseMapper data to collect. Cruise itineraries are the most common choice.

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

Paste CruiseMapper URLs directly (cruise search results, individual ship pages, or individual port pages). When provided, these override the filter fields below.

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

Cruise destination region. Only used when scraping cruise itineraries.

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

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

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

Filter to cruises that include this intermediate port.

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

Filter by ship name. Works in all three modes.

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

Filter by operator (e.g. 'Royal Caribbean', 'Carnival', 'Viking').

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

Voyage duration tier.

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

Only include cruises departing on or after this date (YYYY-MM-DD).

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

Only include cruises departing on or before this date (YYYY-MM-DD).

## `priceMin` (type: `integer`):

Only include cruises at or above this per-person price.

## `priceMax` (type: `integer`):

Only include cruises at or below this per-person price.

## `portName` (type: `string`):

Filter ports by name (e.g. 'Miami', 'Barcelona'). Only used when scraping ports.

## `includeUpcomingArrivals` (type: `boolean`):

When scraping ports, also fetch each port's upcoming-ship-arrivals schedule. Adds significant runtime — one extra request per scheduled month per port. To keep runs predictable, each port is capped at the first 3 months from today and 100 arrivals total.

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

Maximum number of results to collect. Set to 0 for unlimited. The actor never trims mid-page — it stops requesting new pages once the cap is reached, so the final count may slightly overshoot.

## Actor input object example

```json
{
  "searchType": "cruises",
  "startUrls": [],
  "destination": "caribbean",
  "includeUpcomingArrivals": false,
  "maxResults": 100
}
```

# Actor output Schema

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

All scraped records grouped by type.

## `cruises` (type: `string`):

Cruise itineraries with ports of call.

## `ships` (type: `string`):

Passenger ship specifications.

## `ports` (type: `string`):

Port info and optional upcoming arrivals.

# 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 = {
    "searchType": "cruises",
    "startUrls": [],
    "destination": "caribbean",
    "includeUpcomingArrivals": false,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/cruisemapper-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 = {
    "searchType": "cruises",
    "startUrls": [],
    "destination": "caribbean",
    "includeUpcomingArrivals": False,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/cruisemapper-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 '{
  "searchType": "cruises",
  "startUrls": [],
  "destination": "caribbean",
  "includeUpcomingArrivals": false,
  "maxResults": 100
}' |
apify call solidcode/cruisemapper-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "CruiseMapper Scraper",
        "description": "[💰 $1.5 / 1K] Extract cruise itineraries, passenger ships, and ports from CruiseMapper — itinerary stops with dates, ship specs (capacity, year built, tonnage), and port schedules. Filter cruises by destination, dates, line, length, and price.",
        "version": "1.0",
        "x-build-id": "2Yp3z1NK8C8IqrH81"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~cruisemapper-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-cruisemapper-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/solidcode~cruisemapper-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-cruisemapper-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/solidcode~cruisemapper-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-cruisemapper-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": {
                    "searchType": {
                        "title": "What to Scrape",
                        "enum": [
                            "cruises",
                            "ships",
                            "ports"
                        ],
                        "type": "string",
                        "description": "Choose the type of CruiseMapper data to collect. Cruise itineraries are the most common choice.",
                        "default": "cruises"
                    },
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Paste CruiseMapper URLs directly (cruise search results, individual ship pages, or individual port pages). When provided, these override the filter fields below.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "destination": {
                        "title": "Destination Region",
                        "enum": [
                            "iceland-greenland",
                            "baltic-norwegian-fjords",
                            "mediterranean",
                            "west-coast-usa-canada",
                            "east-coast-usa-canada-new-england",
                            "hawaii-mexico-panama-canal",
                            "caribbean",
                            "south-america",
                            "arctic-antarctica",
                            "asia",
                            "africa-indian-ocean",
                            "australia-new-zealand-pacific",
                            "europe-rivers",
                            "canada-usa-rivers",
                            "asia-rivers",
                            "nile-river",
                            "amazon-river",
                            "ireland-uk-british-isles",
                            "galapagos",
                            "alaska",
                            "western-europe-azores-canary",
                            "france-rivers",
                            "russia-rivers"
                        ],
                        "type": "string",
                        "description": "Cruise destination region. Only used when scraping cruise itineraries."
                    },
                    "departurePort": {
                        "title": "Departure Port",
                        "type": "string",
                        "description": "Filter by embarkation port (e.g. 'Miami', 'Barcelona')."
                    },
                    "portOfCall": {
                        "title": "Port of Call",
                        "type": "string",
                        "description": "Filter to cruises that include this intermediate port."
                    },
                    "shipName": {
                        "title": "Ship Name",
                        "type": "string",
                        "description": "Filter by ship name. Works in all three modes."
                    },
                    "cruiseLine": {
                        "title": "Cruise Line",
                        "type": "string",
                        "description": "Filter by operator (e.g. 'Royal Caribbean', 'Carnival', 'Viking')."
                    },
                    "cruiseLength": {
                        "title": "Cruise Length",
                        "enum": [
                            "1-2",
                            "3-5",
                            "6-10",
                            "11-14",
                            "15+"
                        ],
                        "type": "string",
                        "description": "Voyage duration tier."
                    },
                    "startDate": {
                        "title": "Earliest Departure Date",
                        "type": "string",
                        "description": "Only include cruises departing on or after this date (YYYY-MM-DD)."
                    },
                    "endDate": {
                        "title": "Latest Departure Date",
                        "type": "string",
                        "description": "Only include cruises departing on or before this date (YYYY-MM-DD)."
                    },
                    "priceMin": {
                        "title": "Minimum Price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include cruises at or above this per-person price."
                    },
                    "priceMax": {
                        "title": "Maximum Price (USD)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only include cruises at or below this per-person price."
                    },
                    "portName": {
                        "title": "Port Name",
                        "type": "string",
                        "description": "Filter ports by name (e.g. 'Miami', 'Barcelona'). Only used when scraping ports."
                    },
                    "includeUpcomingArrivals": {
                        "title": "Include Upcoming Arrivals",
                        "type": "boolean",
                        "description": "When scraping ports, also fetch each port's upcoming-ship-arrivals schedule. Adds significant runtime — one extra request per scheduled month per port. To keep runs predictable, each port is capped at the first 3 months from today and 100 arrivals total.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of results to collect. Set to 0 for unlimited. The actor never trims mid-page — it stops requesting new pages once the cap is reached, so the final count may slightly overshoot.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
