# OOCL Cargo Tracking Scraper (`muhammetakkurtt/oocl-cargo-tracking-scraper`) Actor

Track OOCL containers, bills of lading, and booking numbers in bulk. Extract real-time cargo status, routing, vessels, ports, release and customs clearance data. Export OOCL shipment tracking results as JSON, CSV, or Excel. Connect to logistics dashboards via API, webhooks, and integrations.

- **URL**: https://apify.com/muhammetakkurtt/oocl-cargo-tracking-scraper.md
- **Developed by:** [Muhammet Akkurt](https://apify.com/muhammetakkurtt) (community)
- **Categories:** Automation, Developer tools, Integrations
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $5.00 / 1,000 tracking 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/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

![OOCL Container Tracking and Shipment Data Scraper](https://i.postimg.cc/5tf5w0qB/oocl-banner.png)

## OOCL Cargo Tracking Scraper

### What does OOCL Cargo Tracking Scraper do?

**OOCL Cargo Tracking Scraper** is an automated OOCL container tracking and shipment tracking API. Enter a container number, bill of lading number, or booking reference and receive structured cargo data covering shipment identifiers, release and customs status, containers, routes, vessels, ports, and the latest carrier event.

Use the Actor to track OOCL shipments in bulk, export carrier data to JSON, CSV, or Excel, and connect OOCL tracking results to logistics dashboards, transport management systems, alerts, schedules, and custom applications.

The Actor sends each submitted reference to the OOCL cargo tracking service, validates the response, and stores one dataset item for every successful shipment lookup. It supports:

- 📦 **OOCL container tracking** using container references
- 📄 **OOCL bill of lading tracking** for shipment visibility
- 🗂️ **Booking number tracking** from the same input field
- 🚢 **Container routing and vessel data** supplied by OOCL
- ✅ **Cargo release and freight release status** monitoring
- 🛃 **Inbound customs and advanced manifest status** collection
- 🔌 **OOCL tracking API access** through Apify
- ⏰ **Scheduled cargo monitoring** for recurring status checks

The scraper processes multiple references in parallel batches and retries temporary errors with proxy rotation when needed.

### Why scrape OOCL shipment data?

Carrier websites are convenient for occasional checks but inefficient for operational shipment monitoring. Automated OOCL cargo tracking can help freight forwarders, importers, exporters, customs teams, logistics providers, and supply chain software companies:

- Check multiple OOCL shipments in a single run
- Monitor release, manifest, and customs clearance indicators
- Populate internal shipment records with structured carrier data
- Create customer-facing tracking dashboards
- Trigger notifications when the latest shipment event changes
- Schedule recurring container checks without manual work
- Export OOCL tracking data for auditing and analysis

### What data can you extract from OOCL?

| Data field | Description |
|---|---|
| `tracking_number` | Container, B/L, or booking reference submitted in the input |
| `type` | Reference or shipment type reported by OOCL |
| `billOfLadingNumber` | Bill of lading number associated with the shipment |
| `bookingNumber` | OOCL booking reference |
| `cargoReleaseStatus` | Cargo release status |
| `freightChargeReleaseStatus` | Freight-charge release status |
| `inboundCustomsClearanceStatus` | Inbound customs clearance indicator |
| `advancedManifest` | Advanced manifest information or status |
| `containers` | Containers associated with the tracked shipment |
| `containerNumber` | Individual container identifier |
| `routing` | Routing legs, ports, vessels, voyages, and schedule information |
| `latestEvent` | Latest event reported for the container |

OOCL can return different fields depending on the reference type and shipment stage. The Actor keeps the complete `data` object so integrations do not lose carrier-specific details.

### Ready-to-Run Examples

Get started in seconds — open the example in the Apify Console and click **Run**:

- **[Track OOCL Containers by Container Number](https://apify.com/muhammetakkurtt/oocl-cargo-tracking-scraper/examples/track-oocl-containers-by-container-number)** — enter a container number and get its routing, release and customs statuses, container details, and latest event.

### How to track OOCL shipments step by step

1. Open the Actor in Apify Console.
2. Add container, bill of lading, or booking references under **Tracking Numbers**.
3. Enter one reference per line.
4. Click **Start**.
5. Review the results in the **Output** tab or retrieve the dataset through the API.

#### Example input

```json
{
  "trackingNumbers": [
    "OOLU2748657830"
  ]
}
```

#### OOCL tracking input parameters

| Parameter | Type | Required | Description |
|---|---|---|---|
| `trackingNumbers` | Array of strings | Yes | OOCL container, bill of lading, or booking references; one per line |

### OOCL Cargo Tracking Scraper output example

Each successful reference creates one dataset record. The example below is shortened and uses illustrative values:

```json
{
  "tracking_number": "OOLU2748657830",
  "data": {
    "type": "CONTAINER",
    "billOfLadingNumber": "EXAMPLE-BL",
    "bookingNumber": "EXAMPLE-BOOKING",
    "cargoReleaseStatus": "AVAILABLE",
    "containers": [
      {
        "containerNumber": "OOLU2748657830",
        "latestEvent": {
          "location": "EXAMPLE PORT",
          "time": "2026-07-01T06:18:55Z",
          "event": "VESSEL DEPARTED"
        },
        "routing": {}
      }
    ]
  }
}
```

Actual status labels and nested routing fields come directly from OOCL and can vary by shipment. Unknown references are skipped and do not create a `tracking-result` charge event.

### Integrations and OOCL tracking API

Apify provides the infrastructure required to use OOCL tracking data in production workflows:

- **API access** from Python, JavaScript, cURL, or any HTTP client
- **Scheduled runs** for recurring container and shipment monitoring
- **Webhooks** to trigger downstream automation when a run finishes
- **Integrations** with Google Sheets, Slack, Zapier, Make, and other services
- **Dataset exports** in JSON, CSV, Excel, XML, HTML, or RSS

### Frequently asked questions

#### Is it legal to scrape OOCL?

The Actor retrieves shipment tracking information using references supplied by the user. Only query shipments you are authorized to access, and ensure your use complies with applicable laws and carrier terms. This Actor is independent and is not affiliated with or endorsed by OOCL.

#### Can I track multiple shipments at once?

Yes. Add multiple references to the input. The Actor processes them in parallel batches and saves one item per successful reference.

#### What types of tracking numbers are supported?

The Actor accepts container numbers, bill of lading numbers, and booking references through the same `trackingNumbers` input.

#### What if a tracking number is not found?

The Actor logs a warning, skips the reference, and does not create an empty output record or result charge.

#### How do I get support or report issues?

Open the **Issues** tab on the Actor page and include the Apify run ID and non-sensitive log context. Do not share API tokens or confidential documents.

# Actor input Schema

## `trackingNumbers` (type: `array`):

The numbers to track — one per line. Container, B/L and booking numbers are all accepted.

## Actor input object example

```json
{
  "trackingNumbers": [
    "OOLU2748657830"
  ]
}
```

# Actor output Schema

## `results` (type: `string`):

Collected OOCL shipment tracking data, one item per tracking number

# 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("muhammetakkurtt/oocl-cargo-tracking-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("muhammetakkurtt/oocl-cargo-tracking-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 muhammetakkurtt/oocl-cargo-tracking-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,muhammetakkurtt/oocl-cargo-tracking-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/nV4VqPL9EpLxcobCH/builds/nADCAifqk4FfqWkTI/openapi.json