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

Scrape CruiseMapper cruise itineraries, ships, and ports. Get sailing dates, prices, port-by-port schedules, ship specifications, and port arrival calendars as structured data.

- **URL**: https://apify.com/parsebird/cruisemapper-scraper.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Categories:** Travel, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.15 / 1,000 records

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

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

Extract cruise itineraries, ship specifications, and port schedules from [CruiseMapper](https://www.cruisemapper.com) — the web's largest cruise-tracking database. Get sailing dates, prices, port-by-port schedules, ship specs, and port arrival calendars as clean, structured data, ready for spreadsheets, dashboards, or your own app.

<table><tr>
<td style="border-left:4px solid #1C1917;padding:12px 16px;font-weight:600">
Search live cruise itineraries by destination, departure port, ship, cruise line, length, dates, and price — or pull full ship specifications and port arrival calendars in the same run.
</td>
</tr></table>

##### Copy to your AI assistant

```
CruiseMapper Scraper on Apify (actor ID: parsebird/cruisemapper-scraper) scrapes cruisemapper.com for cruise itineraries, ships, and ports. Call it with the ApifyClient: `client.actor("parsebird/cruisemapper-scraper").call(run_input={"searchType": "cruises", "destination": "caribbean", "maxResults": 50})`. Key inputs: searchType (string: "cruises" | "ships" | "ports", default "cruises"), startUrls (array of CruiseMapper URLs, overrides filters), destination (string select, cruise region slug, default "caribbean"), departurePort/portOfCall/shipName/cruiseLine (string filters), cruiseLength (string select: "1-2"|"3-5"|"6-10"|"11-14"|"15+"), startDate/endDate (YYYY-MM-DD), priceMin/priceMax (integer USD), portName (string, Ports mode), includeUpcomingArrivals (boolean, Ports mode), maxResults (integer, default 100, 0 = unlimited). Output per item depends on recordType ("cruise" | "ship" | "port"): cruises return id, title, shipName, shipUrl, cruiseLine, departureDate, returnDate, durationNights, departurePort, returnPort, priceFromUsd, currency, and a ports[] array of port-by-port stops with dates and times; ships return name, cruiseLine, passengerCapacity, crewCapacity, yearBuilt, dimensions, grossTonnage, decks, cabins, flagState, builder, shipClass, sisterShips, formerNames, owner, operator, and futureItineraries[]; ports return name, country, region, latitude/longitude, summary, and upcomingArrivals[] when requested. Full API spec: https://apify.com/parsebird/cruisemapper-scraper/api. Get an API token at https://console.apify.com/settings/integrations.
```

### What does CruiseMapper Scraper do?

**CruiseMapper Scraper** is a CruiseMapper API alternative that turns cruisemapper.com's cruise finder, ship database, and port schedules into structured JSON, CSV, or Excel data — no browser, no manual copy-pasting. Use it to build a cruise price tracker, compare itineraries across cruise lines, monitor ship deployment, or pull port call calendars for a specific destination.

The actor has three search modes:

- 🚢 **Cruise Itineraries** — search CruiseMapper's cruise finder by destination, departure port, port of call, ship, cruise line, length, date range, and price. Every cruise record includes the full port-by-port schedule (arrival/departure times, country, port URL).
- 🛳️ **Ships** — look up a single ship by name, or pull an entire cruise line's fleet (e.g. every Royal Caribbean or Carnival ship) with full specifications and each ship's published future itineraries.
- ⚓ **Ports** — look up cruise ports by name or browse the full port directory, with region, coordinates, a descriptive summary, and (optionally) the port's upcoming ship-arrivals calendar for the next 3 months.

You can also skip the filters entirely and paste **Start URLs** — CruiseMapper cruise-search result pages, ship pages, or port pages — and the actor will scrape them directly.

Runs on the Apify platform, so results are available via **API**, can be **scheduled** to run daily or weekly, and can feed directly into **Zapier, Make, Google Sheets, and 1,000+ integrations**. Every new Apify account gets free trial credits to test the actor before paying for usage.

### What data can you extract from CruiseMapper?

#### Cruise itinerary fields

| Field | Description |
|-------|-------------|
| `title` | Itinerary title (e.g. "7 days, Western Caribbean cruise") |
| `shipName` / `shipUrl` | Vessel operating the sailing, with a link to its CruiseMapper ship page |
| `cruiseLine` | Operator |
| `departureDate` / `returnDate` | Embarkation and disembarkation dates (ISO 8601) |
| `durationNights` | Voyage length in nights |
| `departurePort` / `returnPort` | Embarkation and disembarkation ports |
| `priceFromUsd` | Lowest published per-person price, when CruiseMapper shows one |
| `ports[]` | Every stop, with date, arrival/departure time, country, and port URL |

#### Ship fields

| Field | Description |
|-------|-------------|
| `passengerCapacity` / `crewCapacity` | Maximum passengers and crew |
| `yearBuilt` / `builder` / `shipClass` | Build year, shipyard, and vessel class |
| `lengthMeters` / `beamMeters` / `grossTonnage` / `speedKnots` | Hull dimensions, tonnage, and service speed |
| `decks` / `cabins` | Deck and cabin counts |
| `sisterShips[]` / `formerNames[]` | Other vessels in the same class, and any previous names |
| `owner` / `operator` | Registered owner and commercial operator |
| `futureItineraries[]` | Every published forward sailing on that ship |

#### Port fields

| Field | Description |
|-------|-------------|
| `country` / `region` | Country and CruiseMapper cruise region |
| `latitude` / `longitude` | Coordinates |
| `summary` | Editorial description of the port |
| `upcomingArrivals[]` | Scheduled ship calls (date, ship, cruise line, arrival/departure time) when requested |

### How to scrape CruiseMapper with this actor

1. Click **Try for free** on the [CruiseMapper Scraper](https://apify.com/parsebird/cruisemapper-scraper) page (a free Apify account includes trial credits).
2. Pick a **Search type**: Cruise Itineraries, Ships, or Ports.
3. Set filters — destination, departure port, ship, cruise line, dates, price range — or paste CruiseMapper URLs directly into **Start URLs**.
4. Set **Max results** (or 0 for unlimited) and click **Start**.
5. When the run finishes, open the **Dataset** tab and export as JSON, CSV, Excel, or connect it to your app via the [Apify API](https://docs.apify.com/api/v2).

### How much does it cost to scrape CruiseMapper?

CruiseMapper Scraper uses **Pay Per Event (PPE)** pricing — you only pay for records the actor actually returns, not for compute time. Each cruise, ship, or port pushed to the dataset fires one `record-scraped` event.

| Your Apify plan | Price per 1,000 records |
|------------------|--------------------------|
| Free | $1.45 |
| Bronze | $1.35 |
| Silver | $1.25 |
| Gold | $1.15 |

A run that collects 1,000 cruise itineraries costs about $1.15–$1.45 depending on your plan — no separate compute charge. Every new Apify account starts with free trial credits, so you can test the actor at no cost.

### Input

| Parameter | Type | Required | Default | Description |
|-----------|------|----------|---------|-------------|
| searchType | string | No | `cruises` | `cruises`, `ships`, or `ports` |
| startUrls | array | No | `[]` | CruiseMapper cruise-search, ship, or port URLs — overrides the filters below |
| destination | string | No | `caribbean` | Cruise destination region (Cruise Itineraries mode) |
| departurePort | string | No | — | Filter by embarkation port |
| portOfCall | string | No | — | Filter to cruises calling at this port |
| shipName | string | No | — | Filter by ship name (all modes) |
| cruiseLine | string | No | — | Filter by operator; in Ships mode also accepts a CruiseMapper cruise-line slug (e.g. `Carnival-Cruise-Line-9`) |
| cruiseLength | string | No | any | `1-2`, `3-5`, `6-10`, `11-14`, or `15+` days |
| startDate / endDate | string | No | — | Departure date range, `YYYY-MM-DD` |
| priceMin / priceMax | integer | No | — | Per-person price range in USD |
| portName | string | No | — | Filter ports by name (Ports mode) |
| includeUpcomingArrivals | boolean | No | `false` | Fetch each port's upcoming ship-arrivals schedule (Ports mode) |
| maxResults | integer | No | `100` | Maximum records to return; `0` for unlimited |

See the [Input tab](https://apify.com/parsebird/cruisemapper-scraper/input-schema) for the full schema.

### Output example

```json
{
    "recordType": "cruise",
    "id": "5155693",
    "url": "https://www.cruisemapper.com/cruise-search?finder=cruise#cruise-5155693",
    "title": "5 days, round-trip from Port Canaveral, USA",
    "shipName": "Harmony Of The Seas",
    "shipUrl": "https://www.cruisemapper.com/ships/Harmony-Of-The-Seas-1067",
    "shipId": "1067",
    "cruiseLine": "Royal Caribbean Cruises",
    "departureDate": "2026-08-18",
    "returnDate": "2026-08-22",
    "durationNights": 4,
    "departurePort": "Port Canaveral",
    "returnPort": "Port Canaveral",
    "priceFromUsd": 538,
    "currency": "USD",
    "ports": [
        { "date": "18 Aug 16:00", "portName": "Port Canaveral", "country": "USA", "arrivalTime": null, "departureTime": "16:00", "portUrl": "https://www.cruisemapper.com/ports/port-canaveral-port-42", "role": "departure" },
        { "date": "20 Aug 07:00 - 17:00", "portName": "Coco Cay", "country": "Bahamas", "arrivalTime": "07:00", "departureTime": "17:00", "portUrl": "https://www.cruisemapper.com/ports/coco-cay-port-392", "role": "call" },
        { "date": "22 Aug 06:00", "portName": "Port Canaveral", "country": "USA", "arrivalTime": "06:00", "departureTime": null, "portUrl": "https://www.cruisemapper.com/ports/port-canaveral-port-42", "role": "arrival" }
    ],
    "scrapedAt": "2026-08-18T12:00:00Z"
}
```

Download results as **JSON, CSV, Excel, HTML, or XML** from the Dataset tab, or pull them programmatically via the API.

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("parsebird/cruisemapper-scraper").call(run_input={
    "searchType": "cruises",
    "destination": "caribbean",
    "maxResults": 100,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["title"], item["priceFromUsd"])
```

#### JavaScript

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('parsebird/cruisemapper-scraper').call({
    searchType: 'ships',
    cruiseLine: 'Royal Caribbean',
    maxResults: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Use cases

- Track cruise prices across dates, ships, and cruise lines to spot the best deals
- Build a cruise search or comparison tool without maintaining your own scraper
- Monitor a cruise line's entire fleet — specs, deployment, and future sailings
- Pull a port's arrival calendar to plan shore excursions, tours, or port-day staffing
- Feed cruise and port data into a travel-industry dashboard or BI tool

### Is it legal to scrape CruiseMapper?

Yes. CruiseMapper Scraper only collects publicly available data that anyone can see by visiting cruisemapper.com. Scraping publicly accessible web data is generally legal, as established in cases such as *hiQ Labs v. LinkedIn* — see Apify's [blog post on the legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) for details. Respect CruiseMapper's [terms of use](https://www.cruisemapper.com/terms-of-use) and avoid republishing scraped data in ways that infringe their rights. This actor is not affiliated with, endorsed by, or sponsored by CruiseMapper.

### Related actors

- [Airbnb Availability Calendar Scraper](https://apify.com/parsebird/airbnb-availability-calendar-scraper) — pull nightly availability and pricing for any Airbnb listing
- [GetYourGuide Tours & Activities Scraper](https://apify.com/parsebird/getyourguide-scraper) — extract tours, activities, and prices from GetYourGuide
- [GetYourGuide Review Scraper](https://apify.com/parsebird/getyourguide-review-scraper) — collect traveler reviews from GetYourGuide listings

### FAQ

**Does this actor need a CruiseMapper account or API key?**
No. It scrapes publicly available pages and returns structured data — no login or API key required on CruiseMapper's side.

**Why is `priceFromUsd` sometimes `null`?**
CruiseMapper doesn't publish a price for every itinerary. The actor returns exactly what the source page shows rather than guessing a value.

**Can I search by exact ship name in Cruise Itineraries mode?**
Yes, via the `shipName` filter, but CruiseMapper's own cruise finder index doesn't always include every ship's current sailings. For guaranteed coverage of a specific ship's itineraries, use **Ships mode** or paste its ship page URL into **Start URLs** — the ship's own itinerary table is always complete.

**Can I combine multiple filters?**
Yes — destination, departure port, port of call, cruise line, length, dates, and price range all combine (AND logic) in Cruise Itineraries mode.

**Can I schedule recurring runs?**
Yes. Use Apify's [Scheduler](https://docs.apify.com/platform/schedules) to run this actor daily, weekly, or at any interval, and monitor price or itinerary changes over time.

**How do I access results via API?**
Every run's dataset is available through the [Apify API](https://docs.apify.com/api/v2) and the `apify-client` libraries for Python and JavaScript (examples above).

**Something broken or missing?**
Open an issue on the actor's **Issues** tab in Apify Console — reports are reviewed regularly.

# 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. Ignored when scraping ships or ports, and ignored when Start URLs are provided.

## `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"). In Ships mode you may also paste a CruiseMapper cruise-line slug, e.g. "Carnival-Cruise-Line-9".

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

Voyage duration tier.

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

Earliest departure date (YYYY-MM-DD).

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

Latest departure date (YYYY-MM-DD).

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

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

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

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

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

Filter ports by name (e.g. "Miami", "Barcelona"). Used in Ports mode only.

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

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.

## `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",
  "cruiseLength": "",
  "includeUpcomingArrivals": false,
  "maxResults": 100
}
```

# Actor output Schema

## `dataset` (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 = {
    "searchType": "cruises",
    "destination": "caribbean",
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/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",
    "destination": "caribbean",
    "maxResults": 100,
}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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",
  "destination": "caribbean",
  "maxResults": 100
}' |
apify call parsebird/cruisemapper-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parsebird/cruisemapper-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/QkfiudQbVbhHCif5r/builds/B4pJGoH8Wl6ntzTur/openapi.json