# Singapore Port Congestion & Trade Signal Radar (`mai_amm/singapore-port-congestion-trade-signal-radar`) Actor

Monitor Singapore port congestion pressure, trade activity, and shipping disruption signals using official statistics, optional AIS data, and optional news signals.

- **URL**: https://apify.com/mai\_amm/singapore-port-congestion-trade-signal-radar.md
- **Developed by:** [wiseld\_squid](https://apify.com/mai_amm) (community)
- **Categories:** E-commerce, News, Automation
- **Stats:** 4 total users, 3 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 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.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

## Singapore Port Congestion & Trade Signal Radar

Scrape Singapore-area vessel positions and add port congestion risk signals.

### What This Actor Does

This Actor works like a Singapore marine traffic scraper with extra intelligence fields. It returns vessel rows from the Singapore port and Singapore Strait area, then enriches each row with congestion score, risk level, pressure signal, and a plain-English recommendation.

It answers:

- Which vessels are currently visible around Singapore port and the Singapore Strait?
- Is congestion pressure increasing?
- Are trade flows strong, normal, or weak?
- Are there disruption signals logistics teams should watch?
- Should teams take action now?

### Simple Input

The default settings are ready to run. No AIS API key is required. AIS coverage includes Singapore port and the wider Singapore Strait area.

```json
{
  "lookbackMonths": 24,
  "includeNewsSignals": true,
  "includeAIS": true,
  "maxVessels": 1000,
  "alertThreshold": 70
}
````

### Input Fields

- `lookbackMonths` - Number of months to analyze.
- `includeNewsSignals` - Add shipping disruption news signals.
- `includeAIS` - Add vessel-density and slow-vessel signals.
- `maxVessels` - Maximum vessel rows to save. Default is 1,000.
- `alertThreshold` - Score level that triggers an alert.

### Output

The Actor returns vessel rows, similar to a MarineTraffic scraper:

- 1 dataset result = 1 vessel
- Each vessel row includes Singapore port radar context, such as congestion score, risk level, pressure signal, and recommended action.
- The full Markdown intelligence brief is saved separately as `REPORT.md`.

Each vessel row can include:

- `vessel_name`
- `mmsi`
- `imo`
- `vessel_type`
- `latitude`
- `longitude`
- `speed_knots`
- `destination`
- `observed_at`
- `is_slow_vessel`
- `is_stopped_or_waiting`
- `congestion_score`
- `risk_level`
- `trade_signal`
- `pressure_signal`
- `summary`
- `recommended_action`

It also saves:

- `REPORT.md`
- `SIGNALS.csv`

### Example Output

```json
{
  "row_type": "vessel",
  "date": "2026-05-21",
  "observed_at": "2026-05-21T10:12:47.000Z",
  "port": "Singapore",
  "source": "MarineTraffic public AIS map scraper",
  "vessel_name": "EXAMPLE VESSEL",
  "mmsi": "563123456",
  "vessel_type": "Cargo",
  "latitude": 1.263,
  "longitude": 103.821,
  "speed_knots": 0.8,
  "is_slow_vessel": true,
  "is_stopped_or_waiting": true,
  "congestion_score": 71,
  "risk_level": "high",
  "trade_signal": "normal",
  "pressure_signal": "disrupted",
  "summary": "Singapore port pressure is elevated. Vessel-density or throughput indicators are above normal, and logistics teams should monitor potential delays.",
  "recommended_action": "Monitor freight bookings, ETA buffers, and possible routing alternatives over the next 7 days."
}
```

If AIS is unavailable, the Actor returns a single `report` row instead of vessel rows.

### Use Cases

- Freight forwarders monitoring delay risk
- Importers and exporters watching supply-chain pressure
- Shipping analysts tracking Singapore port activity
- Market researchers monitoring Southeast Asia trade flow
- Newsletter writers creating shipping intelligence briefs
- Traders watching bunker and container activity

### Notes

- Official port statistics are monthly.
- Vessel and news signals can change between runs.
- Each dataset result is normally one vessel row.
- The report still uses official port statistics and news signals, but those are saved as context instead of separate dataset rows.
- Result count depends on live vessel density and your `maxVessels` setting.
- Free preview runs are limited to 10 vessel rows.
- Pricing works naturally as results-based usage because vessel rows are the main dataset output.
- If a live source is unavailable, the Actor continues with the remaining sources and adds a warning.
- This Actor provides operational signals, not financial or logistics advice.

# Actor input Schema

## `lookbackMonths` (type: `integer`):

How many months of official Singapore port statistics to analyze.

## `includeNewsSignals` (type: `boolean`):

Automatically search disruption-related shipping news using Google News RSS. No API key required.

## `includeAIS` (type: `boolean`):

Automatically scrape Singapore port and Singapore Strait vessel signals from public MarineTraffic map tiles. No AIS API key required.

## `maxVessels` (type: `integer`):

Maximum vessel rows to save. Lower values reduce result count and run cost; higher values return more AIS detail when available.

## `alertThreshold` (type: `integer`):

Congestion score threshold that triggers a congestion alert.

## Actor input object example

```json
{
  "lookbackMonths": 24,
  "includeNewsSignals": true,
  "includeAIS": true,
  "maxVessels": 1000,
  "alertThreshold": 70
}
```

# Actor output Schema

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

Dataset items. One result is one Singapore-area vessel row with congestion score, risk level, pressure signal, and recommendation context.

## `report` (type: `string`):

Business-readable Singapore port congestion and trade signal report.

## `signalsCsv` (type: `string`):

CSV summary of the latest congestion, trade, vessel, and news signals.

# 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("mai_amm/singapore-port-congestion-trade-signal-radar").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("mai_amm/singapore-port-congestion-trade-signal-radar").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 mai_amm/singapore-port-congestion-trade-signal-radar --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=mai_amm/singapore-port-congestion-trade-signal-radar",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Singapore Port Congestion & Trade Signal Radar",
        "description": "Monitor Singapore port congestion pressure, trade activity, and shipping disruption signals using official statistics, optional AIS data, and optional news signals.",
        "version": "1.0",
        "x-build-id": "USnPyvoZqOjqH3W3k"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mai_amm~singapore-port-congestion-trade-signal-radar/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mai_amm-singapore-port-congestion-trade-signal-radar",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/mai_amm~singapore-port-congestion-trade-signal-radar/runs": {
            "post": {
                "operationId": "runs-sync-mai_amm-singapore-port-congestion-trade-signal-radar",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/mai_amm~singapore-port-congestion-trade-signal-radar/run-sync": {
            "post": {
                "operationId": "run-sync-mai_amm-singapore-port-congestion-trade-signal-radar",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "lookbackMonths": {
                        "title": "Lookback months",
                        "minimum": 6,
                        "maximum": 120,
                        "type": "integer",
                        "description": "How many months of official Singapore port statistics to analyze.",
                        "default": 24
                    },
                    "includeNewsSignals": {
                        "title": "Include auto news signals",
                        "type": "boolean",
                        "description": "Automatically search disruption-related shipping news using Google News RSS. No API key required.",
                        "default": true
                    },
                    "includeAIS": {
                        "title": "Include AIS vessel signals",
                        "type": "boolean",
                        "description": "Automatically scrape Singapore port and Singapore Strait vessel signals from public MarineTraffic map tiles. No AIS API key required.",
                        "default": true
                    },
                    "maxVessels": {
                        "title": "Max vessel rows",
                        "minimum": 100,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum vessel rows to save. Lower values reduce result count and run cost; higher values return more AIS detail when available.",
                        "default": 1000
                    },
                    "alertThreshold": {
                        "title": "Alert threshold",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Congestion score threshold that triggers a congestion alert.",
                        "default": 70
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
