# Alphaliner Top 100 Carrier Fleets (`arman-bd/alphaliner-carrier-fleet-scraper`) Actor

Scrape the Alphaliner Top 100: every container line's operated TEU, owned vs chartered split, orderbook, market share and per-vessel IMO numbers, plus global fleet totals.

- **URL**: https://apify.com/arman-bd/alphaliner-carrier-fleet-scraper.md
- **Developed by:** [Arman Hossain](https://apify.com/arman-bd) (community)
- **Categories:** Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 carrier scrapeds

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/actors/running/actors-in-store.md#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

## Alphaliner Top 100 Carrier Fleet Scraper

![Alphaliner Carrier Fleet: The Top 100 container carriers by TEU, with owned, chartered and orderbook capacity split out](https://api.apify.com/v2/key-value-stores/ZQOcNAOHrIgTacAmy/records/alphaliner-carrier-fleet-scraper.jpg)

Pulls the Alphaliner Top 100: the 100 largest container lines ranked by operated TEU, with the owned vs chartered split, orderbook, global market share and the full list of vessel IMO numbers in each carrier's fleet. One run reads the whole table in a single request.

This Actor reads structured data directly, so there's no browser, no proxy and no login required to use it.

**Agent skill: [SKILL.md](https://api.apify.com/v2/key-value-stores/t7YoTxpZEJOWvw4Ug/records/alphaliner-carrier-fleet-scraper.md)**

```
https://api.apify.com/v2/key-value-stores/t7YoTxpZEJOWvw4Ug/records/alphaliner-carrier-fleet-scraper.md
```

### What you get

One record per carrier, ranked largest fleet first.

| Field | What it holds |
|---|---|
| `rank` | Position by operated TEU, 1 (largest) to 100 |
| `operator` | Full legal/registered operator name |
| `carrierName` | Brand/trading name (e.g. "MSC" for "Mediterranean Shg Co") |
| `carrierCode` | Short internal carrier code |
| `companyId`, `companyRefId` | Alphaliner's internal company identifiers |
| `website` | Carrier's schedule/website URL |
| `flagIconUrl` | Flag icon for the carrier's country of registration |
| `notes` | Free-text note (subsidiary brands folded into this operator, etc.), `null` when empty |
| `totalTeu`, `totalShips` | Total operated capacity: owned + chartered |
| `ownedTeu`, `ownedShips` | Owned-fleet portion |
| `charteredTeu`, `charteredShips`, `charteredSharePercent` | Chartered-in portion and its share of the total fleet |
| `orderbookTeu`, `orderbookShips`, `orderbookSharePercent` | Vessels on order and orderbook size as a percentage of the current fleet |
| `marketSharePercent` | Share of total global operated TEU |
| `top30` | `true` for the 30 largest operators |
| `vesselImos` | Every vessel's IMO number in that carrier's operated fleet |
| `vesselCount` | Length of `vesselImos` (populated even when the list itself is switched off) |
| `globalFleet` | Global cellular fleet totals (active vessels/TEU/DWT, transatlantic/transpacific/Europe trade capacity), the same object on every row |
| `scrapedAt` | Run timestamp |

`RUN_SUMMARY` in the key-value store holds per-run counts, the filters you used, and any call that failed.

### Use cases

- **Carrier master data.** `vesselImos` is a ready-made IMO-to-operator mapping for roughly 7,600 cellular ships, useful as a join key against AIS, port-call or sanctions data.
- **Fleet strategy tracking.** Compare `ownedTeu` vs `charteredTeu` over successive weekly runs to see which lines are growing owned tonnage vs leaning on the charter market.
- **Orderbook and supply-side analysis.** `orderbookTeu` and `orderbookSharePercent` show which operators are adding the most future capacity relative to their current fleet.
- **Market concentration.** `marketSharePercent` across all 100 rows gives a full HHI-style concentration picture of global container shipping.
- **Credit and equity research.** A clean, structured weekly snapshot instead of retyping the public table by hand.

### Quick start

The full table, nothing filtered out:

```json
{}
```

Just the carriers you care about, without the (large) IMO lists:

```json
{
 "carriers": ["MSC", "Maersk", "CMA CGM", "COSCO"],
 "includeVesselImos": false
}
```

Only operators large enough to matter for a concentration study:

```json
{
 "minTotalTeu": 500000,
 "maxCarriers": 30
}
```

### Input

| Field | Type | Default | Notes |
|---|---|---|---|
| `carriers` | array | `[]` | Keep only carriers whose `operator` or `carrierName` contains one of these terms (case-insensitive substring match). Empty means all 100. |
| `minTotalTeu` | integer | `0` | Drop carriers whose `totalTeu` is below this. `0` keeps everyone. |
| `maxCarriers` | integer | `100` | Stop after this many carriers, counted after the filters above. The table is pre-sorted by rank, so a lower value keeps the largest operators. Clamped to 1-100. |
| `includeVesselImos` | boolean | `true` | Populate `vesselImos`. Switch off for a much smaller dataset; `vesselCount` is still populated either way. |
| `includeGlobalTotals` | boolean | `true` | Attach `globalFleet` to every row. Switch off to get `globalFleet: null` and skip the extra request. |

Nothing is required. Running with no input returns all 100 carriers, fully populated.

### Output example

```json
{
 "rank": 1,
 "operator": "Mediterranean Shg Co",
 "carrierName": "MSC",
 "carrierCode": "MSC",
 "companyId": "289",
 "companyRefId": "157581",
 "website": "https://www.msc.com/en/search-a-schedule",
 "flagIconUrl": "https://static.axsmarine.com/images/flags/big/ch.png",
 "notes": "MSC includes WEC Lines, Log-In Logistica",
 "totalTeu": 7389280,
 "totalShips": 1010,
 "ownedTeu": 4737110,
 "ownedShips": 759,
 "charteredTeu": 2652170,
 "charteredShips": 251,
 "charteredSharePercent": 35.9,
 "orderbookTeu": 2935318,
 "orderbookShips": 166,
 "orderbookSharePercent": 39.7,
 "marketSharePercent": 21.5,
 "top30": true,
 "vesselImos": ["9453298", "9463205", "9142447"],
 "vesselCount": 1010,
 "globalFleet": {
 "activeVessels": 7629,
 "activeTeu": 34594537,
 "activeDwt": 411462664,
 "fullyCellularVessels": 6812,
 "fullyCellularTeu": 34175555,
 "transatlanticTeu": 153697,
 "transpacificTeu": 601579,
 "europeTeu": 553910
 },
 "scrapedAt": "2026-08-21T12:00:00.000Z"
}
```

(`vesselImos` is truncated above for readability; a real record carries the full fleet.)

### API example

```bash
curl -X POST "https://api.apify.com/v2/acts/arman-bd~alphaliner-carrier-fleet-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
 -H "Content-Type: application/json" \
 -d '{
 "minTotalTeu": 500000,
 "maxCarriers": 30
 }'
```

### JavaScript example

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('arman-bd/alphaliner-carrier-fleet-scraper').call({
 carriers: ['MSC', 'Maersk'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
for (const c of items) console.log(`#${c.rank} ${c.carrierName}: ${c.totalTeu.toLocaleString()} TEU, ${c.vesselCount} ships`);
```

### Notes

- The table has exactly 100 rows and no pagination: one run reads all of them in a single request.
- `rank` is derived from the table's own sort order (largest fleet first), not copied from the source's own rank field, which is only populated for the top 20 rows.
- `globalFleet` reflects the total active cellular container fleet, not just the Top 100. It is the same on every row in a given run because it is a single global figure, not a per-carrier one.
- `notes` sometimes lists subsidiary brands folded into the parent operator's Top 100 entry (for example, MSC's entry covers WEC Lines and Log-In Logistica too), which is useful context when reconciling against a brand-level list.
- This table is refreshed by its source on a weekly cadence, so daily runs will usually return identical or near-identical figures. A weekly schedule matches how often the numbers actually move.
- Attribute Alphaliner/AXSMarine as the source of this data; it is not licensed for resale as a bulk feed.

### FAQ

**Do I need an account or API key?** No. No credentials are required to use this Actor.

**How far back does this go?** This is always the current snapshot. For history, run on a schedule (weekly matches the source's own update cadence) and key your own archive on `scrapedAt`.

**Why is `vesselCount` sometimes different from `totalShips`?** `vesselCount` counts the IMO numbers actually listed in the fleet string; `totalShips` is the source's own operated-ship count. They normally match; a handful of the smallest operators carry no vessel list at all, in which case `vesselCount` is `0`.

**Can I get owned and chartered fleets as separate vessel lists?** No, `vesselImos` is the combined operated fleet. The owned/chartered split is only available as TEU and ship counts (`ownedTeu`/`ownedShips` vs `charteredTeu`/`charteredShips`), not per-vessel.

**Does `top30` change if I filter with `carriers` or `minTotalTeu`?** No. `top30` reflects the carrier's true rank in the full 100-row table, regardless of which rows your filters keep.

**Can I plug it into something else?** Yes. Apify API, the client libraries, webhooks, scheduled runs, dataset exports to JSON, CSV or Excel, or MCP. The output is structured JSON.

# Actor input Schema

## `carriers` (type: `array`):

Keep only carriers whose operator or brand name contains one of these terms (case-insensitive substring match). Leave empty to keep all 100.

## `minTotalTeu` (type: `integer`):

Drop carriers whose total operated TEU (owned + chartered) is below this. Rank 100 currently sits at roughly 6,900 TEU and rank 1 above 7,000,000, so this is a wide range. 0 keeps everyone.

## `maxCarriers` (type: `integer`):

Stop after saving this many carriers, counted after the filters above are applied. The table is already sorted by rank (largest fleet first), so a lower value keeps the top of the list.

## `includeVesselImos` (type: `boolean`):

Include the 'vesselImos' array, the full list of IMO numbers for every ship in that carrier's operated fleet. Switch off for a much smaller dataset when you only need the summary numbers; 'vesselCount' is still populated either way.

## `includeGlobalTotals` (type: `boolean`):

Attach the 'globalFleet' object (total active cellular fleet vessels/TEU/DWT and transatlantic/transpacific/Europe trade capacity) to every row. These figures are the same on every carrier's record; switch off to skip the extra request and get 'globalFleet: null' instead.

## Actor input object example

```json
{
  "carriers": [
    "MSC",
    "Maersk",
    "CMA CGM"
  ],
  "minTotalTeu": 0,
  "maxCarriers": 100,
  "includeVesselImos": true,
  "includeGlobalTotals": true
}
```

# Actor output Schema

## `items` (type: `string`):

Every carrier record the run produced.

## `runsummary` (type: `string`):

The RUN\_SUMMARY record from the run's key-value store.

# 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("arman-bd/alphaliner-carrier-fleet-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 = {}

# Run the Actor and wait for it to finish
run = client.actor("arman-bd/alphaliner-carrier-fleet-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 '{}' |
apify call arman-bd/alphaliner-carrier-fleet-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arman-bd/alphaliner-carrier-fleet-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/79bf5X92sLFlcjslu/builds/fJWEwkKHehhiPAnRZ/openapi.json