# Strait of Hormuz Intelligence Feed (`mai_amm/strait-of-hormuz-intelligence-feed`) Actor

Scrape Strait of Hormuz vessel positions and add tanker flow, oil chokepoint, and maritime risk signals from public AIS map data and shipping news.

- **URL**: https://apify.com/mai\_amm/strait-of-hormuz-intelligence-feed.md
- **Developed by:** [wiseld\_squid](https://apify.com/mai_amm) (community)
- **Categories:** News, E-commerce, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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

## Strait of Hormuz Intelligence Feed

Scrape Strait of Hormuz vessel positions and enrich each result with tanker flow, oil chokepoint, and maritime risk signals.

### What This Actor Does

This Actor works like a Hormuz AIS and tanker traffic scraper with extra intelligence fields. It returns vessel rows from the Strait of Hormuz, Gulf of Oman approach, and Persian Gulf approach, then enriches each row with risk score, tanker classification, movement direction, slow/stopped vessel flags, news risk, and a plain-English recommendation.

It answers:

- Which vessels and tankers are currently visible around the Strait of Hormuz?
- Are tankers moving slowly or stopping near the transit corridor?
- Is visible tanker flow inbound, outbound, or mixed?
- Are shipping or geopolitical news signals elevated?
- Should risk teams monitor this chokepoint more closely?

### Simple Input

The default settings are ready to run. No AIS API key is required.

```json
{
  "includeNewsSignals": true,
  "includeAIS": true,
  "maxVessels": 100,
  "tankersOnly": false,
  "alertThreshold": 70
}
````

### Input Fields

- `includeNewsSignals` - Add Hormuz, tanker, and maritime security news signals.
- `includeAIS` - Add public AIS/map vessel-density and slow-vessel signals.
- `maxVessels` - Maximum vessel rows to save. Default is 100.
- `tankersOnly` - Save only tanker-related vessels to the dataset.
- `alertThreshold` - Risk score level that triggers an alert.

### Output

The Actor returns vessel rows:

- 1 dataset result = 1 vessel
- Each vessel row includes Hormuz risk context, tanker flow signal, risk score, and recommended action.
- The full Markdown intelligence brief is saved separately as `REPORT.md`.

Each vessel row can include:

- `vessel_name`
- `mmsi`
- `imo`
- `source_ship_id`
- `vessel_type`
- `is_tanker`
- `tanker_category`
- `latitude`
- `longitude`
- `speed_knots`
- `course`
- `direction`
- `zone_segment`
- `zone_segments`
- `tanker_zone_segments`
- `destination`
- `is_slow_vessel`
- `is_stopped_or_waiting`
- `risk_score`
- `risk_level`
- `tanker_flow_signal`
- `pressure_signal`
- `news_risk_signal`
- `summary`
- `recommended_action`

It also saves:

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

### Sources

- Public AIS/map tile signals for visible vessel positions.
- Google News RSS for Hormuz, tanker, and maritime disruption keywords.
- EIA World Oil Transit Chokepoints for static oil chokepoint context.
- IEA Strait of Hormuz oil security context for strategic importance and LNG exposure.

### Zone Segments

The Actor classifies each vessel into one approximate monitoring segment:

- `hormuz_transit_corridor`
- `fujairah_anchorage`
- `gulf_of_oman_approach`
- `persian_gulf_approach`
- `uae_oman_coastal_staging`
- `outer_monitoring_area`

### Example Output

```json
{
  "row_type": "vessel",
  "date": "2026-05-22",
  "observed_at": "2026-05-22T10:12:47.000Z",
  "zone": "Strait of Hormuz",
  "source": "Public AIS map tile scraper",
  "vessel_name": "EXAMPLE TANKER",
  "mmsi": "422123456",
  "vessel_type": "Oil Tanker",
  "latitude": 26.18,
  "longitude": 56.32,
  "speed_knots": 2.4,
  "course": 105,
  "direction": "eastbound_outbound_to_gulf_of_oman",
  "is_tanker": true,
  "tanker_category": "oil_tanker",
  "is_slow_vessel": true,
  "is_stopped_or_waiting": false,
  "risk_score": 74,
  "risk_level": "high",
  "tanker_flow_signal": "declining",
  "pressure_signal": "stretched",
  "news_risk_signal": "medium",
  "summary": "Strait of Hormuz tanker and vessel risk is elevated. Vessel-density, slow movement, tanker concentration, or disruption news signals should be monitored closely.",
  "recommended_action": "Increase monitoring frequency and review tanker, insurance, and route exposure around the Hormuz transit corridor."
}
```

If AIS is unavailable, the Actor still saves `REPORT.md` and `SIGNALS.csv` with warnings.

### Use Cases

- Energy market researchers monitoring oil chokepoint risk
- Maritime risk teams watching tanker movement
- Shipping analysts tracking Gulf of Oman and Persian Gulf traffic
- Insurance and compliance teams monitoring route exposure
- Newsletter writers creating maritime risk briefs
- Supply-chain risk platforms needing structured chokepoint signals

### Notes

- Public AIS/map signals can be delayed, incomplete, or unavailable.
- EIA/IEA context is static reference context, not live flow volume.
- Vessel and news signals can change between runs.
- Each dataset result is normally one vessel row.
- 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 public-source risk signals, not official security, logistics, or financial advice.

# Actor input Schema

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

Automatically search Hormuz, tanker, and maritime security news using Google News RSS. No API key required.

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

Automatically scrape Strait of Hormuz vessel signals from public AIS 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.

## `tankersOnly` (type: `boolean`):

Save only tanker-related vessels to the dataset. Overall counts still use all visible vessels.

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

Risk score threshold that triggers a chokepoint risk alert.

## `outputMode` (type: `string`):

Controls what is saved to the dataset. 'full' saves individual vessel rows, 'summary' saves a single summary row, 'report' saves the Markdown report row.

## Actor input object example

```json
{
  "includeNewsSignals": true,
  "includeAIS": true,
  "maxVessels": 100,
  "tankersOnly": false,
  "alertThreshold": 70,
  "outputMode": "full"
}
```

# Actor output Schema

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

Dataset items. One result is one Hormuz-area vessel row with risk score, tanker flow signal, pressure signal, and recommendation context.

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

Business-readable Strait of Hormuz tanker flow and maritime risk report.

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

CSV summary of the latest risk, tanker flow, 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/strait-of-hormuz-intelligence-feed").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/strait-of-hormuz-intelligence-feed").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/strait-of-hormuz-intelligence-feed --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=mai_amm/strait-of-hormuz-intelligence-feed",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Strait of Hormuz Intelligence Feed",
        "description": "Scrape Strait of Hormuz vessel positions and add tanker flow, oil chokepoint, and maritime risk signals from public AIS map data and shipping news.",
        "version": "1.0",
        "x-build-id": "OoDFEfTbQyDpbIjJb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mai_amm~strait-of-hormuz-intelligence-feed/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mai_amm-strait-of-hormuz-intelligence-feed",
                "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~strait-of-hormuz-intelligence-feed/runs": {
            "post": {
                "operationId": "runs-sync-mai_amm-strait-of-hormuz-intelligence-feed",
                "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~strait-of-hormuz-intelligence-feed/run-sync": {
            "post": {
                "operationId": "run-sync-mai_amm-strait-of-hormuz-intelligence-feed",
                "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": {
                    "includeNewsSignals": {
                        "title": "Include auto news signals",
                        "type": "boolean",
                        "description": "Automatically search Hormuz, tanker, and maritime security news using Google News RSS. No API key required.",
                        "default": true
                    },
                    "includeAIS": {
                        "title": "Include AIS vessel signals",
                        "type": "boolean",
                        "description": "Automatically scrape Strait of Hormuz vessel signals from public AIS map tiles. No AIS API key required.",
                        "default": true
                    },
                    "maxVessels": {
                        "title": "Max vessel rows",
                        "minimum": 1,
                        "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": 100
                    },
                    "tankersOnly": {
                        "title": "Tankers only",
                        "type": "boolean",
                        "description": "Save only tanker-related vessels to the dataset. Overall counts still use all visible vessels.",
                        "default": false
                    },
                    "alertThreshold": {
                        "title": "Alert threshold",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Risk score threshold that triggers a chokepoint risk alert.",
                        "default": 70
                    },
                    "outputMode": {
                        "title": "Output mode",
                        "enum": [
                            "summary",
                            "full",
                            "report"
                        ],
                        "type": "string",
                        "description": "Controls what is saved to the dataset. 'full' saves individual vessel rows, 'summary' saves a single summary row, 'report' saves the Markdown report row.",
                        "default": "full"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
