# Baltic & Nordic Vessel Tracker — Live AIS for AI Agents (`haketa/vessel-tracker`) Actor

Track live ships in the Baltic & Nordic seas via AIS. Get real-time vessel positions, speed, course, type, size, IMO/MMSI, flag and destination — filter by area, MMSI or ship type. Real-time maritime grounding for AI agents, logistics & compliance.

- **URL**: https://apify.com/haketa/vessel-tracker.md
- **Developed by:** [Haketa](https://apify.com/haketa) (community)
- **Categories:** AI, Agents, Travel
- **Features:** Limited permissions
- **Stats:** 2 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.70 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Baltic & Nordic Vessel Tracker — Live AIS Ship Positions, Type, Flag & Destination

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-orange.svg)](https://apify.com/haketa/vessel-tracker)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://apify.com/haketa/vessel-tracker)
[![Data Format](https://img.shields.io/badge/Data-JSON%20%7C%20CSV%20%7C%20Excel-blue.svg)](https://apify.com/haketa/vessel-tracker)
[![AIS Protocol](https://img.shields.io/badge/AIS-Live%20Streaming-blue.svg)](https://apify.com/haketa/vessel-tracker)
[![Pagination](https://img.shields.io/badge/Scale-1%2C000%2B%20Vessels-brightgreen.svg)](https://apify.com/haketa/vessel-tracker)

**Track live ships across the Baltic and Nordic seas in real time.** This high-performance **vessel tracker** turns raw maritime **AIS** (Automatic Identification System) data into a clean, structured feed: give it a sea area, a ship type, a destination, or a list of MMSI numbers and it returns every matching vessel's **live position, speed, course, heading, ship type, size, flag, destination and ETA** — no login, no coding, no API key. Use it to **track ships** and **scrape AIS vessel data** the way you need it.

Export to **JSON, CSV, Excel, or API**.

> Built for AI agents that need real-time maritime grounding, logistics and port-operations teams, compliance and sanctions analysts watching tanker traffic, and researchers studying one of the world's busiest shipping corridors. Extraction is completely unlocked for **1,000+ vessels**, scaling across the entire regional fleet.

***

### ⚡ At a glance

| Metric / Feature | Specification |
|---|---|
| **Coverage Area** | Baltic Sea, Gulf of Finland, Gulf of Bothnia, Baltic Proper, Danish Straits, Kattegat & Skagerrak |
| **Data Protocol** | Live terrestrial AIS telemetry combined with static ship registration records |
| **Ship Capacity** | **1,000+ vessels unlocked** — processes the entire active regional fleet (1,500–2,500+ ships) |
| **Throughput / Speed** | ~300–500 moving vessels extracted and filtered in under 5 seconds |
| **Recommended Memory** | 512 MB – 1024 MB (lightweight & ultra-fast pure HTTP execution) |
| **Output Formats** | JSON, CSV, Excel (XLSX), XML, HTML |
| **Deduplication** | 100% unique records keyed by Maritime Mobile Service Identity (MMSI) |
| **Live Telemetry** | Latitude, longitude, speed over ground (SOG), course over ground (COG), true heading |
| **Voyage Data** | Reported destination, decoded ISO-8601 ETA, current draught, ship dimensions |

***

### 🔎 Why scrape Baltic & Nordic AIS vessel data?

**AIS (Automatic Identification System)** is the VHF transponder signal every commercial ship broadcasts — transmitting its identity, position, speed, course and voyage plan. Those positions change by the minute, so a static snapshot is useless almost immediately. A large language model cannot know where a ship is *right now*; a logistics dashboard needs the *current* picture of inbound traffic; a compliance desk needs to see which tankers are moving through a sensitive corridor *today*.

Collecting this manually is frustrating. Public ship-tracking websites throttle scrapers, hide data behind heavy interactive maps and paywalls, and refuse to provide clean machine-readable exports. Raw government AIS feeds, meanwhile, are split across two separate data streams — live spatial coordinates in one, vessel identity and dimensions in another — and encode ship types, navigation statuses, and ETAs as cryptic integers. This **AIS vessel tracker** does all of that decoding and joins both feeds into one flat, ready-to-use record per ship.

The Baltic Sea and Gulf of Finland are among the most heavily trafficked and most geopolitically scrutinized waters on Earth — the maritime gateway to St. Petersburg, Ust-Luga, Primorsk, Tallinn, Helsinki, and the Gulf of Bothnia industrial ports. It is also the focal corridor for monitoring "shadow fleet" oil tankers and maritime sanctions compliance. This **vessel tracker** provides an open, programmable window directly into those waters.

#### Commercial Marine Platforms vs. This Vessel Tracker

| Feature | Commercial Map Portals | Baltic & Nordic Vessel Tracker |
|---|---|---|
| **API Pricing** | $300–$2,000/month subscriptions | Fraction of a cent per run ($0.001) |
| **Export Formats** | Restricted or proprietary UI | JSON, CSV, Excel, XML via 1-click or API |
| **Rate Limiting** | Strict IP throttling & CAPTCHAs | Direct keyless open-data pipeline |
| **Data Enrichment** | Raw cryptic codes (AIS type 70) | Decoded human labels ("Cargo", "Under way") |
| **ETA Decoding** | Often raw 20-bit integer format | Fully normalized ISO-8601 UTC timestamp |
| **AI Agent Integration**| Heavy JavaScript web maps | Flat JSON records ready for MCP tool-calling |

#### High-Value Reasons to Extract AIS Vessel Data

- **Maritime Grounding for AI Agents:** Feed real-time spatial reality into LLMs — e.g., "Which crude oil tankers are currently navigating the Gulf of Finland towards Primorsk?"
- **Inbound Port Operations:** Monitor approaching traffic, expected times of arrival (ETA), and draught limits to optimize pilotage and berth allocation.
- **Fleet Surveillance:** Track an operator's specific fleet across multiple sea sectors by supplying an array of MMSI numbers.
- **Sanctions & Compliance Monitoring:** Screen tankers by flag state (Panama, Liberia, Gabon, Marshall Islands) moving through sensitive Baltic export corridors.
- **Maritime Supply Chain Logistics:** Detect arrival delays of container ships and dry bulk carriers before they dock.
- **Live Geospatial Mapping:** Stream vessel coordinates, courses, and speeds into custom GIS systems or interactive Leaflet/Mapbox visualizations.

***

### ✨ Key Features & Capabilities

- ✅ **Full Basin Coverage:** Captures the live operational fleet across the Gulf of Finland, Gulf of Bothnia, Baltic Proper, Danish Straits, Kattegat, and Skagerrak.
- ✅ **Custom Geospatial Bounding Box:** Define exact rectangular map areas (`minLon,minLat,maxLon,maxLat`) to focus on a specific strait, anchorage, or harbor approach.
- ✅ **Decoded Vessel Taxonomy:** Categorizes raw numeric AIS types into intuitive classifications: Cargo, Tanker, Passenger, Fishing, Tug / Towing, Sailing, Pleasure craft, High-speed craft, and Other.
- ✅ **Specific MMSI Fleet Tracking:** Input one or several MMSI transponder IDs to filter the entire fleet and isolate only the ships you care about.
- ✅ **Fuzzy Text Matching:** Filter by ship name or reported destination port (case-insensitive substring matching, e.g. `"HELSINKI"`, `"ROTTERDAM"`, `"UST-LUGA"`).
- ✅ **Moving-Only Filter:** Eliminate stationary noise by filtering out anchored, moored, or aground ships to focus exclusively on active traffic under way.
- ✅ **Automatic Flag State Resolution:** Derives the vessel's national flag registry directly from Maritime Identification Digits (MID), covering 50+ sovereign registries and flags of convenience.
- ✅ **ISO-8601 Decoded ETA:** Reconstructs the crew-reported 20-bit ETA broadcast into an absolute UTC timestamp with automated year-rollover protection.
- ✅ **Dimensional Hull Profiles:** Extracts vessel length, beam width, and current water draught in meters.
- ✅ **1,000+ Fleet Scale:** Fetches and joins entire regional fleets in a single blazing-fast HTTP pass (< 5 seconds).

***

### 🎯 Primary Use Cases

#### 1. Port Authorities & Marine Terminal Operators

Forecast vessel arrival times, manage tug and pilot dispatch schedules, and cross-reference vessel length and draught against berth channel restrictions.

#### 2. Maritime Sanctions & Commodity Traders

Track crude oil and refined product tankers operating in northern European export corridors. Monitor flag hopping and sudden destination changes across the Danish Straits.

#### 3. Freight Forwarders & Supply Chain Teams

Track inbound cargo vessels carrying containerized goods or bulk commodities. Calculate realistic transit times based on real-time speed over ground (SOG).

#### 4. Marine Environmental & Fisheries Researchers

Study commercial fishing vessel density, measure high-speed craft traffic in marine conservation zones, and analyze commercial route compliance.

#### 5. AI Copilots & Autonomous Agents

Empower AI agents with live maritime tool-calling capabilities. Using Apify MCP or REST API, agents can query ship whereabouts and verify shipping claims instantly.

***

### 📥 Input Parameters

Configure the actor easily using the visual form in Apify Console or pass a JSON payload via the REST API.

| Field | Type | Default | Description |
|---|---|---|---|
| `region` | Select | `"all"` | Sea area: `"all"`, `"gulf-of-finland"`, `"gulf-of-bothnia"`, `"baltic-proper"`, `"danish-straits"`, `"kattegat-skagerrak"`, `"custom"`. |
| `bbox` | String | `""` | Custom bounding box `minLon,minLat,maxLon,maxLat` (used when `region` is `"custom"`), e.g. `"22,59,28,61"`. |
| `shipType` | Select | `"all"` | Filter by vessel classification: `"all"`, `"cargo"`, `"tanker"`, `"passenger"`, `"fishing"`, `"tug"`, `"sailing"`, `"pleasure"`, `"high-speed"`, `"other"`. |
| `movingOnly` | Boolean | `false` | When true, hides stopped, anchored, or moored vessels and keeps only ships navigating with speed > 0.5 knots. |
| `nameQuery` | String | `""` | Optional case-insensitive substring to filter vessels by name (e.g. `"Maersk"`, `"Baltic"`). |
| `destination` | String | `""` | Optional case-insensitive substring to filter by reported destination port (e.g. `"HELSINKI"`, `"KLAIPEDA"`). |
| `mmsi` | Array | `[]` | List of specific 9-digit MMSI transponder numbers to follow. |
| `maxItems` | Integer | `0` | Maximum vessels to output. Set to `0` for unlimited extraction (entire matching fleet). |
| `proxyConfiguration` | Object | `{"useApifyProxy": false}` | Proxy settings. Public open data source; proxy is off by default. |

#### Input Examples

##### Example 1: Active Tankers in the Gulf of Finland (Moving Only)

```json
{
  "region": "gulf-of-finland",
  "shipType": "tanker",
  "movingOnly": true,
  "maxItems": 200
}
```

##### Example 2: Inbound Ships Heading to Helsinki or St. Petersburg

```json
{
  "region": "all",
  "destination": "HELSINKI",
  "maxItems": 500
}
```

##### Example 3: Tracking Specific Fleet by MMSI

```json
{
  "mmsi": [
    "244772000",
    "230123456",
    "265847000"
  ],
  "movingOnly": false
}
```

##### Example 4: Custom Spatial Bounding Box (Stockholm Archipelago)

```json
{
  "region": "custom",
  "bbox": "18.0,59.0,19.5,59.8",
  "shipType": "all",
  "maxItems": 0
}
```

***

### 📤 Output Dataset & Field Coverage

The actor outputs flat JSON objects where each record represents a single tracked vessel.

#### Field Specification & Coverage Indicators

##### 🚢 Vessel Identification

| Field | Type | Coverage | Description |
|---|---|---|---|
| `mmsi` | String | 🟢 High (100%) | Unique 9-digit Maritime Mobile Service Identity. |
| `imo` | String | 🟡 Conditional (~72%) | Permanent 7-digit IMO hull number. Empty for smaller craft. |
| `name` | String | 🟡 Conditional (~75%) | Broadcast vessel name. |
| `callSign` | String | 🟡 Conditional (~71%) | Marine radio call sign assigned by licensing flag. |
| `flag` | String | 🟢 High (~87%) | Flag state resolved from MMSI maritime identification digits. |
| `shipType` | String | 🟢 High (100%) | Raw numeric AIS ship-type identifier. |
| `shipTypeText` | String | 🟢 High (100%) | Human-readable category (e.g. `"Cargo"`, `"Tanker"`). |

##### 🌐 Real-Time Telemetry & Navigation

| Field | Type | Coverage | Description |
|---|---|---|---|
| `latitude` | String | 🟢 High (100%) | Current WGS-84 latitude in decimal degrees. |
| `longitude` | String | 🟢 High (100%) | Current WGS-84 longitude in decimal degrees. |
| `speedKnots` | String | 🟢 High (100%) | Speed over ground in knots (SOG). |
| `courseOverGround`| String | 🟢 High (100%) | Course over ground in degrees (COG). |
| `heading` | String | 🟢 High (~92%) | Compass heading in degrees. Empty if uncalibrated. |
| `navStatus` | String | 🟢 High (100%) | Raw numeric navigation status code. |
| `navStatusText` | String | 🟢 High (100%) | Readable status (`"Under way using engine"`, `"At anchor"`, `"Moored"`). |

##### ⚓ Voyage & Port Destination

| Field | Type | Coverage | Description |
|---|---|---|---|
| `destination` | String | 🟡 Conditional (~70%) | Crew-reported destination port string. |
| `eta` | String | 🟡 Conditional (~70%) | Decoded ISO-8601 UTC timestamp of estimated arrival. |
| `positionTime` | String | 🟢 High (100%) | Timestamp of AIS transponder observation. |
| `scrapedAt` | String | 🟢 High (100%) | ISO 8601 timestamp of extraction. |

##### 📏 Vessel Dimensions & Hull Profile

| Field | Type | Coverage | Description |
|---|---|---|---|
| `draughtMeters` | String | 🟡 Conditional (~68%) | Current water draught in meters. |
| `lengthMeters` | String | 🟡 Conditional (~74%) | Total hull length in meters. |
| `widthMeters` | String | 🟡 Conditional (~74%) | Total hull beam width in meters. |

#### Sample Output Record

```json
{
  "mmsi": "244772000",
  "imo": "9331361",
  "name": "LEONIE",
  "callSign": "PHLE",
  "shipType": "70",
  "shipTypeText": "Cargo",
  "flag": "Netherlands",
  "latitude": "57.815853",
  "longitude": "18.044017",
  "speedKnots": "8.6",
  "courseOverGround": "210.9",
  "heading": "209",
  "navStatus": "0",
  "navStatusText": "Under way using engine",
  "destination": "PLSZZ",
  "eta": "2026-11-12T03:00:00Z",
  "draughtMeters": "5.5",
  "lengthMeters": "90",
  "widthMeters": "13",
  "positionTime": "2026-11-10T16:15:46Z",
  "scrapedAt": "2026-11-10T16:18:00.000Z"
}
```

***

### 🔁 Scale, Architecture & Performance

- **Zero-Pagination Bulk Pipeline:** The actor utilizes high-efficiency stream compression to download live AIS position vectors and static metadata in parallel batches, joining thousands of entities in memory in milliseconds.
- **Uncapped Fleet Retrieval:** Removing legacy demo caps allows full fleet extractions exceeding 1,000+ active vessels across the entire Baltic basin.
- **Micro-Cost Execution:** Because no browser instances or proxy rotation bandwidth are consumed, runs finish in 2–5 seconds with compute costs typically under $0.0005 per run.
- **Strict MMSI Deduplication:** Every vessel record is uniquely mapped by transponder ID, guaranteeing 0% duplicates in your downstream datasets.

***

### 💻 Programmatic Integration & AI Agent Tool Calling

#### Node.js (Apify SDK)

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

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

const run = await client.actor('haketa/vessel-tracker').call({
    region: 'gulf-of-finland',
    shipType: 'tanker',
    movingOnly: true,
    maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Tracked ${items.length} active tankers navigating the Gulf of Finland.`);
```

#### Python (Apify Client)

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.getenv('APIFY_TOKEN'))

run = client.actor('haketa/vessel-tracker').call(run_input={
    'region': 'baltic-proper',
    'shipType': 'cargo',
    'destination': 'ROTTERDAM',
    'maxItems': 50,
})

for ship in client.dataset(run['defaultDatasetId']).list_items().items:
    print(f"{ship['name']} ({ship['flag']}) -> SOG: {ship['speedKnots']} kn, ETA: {ship['eta']}")
```

#### Direct cURL Request

```bash
curl -X POST "https://api.apify.com/v2/acts/haketa~vessel-tracker/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "region": "all",
    "shipType": "tanker",
    "movingOnly": true,
    "maxItems": 250
  }'
```

***

### 🗺️ Supported Sea Sectors & Coordinate Boundaries

The actor comes pre-configured with boundary coordinates for the key waterways of Northern Europe:

| Region Key | Region Label | Geographic Boundaries (Lon/Lat) | Key Ports & Passages Included |
|---|---|---|---|
| `all` | All Areas (Baltic & Nordic) | Full regional terrestrial AIS coverage | Complete Baltic Sea, Kattegat, Skagerrak |
| `gulf-of-finland` | Gulf of Finland | 22°E–30.5°E, 59°N–61°N | Helsinki, Tallinn, St. Petersburg, Ust-Luga, Primorsk |
| `gulf-of-bothnia` | Gulf of Bothnia | 17°E–26°E, 60°N–66°N | Oulu, Vaasa, Rauma, Pori, Luleå, Umeå |
| `baltic-proper` | Baltic Proper | 12°E–23°E, 54°N–60°N | Stockholm, Riga, Klaipeda, Gdansk, Gdynia, Kaliningrad |
| `danish-straits` | Danish Straits | 9°E–13°E, 54°N–58°N | Great Belt, Little Belt, The Sound (Øresund), Copenhagen |
| `kattegat-skagerrak`| Kattegat & Skagerrak | 7°E–13°E, 56°N–59.5°N | Gothenburg, Oslofjord approaches, Skagen passage |
| `custom` | Custom Map Area | User-defined `minLon,minLat,maxLon,maxLat` | Pinpoint monitoring of harbor berths and pilot stations |

***

### ⚓ AIS Navigational Status Reference

Every broadcast AIS dynamic message contains a 4-bit navigation status integer. This scraper maps each code to its standardized International Maritime Organization (IMO) definition:

| Code | Status Text | Marine Meaning |
|---|---|---|
| `0` | Under way using engine | Vessel is navigating actively under engine power |
| `1` | At anchor | Vessel is held in place by anchor equipment |
| `2` | Not under command | Vessel unable to maneuver due to exceptional circumstance |
| `3` | Restricted manoeuvrability | Vessel restricted in ability to maneuver (dredging, towing) |
| `4` | Constrained by draught | Vessel severely restricted in maneuvering by water depth |
| `5` | Moored | Vessel secured to dock, pier, or buoy equipment |
| `6` | Aground | Vessel has touched ground and is stationary |
| `7` | Engaged in fishing | Commercial vessel operating trawls, lines, or nets |
| `8` | Under way sailing | Vessel navigating under sail power |
| `14` | AIS-SART active | Search and rescue transponder broadcast active |
| `15` | Undefined | Default state when transponder status is unassigned |

***

### 💡 Practical Pro-Tips

- **Filter Anchored Ships:** If building a traffic velocity map, set `movingOnly: true` to avoid cluttering your visualization with hundreds of vessels moored at harbor berths.
- **Monitor Specific Ports:** Pass the destination port name (e.g. `"KLAIPEDA"`) into `destination` to capture vessels approaching that harbor regardless of where they currently are in the Baltic.
- **Geofence Chokepoints:** Use `region: "custom"` with bounding box coordinates around the Fehmarn Belt or Great Belt to track all traffic passing between the North Sea and the Baltic Sea.
- **Automated Alerts via Webhooks:** Connect Apify Webhooks to Make or Zapier to trigger SMS or Slack notifications whenever a monitored MMSI enters a specific port.

***

### ❓ Frequently Asked Questions (FAQ)

##### Where does this AIS data come from?

The data is aggregated from official coastal terrestrial AIS sensor networks across the Baltic Sea and Nordic coastlines (Fintraffic / digitraffic.fi), published openly under CC BY 4.0.

##### Can I track ships outside the Baltic and Nordic region?

No. This specific scraper operates across the Baltic Sea, Gulf of Finland, Gulf of Bothnia, Baltic Proper, Danish Straits, and Kattegat/Skagerrak coastal waters.

##### Why are some vessel names or IMO numbers blank?

AIS transmits in two channels: dynamic position (every few seconds) and static voyage metadata (every 6 minutes). If a vessel recently turned on its transponder, its static identity packet may not yet have been received.

##### What does `movingOnly` do?

It filters out vessels with speed over ground (SOG) below 0.5 knots or reported navigation status of "At anchor", "Moored", or "Aground".

***

### 📋 Changelog

#### v1.2 (2026-11)

- **Unlocked 1,000+ Fleet Scale:** Removed pagination and demo limits when explicit `maxItems > 200` is requested, allowing extraction of the entire active fleet across the Baltic & Nordic basins.
- **Enhanced ETA ISO Parsing:** Decoded 20-bit AIS ETA transmissions into verified UTC ISO-8601 timestamps with year-boundary rollover protection.
- **Expanded Flag State Mapping:** Added Maritime Identification Digits (MID) resolution for flags of convenience (Panama, Liberia, Marshall Islands, Gabon, Palau).
- **Optimized Prefill Execution:** Runs finish in under 10 seconds on Apify platform.

#### v1.1 (2026-07)

- **Custom Bounding Box Support:** Enabled spatial coordinates filtering (`minLon,minLat,maxLon,maxLat`) for targeted straits and ports.
- **Moving-Only Filter:** Added speed threshold filter to drop anchored and moored vessels.

#### v1.0 (2026-07)

- Initial release featuring live AIS position and static metadata join, ship type classification, and multi-format exports.

# Changelog

This Actor's version history is a separate document: https://apify.com/haketa/vessel-tracker/changelog.md

# Actor input Schema

## `region` (type: `string`):

Pick the Baltic or Nordic sea area you want to watch. Choose "All" to see the whole live fleet across the region.

## `shipType` (type: `string`):

Show only one category of vessel, or keep "All types" to include everything.

## `movingOnly` (type: `boolean`):

Turn on to hide ships that are stopped, anchored or moored, and keep only vessels currently under way.

## `nameQuery` (type: `string`):

Optional. Type part of a ship name to keep only matching vessels (case-insensitive). Leave blank to include every vessel.

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

Optional. Type part of a reported destination port to keep only ships heading there, e.g. HELSINKI or ROTTERDAM. Leave blank for all destinations.

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

Cap how many vessels to return. Set 0 for no limit (return everything that matches your filters).

## `mmsi` (type: `array`):

Optional. Follow only certain ships by their MMSI number, e.g. 230123456. Leave empty to include the whole fleet.

## `bbox` (type: `string`):

Optional. Only used when Sea area is set to "Custom map area". Enter a bounding box as minLon,minLat,maxLon,maxLat (for example 22,59,28,61 for the Gulf of Finland).

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

Apify Proxy settings. This data source is public, so a proxy is off by default and not needed for normal use.

## Actor input object example

```json
{
  "region": "all",
  "shipType": "all",
  "movingOnly": false,
  "nameQuery": "",
  "destination": "",
  "maxItems": 100,
  "mmsi": [],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `vessels` (type: `string`):

Download the full list of tracked vessels.

## `mmsi` (type: `string`):

Maritime Mobile Service Identity

## `imo` (type: `string`):

IMO number

## `name` (type: `string`):

Vessel name

## `callSign` (type: `string`):

Radio call sign

## `shipTypeText` (type: `string`):

Ship type

## `flag` (type: `string`):

Flag state (from MMSI)

## `latitude` (type: `string`):

Latitude

## `longitude` (type: `string`):

Longitude

## `speedKnots` (type: `string`):

Speed over ground in knots

## `courseOverGround` (type: `string`):

Course over ground (degrees)

## `heading` (type: `string`):

True heading (degrees)

## `navStatusText` (type: `string`):

Navigational status

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

Reported destination

## `eta` (type: `string`):

Reported estimated time of arrival (ISO-8601 UTC, when broadcast)

## `draughtMeters` (type: `string`):

Draught in meters

## `lengthMeters` (type: `string`):

Length in meters

## `widthMeters` (type: `string`):

Width in meters

## `positionTime` (type: `string`):

Timestamp of the position

## `scrapedAt` (type: `string`):

Extraction timestamp

# 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 = {
    "nameQuery": "",
    "destination": "",
    "maxItems": 100,
    "mmsi": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/vessel-tracker").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 = {
    "nameQuery": "",
    "destination": "",
    "maxItems": 100,
    "mmsi": [],
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/vessel-tracker").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 '{
  "nameQuery": "",
  "destination": "",
  "maxItems": 100,
  "mmsi": []
}' |
apify call haketa/vessel-tracker --silent --output-dataset

```

## MCP server setup

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

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/pW580bScEOE525WpX/builds/Z9jP8Kt8L6eSotdfb/openapi.json