# USCG PSIX Vessel Incident Scraper (`acquistion-automation/uscg-psix-vessel-incidents-scraper`) Actor

Scrapes USCG PSIX vessel incident reports by vessel name and returns each incident as a flat row with date, location, nature of the case, and vessel details. Export to CSV, JSON, Excel, or XML.

- **URL**: https://apify.com/acquistion-automation/uscg-psix-vessel-incidents-scraper.md
- **Developed by:** [Acquisition Automation Co.](https://apify.com/acquistion-automation) (community)
- **Categories:** Other, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $19.00 / 1,000 result items

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

![Acquisition Automation Co. Search less. Close more.](https://api.apify.com/v2/key-value-stores/AOdPHdOpeDpzEPS5f/records/banner.jpg)

## 🚢 USCG PSIX Vessel Registry Scraper

> **Look up any vessel in the official U.S. Coast Guard registry and get its record as a flat row.** Search by name and the Actor returns every matching vessel with its official number, hull identification number, call sign, flag, service type, status and build year. No API key, no registration, no login.

The Coast Guard publishes the Port State Information Exchange, known as PSIX, at `cgmix.uscg.mil`. It is the authoritative record of vessels documented in the United States. The site answers one name at a time through a search form, there is no bulk download, and nothing on the page can be exported. This Actor drives that search for you and writes every matching vessel into a dataset you can open in a spreadsheet.

| Who uses it | What they use the registry for |
|---|---|
| 🛥 Buyers of marine businesses | Confirming the boats on a seller's asset list are documented, active and the age the seller claims |
| 📋 Marine lenders and insurers | Verifying official number, hull identification number and flag before writing a policy or a loan |
| ⚓ Fleet and compliance teams | Keeping an internal vessel list matched to the Coast Guard's own record |
| 📰 Researchers and journalists | Building a dataset of documented vessels by name pattern, service type or build year |

### 📋 What it does

> 💡 **Why it matters:** in a deal that includes vessels, the registry is the cheapest way to check that what is written on the asset schedule is real. One search per name, in bulk, exported.

- 🔎 **Searches PSIX by vessel name.** Partial names work. Searching `liberty` returns `LIBERTY CALL`, `A S LIBERTY` and every other match.
- 🆔 **Returns the identifiers that matter.** Official number, hull identification number and call sign, which are what a title search, a lien check or an insurance file will ask for.
- 🏴 **Flag, service and status.** Whether the vessel is active, what it is registered to do, and which country flags it.
- 📅 **Build year**, as the Coast Guard records it rather than as the seller remembers it.
- 📦 **One row per vessel**, the same fields every run, so results from several searches append into a single clean dataset.
- 💾 **Exports to CSV, Excel, JSON or XML**, from the run page or the API.

### 📊 Output

Every vessel is one flat row. `N/A` means the Coast Guard publishes no value for that field, and `null` means the field did not appear for that record.

| Field | Type | Description |
|---|---|---|
| 🚢 `vesselName` | string | Vessel name exactly as the Coast Guard records it |
| ✅ `serviceStatus` | string | Registry status, for example `Active` |
| 🆔 `vin` | string | The vessel's official Coast Guard number |
| 🔤 `callSign` | string | Radio call sign, where one is assigned |
| 🏷 `hin` | string | Hull identification number, the vessel equivalent of a VIN |
| ⚙️ `service` | string | Registered service, for example `Recreational` |
| 🏴 `flag` | string | Flag state, for example `UNITED STATES` |
| 📅 `buildYear` | string | Year of build as recorded |
| 🔗 `sourceUrl` | string | The PSIX search page the row came from |
| 🕒 `scrapedAt` | string | ISO timestamp of collection |
| ⚠️ `error` | string | `null` on a normal row |
| 🔧 `detailButton` | string | Internal control id for the row's detail page. Kept for traceability, of no use in analysis |

#### Example rows

```json
{
  "vesselName": "LIBERTY CALL",
  "serviceStatus": "Active",
  "vin": "1141956",
  "callSign": "N/A",
  "hin": "HG000191L203",
  "service": "Recreational",
  "flag": "UNITED STATES",
  "buildYear": "2003",
  "sourceUrl": "https://cgmix.uscg.mil/PSIX/PSIXSearch.aspx",
  "scrapedAt": "2026-09-14T17:33:05.065Z",
  "error": null
}
```

```json
{
  "vesselName": "A S LIBERTY",
  "serviceStatus": "Active",
  "vin": "CG1195029",
  "callSign": "N/A",
  "hin": null,
  "service": null,
  "flag": "UNKNOWN",
  "buildYear": "N/A",
  "sourceUrl": "https://cgmix.uscg.mil/PSIX/PSIXSearch.aspx",
  "scrapedAt": "2026-09-14T17:33:05.228Z",
  "error": null
}
```

### ✨ Why choose this Actor

| | What you get |
|---|---|
| **The official record** | Data comes from the Coast Guard's own database, not from a broker listing or a tracking site. |
| **No credentials** | The PSIX search is public. No API key, no account, no rate-limit negotiation. |
| **Bulk instead of one at a time** | The site answers one name per search. Here you set a limit and walk away. |
| **The same fields every run** | Append a hundred searches into one dataset without cleaning columns. |
| **You pay per row** | No subscription. A search that returns nothing costs nothing. |

### 🚀 How to use it

1. [Create a free Apify account](https://console.apify.com/sign-up). New accounts start with $5 of credit.
2. Open the Actor and select **Try for free**.
3. Type a vessel name, or part of one, into `vesselName`.
4. Set `maxItems` to cap the run.
5. Select **Start**, then export from the **Dataset** tab as CSV, Excel, JSON or XML.

A first run:

```json
{
  "vesselName": "liberty",
  "maxItems": 10
}
```

A larger pull:

```json
{
  "vesselName": "liberty",
  "maxItems": 200
}
```

### ⚙️ Input

| Field | Required | Description |
|---|---|---|
| `vesselName` | No | Vessel name or part of one. PSIX matches on substrings |
| `maxItems` | No | Maximum rows to collect in a run, from 1 to 1,000,000 |

### 💰 Pricing

Pay per result. No subscription, and no Apify platform usage on top.

| Apify plan | Free | Bronze | Silver | Gold | Platinum | Diamond |
|---|---|---|---|---|---|---|
| Per vessel row | $0.021 | $0.0203 | $0.0197 | $0.019 | $0.019 | $0.019 |

| Rows collected | Cost on the Free plan |
|---|---|
| 100 | $2.10 |
| 1,000 | $21.00 |
| 10,000 | $210.00 |

**Free plan runs** return up to 10 rows as a preview. Any paid Apify plan lifts that to 1,000,000 per run.

### 🔌 Integrate with any app

The dataset is available through the Apify API as soon as the run finishes. Use `run-sync-get-dataset-items` for a one-shot call, webhooks to trigger what happens next, or the Make, Zapier, Airbyte and LangChain integrations listed on the Actor page.

### 🤖 Use with an AI agent

Give an agent live access to the registry over the Model Context Protocol:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=acquistion-automation/uscg-psix-vessel-incidents-scraper"
```

Then ask it in plain language to look a vessel up and read the result back.

### ❓ Frequently asked questions

**Does this return accidents, casualties or inspection reports?**
No. It returns the registry record for each vessel: identifiers, flag, service, status and build year. Inspection and casualty history lives on the PSIX detail page, which this Actor does not open.

**Why did I get several vessels for one name?**
PSIX matches substrings. A search for `liberty` returns every documented vessel whose name contains it. Filter the dataset afterwards, or search a more specific name.

**Why is a field `N/A` or empty?**
The Coast Guard does not publish every field for every vessel. `N/A` is what the page itself shows. `null` means the field was absent from that record.

**Which vessels are in PSIX?**
Vessels documented in the United States, and foreign vessels that have called at U.S. ports. A pleasure boat registered only with a state will usually not appear.

**Do I need a proxy?**
No. Requests and retries are handled inside the Actor and included in the price.

**What can I export?**
CSV, Excel, JSON and XML from the run page, or JSON straight from the API.

### 🔗 More from Acquisition Automation Co.

- [SAM.gov Contract Opportunities Scraper](https://apify.com/acquistion-automation/sam-gov-contracts-scraper)
- [PublicSurplus Scraper](https://apify.com/acquistion-automation/publicsurplus-scraper)
- [IRS Exempt Organizations Scraper](https://apify.com/acquistion-automation/irs-eo-master-file-scraper)
- [Clutch Agencies Scraper](https://apify.com/acquistion-automation/clutch-agencies-scraper)
- [BizBuySell Scraper](https://apify.com/acquistion-automation/bizbuysell-scraper)

### About Acquisition Automation Co.

We build automation for people buying businesses. The repetitive part of an acquisition search, checking listings, pulling public records, tracking owners and assets, is work a machine should do, so the buyer's time goes into judging deals instead of collecting them.

We add new Actors regularly. If there is a source you need and do not see here, tell us.

### 🆘 Support

Open an issue in the **Issues** tab of this Actor with your run ID, the input you used, and what you expected to get back.

### ⚠️ Disclaimer

This Actor is independent and is not affiliated with, endorsed by, or sponsored by the United States Coast Guard or any government agency. It collects only publicly available data. You are responsible for using that data in compliance with the source's terms of service and applicable law.

# Actor input Schema

## `vesselName` (type: `string`):

Vessel name

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

Maximum number of incidents to collect per run.

## Actor input object example

```json
{
  "vesselName": "liberty",
  "maxItems": 10
}
```

# Actor output Schema

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

Scraped records.

# 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 = {
    "vesselName": "liberty",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("acquistion-automation/uscg-psix-vessel-incidents-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 = {
    "vesselName": "liberty",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("acquistion-automation/uscg-psix-vessel-incidents-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 '{
  "vesselName": "liberty",
  "maxItems": 10
}' |
apify call acquistion-automation/uscg-psix-vessel-incidents-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,acquistion-automation/uscg-psix-vessel-incidents-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/ANdTDhx7wqh07MEUd/builds/PVGvvQCzn6iej143l/openapi.json