# CruiseFeed API: Real-Time Cruise Data & Pricing (REST) (`vulnv/cruise-data-api`) Actor

Always-on REST API for normalized cruise inventory from 60+ lines (MSC, Royal Caribbean, Carnival, Norwegian, Princess, Disney and more): ships, sailing dates, itineraries, ports of call, lead-in pricing and price history. Query it live on demand - no batch run. Unofficial; public data only.

- **URL**: https://apify.com/vulnv/cruise-data-api.md
- **Developed by:** [VulnV](https://apify.com/vulnv) (community)
- **Categories:** Travel, Integrations
- **Stats:** 5 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 cruise/ship records

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## CruiseFeed API – Real-Time Cruise Data & Pricing (Standby REST API)

An always-on REST API for **normalized cruise inventory** – cruise lines, ships,
sailing dates, day-by-day itineraries, ports of call and lead-in pricing –
across 60+ cruise lines, in one clean schema. It runs on Apify in **Standby
mode**, so you query it live like an API instead of running a batch job. Every
record carries a stable opaque `id` and the same shape
across every line.

It's built for travel-tech use cases – OTAs, cruise-comparison sites, travel
agencies and data aggregators – that need broad, fresh cruise inventory on
demand. The data is **public cruise inventory only – no personal data.**

> **Unofficial.** This Actor is not affiliated with, endorsed by, or sponsored
> by any cruise line or travel brand. Cruise line and ship names are trademarks
> of their respective owners and are used here only to describe the data the
> Actor returns.

### How it works (Standby)

This Actor is a live HTTP API, not a one-off run. Start it once and it stays
warm; then send normal `GET` requests to its **Standby URL**:

```
https://<username>--cruise-data-api.apify.actor/<endpoint>
```

- **Authentication is handled by Apify.** Send your Apify token as
  `Authorization: Bearer <APIFY_TOKEN>` or `?token=<APIFY_TOKEN>`. From the
  **Standby** tab on this page you can also try every endpoint right in the
  browser, no token setup required.
- **Billing is pay-per-event** (see [Billing](#billing)).
- The interactive endpoint reference is on the **Standby** tab (rendered from the
  Actor's OpenAPI schema).

```bash
## Caribbean sailings under $1,200, live
curl "https://<username>--cruise-data-api.apify.actor/cruises?region=Caribbean&max_price=1200&limit=10" \
  -H "Authorization: Bearer $APIFY_TOKEN"

## one ship by IMO number, with full specs
curl "https://<username>--cruise-data-api.apify.actor/ships/9839419" \
  -H "Authorization: Bearer $APIFY_TOKEN"
```

### Endpoints

| Method | Path | Description |
|--------|------|-------------|
| GET | `/cruises` | List & filter sailings (the workhorse) |
| GET | `/cruises.csv` | Same filters, streamed as CSV |
| GET | `/cruises/{id}` | One sailing, enriched with its `ship` |
| GET | `/cruises/{id}/history` | Price & availability history |
| GET | `/changes` | Recent price changes (fare-drop alerts) |
| GET | `/ships` | List & filter ships (specs, capacity, build) |
| GET | `/ships/{ship_id}` | One ship by IMO number |
| GET | `/cruise-lines` | Distinct cruise line names |
| GET | `/ports` | Distinct departure ports |
| GET | `/stats` | Catalogue totals |

Each cruise carries a lead-in `price_amount`, plus a `fares` array that holds the
per-cabin-class breakdown **when the source publishes more than one cabin fare** —
it's empty when the line quotes only a single "from" price.

#### Machine-readable spec & Postman

- **OpenAPI:** [`openapi.yaml`](openapi.yaml) — kept in lock-step with the live API.
- **Postman:** [`cruisefeed.postman_collection.json`](cruisefeed.postman_collection.json) —
  import it, set the `apiKey` variable, and every request is pre-wired. It targets the
  **direct hosted API** at `https://api.cruisefeed.io` (auth: `Authorization: Bearer <key>`),
  which is the same data as this Actor via a different front door.
- **Interactive docs:** https://api.cruisefeed.io/docs

#### Filters for `GET /cruises`

`cruise_line` · `ship_name` · `embark_port` · `region` (partial) ·
`departure_from` · `departure_to` · `min_price` · `max_price` · `min_nights` ·
`max_nights` · `round_trip` · `dedupe` (default true) · `sort` (default
`departure_date`) · `limit` (1–500, default 50) · `offset`.

### Example: list cruises

**Request**

```bash
curl "https://<username>--cruise-data-api.apify.actor/cruises?cruise_line=MSC%20Cruises&max_price=1500&min_nights=5&limit=1" \
  -H "Authorization: Bearer $APIFY_TOKEN"
```

**Response**

```json
{
  "items": [
    {
      "id": "cru_4f2a9c1b7e3d5068",
      "cruise_line": "MSC Cruises",
      "ship_name": "MSC World Europa",
      "title": "7-Night Western Mediterranean",
      "departure_date": "2026-09-12",
      "return_date": "2026-09-19",
      "duration_days": 8,
      "nights": 7,
      "round_trip": true,
      "embark_port": "Barcelona",
      "disembark_port": "Barcelona",
      "region": "Western Mediterranean",
      "sea_days": 2,
      "port_count": 4,
      "price_amount": 799,
      "price_currency": "EUR",
      "price_per_night": 114.14,
      "taxes_and_fees": 189.5,
      "obc_amount": 50,
      "sold_out": false,
      "itinerary": [
        { "seq": 1, "port": "Barcelona", "date_raw": "12 Sep", "is_embark": true, "is_disembark": false },
        { "seq": 2, "port": "Marseille", "date_raw": "13 Sep", "is_embark": false, "is_disembark": false }
      ],
      "booking_url": "https://www.msccruises.com/en-gb/...",
      "scraped_at": "2026-06-28T04:12:00Z"
    }
  ],
  "total": 1843,
  "limit": 1,
  "offset": 0
}
```

#### CSV export

```bash
curl "https://<username>--cruise-data-api.apify.actor/cruises.csv?region=Caribbean&max_price=1200" \
  -H "Authorization: Bearer $APIFY_TOKEN" -o cruises.csv
```

#### Price-drop tracking

```bash
## fares that changed since a date (great for deal alerts)
curl "https://<username>--cruise-data-api.apify.actor/changes?since=2026-06-20&cruise_line=MSC%20Cruises" \
  -H "Authorization: Bearer $APIFY_TOKEN"
```

#### Ship metadata

```bash
## search ships by name
curl "https://<username>--cruise-data-api.apify.actor/ships?q=world%20europa" \
  -H "Authorization: Bearer $APIFY_TOKEN"

## one ship by IMO (tonnage, decks, cabins, capacity, builder, sister ships)
curl "https://<username>--cruise-data-api.apify.actor/ships/9839419" \
  -H "Authorization: Bearer $APIFY_TOKEN"
```

The single-cruise endpoint (`GET /cruises/{id}`) returns a `ship`
object inline, so you get the vessel's specs alongside the sailing in one call.

### Billing

Pay-per-event, charged through Apify:

- **Per record returned** by the list/search endpoints (`/cruises`, `/ships`,
  `/changes`, CSV rows).
- **One record** for single-record lookups (one cruise, one ship, one history
  document) and for reference lists (`/cruise-lines`, `/ports`, `/stats`).
- A small fixed **Actor start** fee when a Standby instance spins up.

On the free tier, list endpoints return a **5-record sample per page** so you can
evaluate the data before committing. See the **Pricing** section on this page for
current rates.

### Data schema

| Field | Type | Notes |
|-------|------|-------|
| `id` | string | Opaque, source-agnostic id (unique per sailing) |
| `cruise_line`, `ship_name`, `title` | string | Normalized names |
| `departure_date`, `return_date` | date | `YYYY-MM-DD` (may be null for product-level sailings) |
| `duration_days`, `nights` | integer | |
| `round_trip` | boolean | |
| `embark_port`, `disembark_port`, `region` | string | |
| `ship_code`, `destination_code` | string | Line-specific codes, when exposed |
| `sea_days`, `port_count` | integer | Days at sea / ports of call on the itinerary |
| `price_amount`, `price_currency`, `price_per_night` | number | Lead-in fare (may be null) |
| `taxes_and_fees`, `taxes_currency` | number/string | Taxes & fees when itemized |
| `obc_amount` | number | Bundled onboard credit, when advertised |
| `sold_out` | boolean | Listed but no longer bookable |
| `fares` | array | Per-cabin-class breakdown (partial across lines) |
| `itinerary` | array | `{ seq, port, date_raw, is_embark, is_disembark }` per stop |
| `booking_url`, `detail_url`, `image_url` | string | Deep links and a representative image |
| `scraped_at` | datetime | ISO 8601 |

The `/ships` endpoints add vessel specs: IMO, operator, year built, capacity,
gross tonnage, length/beam, decks, cabins, builder, class, sister ships and flag.

### Use cases

- **OTAs & cruise booking sites** – power on-site search and listings with broad,
  fresh inventory instead of scraping each line.
- **Travel agencies & host networks** – one searchable dataset across every line.
- **Aggregators & travel-tech** – a normalized cruise feed as a product input.
- **Deal & content sites** – programmatic listing pages and fare-drop alerts from
  `/changes` and price history.

### FAQ

**How fresh is the data?** Inventory and prices are refreshed regularly; each
record includes a `scraped_at` timestamp, and price history is available for
change tracking via `/changes` and `/cruises/{id}/history`.

**What formats?** JSON for every endpoint, plus CSV via `/cruises.csv`.

**Does it include personal data?** No – public cruise inventory facts only
(lines, ships, sailings, itineraries, ports, lead-in prices).

**Is it official?** No. It is an independent, unofficial Actor and is not
affiliated with any cruise line. Brand names are used only to describe the data.

### Support

Questions, bugs or feature requests? Use the **Issues** tab on this Actor's page.

# Actor input Schema

## Actor input object example

```json
{}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("vulnv/cruise-data-api").call(input);

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("vulnv/cruise-data-api").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{}' |
apify call vulnv/cruise-data-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/b8vkkKfGqvjCt43d9/builds/On8P80V5Z5E5VJSpx/openapi.json