# US Coast Guard Vessel Inspections Scraper - PSIX (`scrapers_lat/uscg-psix-vessel-inspections-scraper`) Actor

Search the US Coast Guard PSIX vessel database: IMO number, call sign, flag, service type, build year, length and tonnage, certificates and class society, plus every recorded inspection with its full deficiency narratives, action codes, detentions and resolutions. JSON, CSV, Excel.

- **URL**: https://apify.com/scrapers\_lat/uscg-psix-vessel-inspections-scraper.md
- **Developed by:** [Scrapers Lat](https://apify.com/scrapers_lat) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.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.
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?

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

[![US Coast Guard Vessel Inspections Scraper](https://scrapers.lat/banners/uscg-psix-vessel-inspections-scraper.png)](https://apify.com/scrapers_lat/uscg-psix-vessel-inspections-scraper)

## US Coast Guard Vessel Inspections Scraper

Ship safety records from the US Coast Guard's public vessel database: who the hull is, how big it is, what certificates it carries, and every inspection it has been through, down to the inspector's own words on each deficiency and whether the ship was detained.

This is the record buyers usually have to pay a maritime data terminal for. It comes back structured, filterable and ready to score.

Here is one real result, trimmed to show the shape of the output:

```json
{
  "vesselId": "1162376",
  "vesselName": "CMB POMEROL",
  "callSign": "3FSK9",
  "imoNumber": "9598335",
  "officialNumber": null,
  "identificationType": "IMO Number",
  "flag": "PANAMA",
  "serviceType": "Freight Ship",
  "serviceSubType": "Bulk Carrier",
  "status": "Active",
  "isActive": true,
  "buildYear": 2012,
  "vesselAgeYears": 14,
  "lengthFeet": 770.9,
  "lengthMeters": 234.97,
  "lengthBetweenPerpendicularsFeet": 744.8,
  "breadthFeet": 124.7,
  "breadthMeters": 38.01,
  "depthFeet": 65.3,
  "draftFeet": 47.5,
  "grossTonnage": 50617,
  "netTonnage": 31470,
  "deadweightTons": 95731,
  "displacementTons": 110378,
  "classificationSocieties": ["NKK"],
  "certificateCount": 13,
  "activeCertificateCount": 4,
  "expiredCertificateCount": 9,
  "nextCertificateExpiry": null,
  "certificates": [
    {
      "type": "ISM - Safety Management Certificate",
      "issuedBy": "NKK",
      "status": "EXPIRED",
      "issueDate": "2017-07-04",
      "expiryDate": "2022-06-15"
    }
  ],
  "inspectionCount": 4,
  "portStateControlInspectionCount": 3,
  "inspectionsWithDeficiencies": 1,
  "deficiencyCount": 1,
  "unresolvedDeficiencyCount": 0,
  "deficienciesPerInspection": 0.25,
  "detentionCount": 0,
  "detentionDeficiencyCount": 0,
  "hasDetention": false,
  "firstInspectionDate": "2013-08-19",
  "lastInspectionDate": "2019-10-22",
  "lastDetentionDate": null,
  "daysSinceLastInspection": 2496,
  "deficiencySystems": [
    { "system": "06 - Cargo Operations Including Equipment", "count": 1 }
  ],
  "inspectionPorts": ["Mobile, Alabama", "Baltimore, Maryland"],
  "inspections": [
    {
      "activityId": "6420994",
      "date": "2019-10-21",
      "type": "Vessel Inspection",
      "status": "Closed",
      "outcome": "Approved Inspection",
      "port": "Mobile, Alabama",
      "isPortStateControl": true,
      "deficiencyCount": 1,
      "unresolvedDeficiencyCount": 0,
      "detentionDeficiencyCount": 0,
      "wasDetained": false,
      "deficiencies": [
        {
          "description": "When transporting a solid bulk cargo which is liable to emit a toxic or flammable gas, or cause oxygen depletion in the cargo space, an appropriate instrument for measuring the concentration of gas or oxygen in the air shall be provided together with detailed instructions for its use. PSCO noted that the calibration gas has been expired since May 2013. Manual for gas detector specifies that expired gas shall not be used. SOLAS (14) VI/3.1",
          "system": "06 - Cargo Operations Including Equipment",
          "component": "06105 - Atmosphere testing instruments",
          "action": "17 - Rectify deficiencies prior to departure",
          "actionCode": "17",
          "isDetention": false,
          "isResolved": true,
          "resolutionDate": "2019-10-22"
        }
      ]
    }
  ],
  "psixUrl": "https://cgmix.uscg.mil/PSIX/PSIXDetails.aspx?VesselID=1162376",
  "scrapedAt": "2026-08-22T22:04:11.902Z"
}
```

### What you get

**Vessel identity** — name, IMO number, official number, call sign, flag state, service type and sub-type (crude oil tank ship, bulk carrier, passenger ship, offshore supply vessel and the rest), registry status and build year, with age already calculated.

**Size** — overall length and length between perpendiculars, breadth, moulded depth and design draft, in feet and in metres. Gross, net, deadweight and displacement tonnage, normalised. Gross and net are filed by the registry under unit labels rather than names, so most exports of this data lose them entirely; here they come back as plain `grossTonnage` and `netTonnage`.

**Certificates** — the document file with issue and expiry dates and the issuing organisation: safety management (ISM), load line, oil and air pollution prevention (IOPP, IAPP), classification documents, certificates of inspection. `classificationSocieties` pulls out the class society, and `nextCertificateExpiry` and `daysToNextCertificateExpiry` tell you what lapses next.

**Inspection history** — every recorded inspection with its date, type, outcome, Coast Guard zone port, and a flag marking the Port State Control exams that drive foreign-flag targeting.

**Deficiency detail** — this is the part that matters. Each deficiency carries the inspector's full written finding, usually with the SOLAS or MARPOL reference, plus the system, sub-system and component codes, the action code the Coast Guard applied, whether it has been resolved, and the resolution text and date.

**Detention flags** — deficiencies carrying action code 30 are detentions. `hasDetention`, `detentionCount`, `detentionDeficiencyCount` and `lastDetentionDate` are pre-computed at the vessel level, and `wasDetained` at the inspection level, so a problem hull sorts to the top without any post-processing.

**Risk rollups** — `deficiencyCount`, `unresolvedDeficiencyCount`, `deficienciesPerInspection`, `daysSinceLastInspection`, `inspectionPorts` and `deficiencySystems` (deficiency counts grouped by ship system, worst first) turn a raw history into something you can rank on.

### Ways to search

| Mode | What it does |
|---|---|
| By vessel name | Partial match. `MAERSK` returns EFFIE MAERSK, MAERSK NEWBURY and the rest |
| By IMO / official number / call sign | Exact lookups from a list. An `IMO` prefix is ignored, and numbers and call signs can be mixed in the same list |
| Fleet sweep | Every vessel under a flag state and/or a service type, optionally bounded by build years |

### Filters

Filters are applied before a record is counted, so you only pay for rows you asked for.

- `detentionsOnly` — only inspections that detained the ship. The fastest route to a problem-tonnage list
- `portStateControlOnly` — only the foreign-flag Port State Control exams
- `withDeficienciesOnly` and `unresolvedDeficienciesOnly` — drop clean inspections, or keep only findings still open
- `minDeficiencies` — skip vessels below a deficiency count
- `deficiencySystem` — findings against one system: `Fire Safety`, `Pollution Prevention`, `Life Saving Appliances`, `Cargo Operations`
- `deficiencyKeyword` — free text inside the inspector's narrative: `lifeboat`, `corrosion`, `ISM`, `oily water separator`
- `portContains` — inspections at a given port or state
- `inspectionDateFrom` and `inspectionDateTo` — the inspection window
- `flagFilter`, `serviceTypeFilter`, `statusFilter`, `buildYearFrom`, `buildYearTo` — narrow the fleet itself
- `includeDeficiencies`, `includeCertificates`, `includeDimensions`, `includeTonnage` — switch off what you do not need for a faster, lighter run
- `outputLevel` — one rich row per vessel with inspections nested, or one flat row per inspection for pivoting

### Who is it for

| Use case | Who benefits |
|---|---|
| Charterer and owner vetting | Operators screening a hull's detention and deficiency record before fixing |
| Marine insurance and P\&I | Underwriters pricing risk on age, class, deficiency density and detention history |
| Ship finance and sale-and-purchase | Analysts checking condition history and certificate status behind a valuation |
| Port and terminal safety | Terminals flagging inbound tonnage with open deficiencies |
| Class societies and consultants | Benchmarking deficiency patterns by flag, system and vessel type |
| Maritime research and journalism | Tracing substandard shipping, flag-of-convenience patterns and pollution enforcement |

### Tips

- `detentionsOnly` with a flag state and a build-year range is the quickest way to build a substandard-tonnage watchlist for a registry.
- `deficiencyKeyword` searches the inspector's own text, so it finds things no code list captures. `oily water separator` and `magic pipe` both surface pollution cases.
- Set `outputLevel` to inspection when you want to chart deficiencies over time; keep it on vessel when you want one row per ship for a CRM or a risk model.
- `maxInspectionsPerVessel` controls both depth and speed. Lower it for a broad fleet inventory, raise it for a full history on a short list.
- `maxRecords` is a hard cap and controls run cost.

### FAQ and troubleshooting

**Which vessels are covered?** Vessels recorded by the US Coast Guard, which includes US-flag vessels and the foreign-flag ships that call at US ports. A ship that has never traded to the United States will not be there.

**Does it cover Port State Control outside the US?** No. This is the US record. `isPortStateControl` marks the exams the Coast Guard itself classifies as Port State Control related.

**How do I tell a detention from an ordinary deficiency?** By the action code. Code 30 is a detention and is surfaced as `isDetention` on the deficiency and `wasDetained` on the inspection. Codes such as 17 and 40 mean rectify before departure or before the next US port, which are findings, not detentions.

**Why is `nextCertificateExpiry` empty on some ships?** Because every certificate on file has already lapsed, which usually means the vessel has not been in US waters recently. The certificate list still shows what was held and when it expired.

**Why do some vessels have no inspections?** They are on the register but have no recorded inspection inside the date window. Widen `inspectionDateFrom`, or accept that the hull has no US inspection history.

**Why did a very broad search return nothing?** The registry refuses to answer a query above its own result ceiling, and answers with an empty set rather than a truncated one. The actor detects this and splits the query by build year automatically, and says so in the run log when it does. Hulls with no recorded build year cannot be reached that way, so a split sweep is reported as partial rather than complete.

**Are owners and operators included?** No. The public vessel record covers identity, dimensions, tonnage, documents and inspection history. Ownership and management are not part of it.

**How fresh is the data?** It is read live on every run. `scrapedAt` records when each row was collected.

**Do I need an API key or credentials?** No. The record is public and the actor needs nothing from you beyond the search input.

**What happens if a lookup fails?** That vessel is skipped and the run continues. Nothing is charged for a record that could not be retrieved.

***

Not affiliated with, endorsed by or sponsored by the United States Coast Guard. All data is read from publicly available records.

# Actor input Schema

## `searchMode` (type: `string`):

How to pick the vessels. Name is a partial match on the vessel name. Identifiers looks up exact IMO numbers, official numbers or call signs. Fleet sweeps every vessel under a flag state and/or service type.

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

Part of the vessel name, e.g. "MAERSK" finds EFFIE MAERSK, MAERSK NEWBURY and so on. Used when search mode is "By vessel name".

## `identifiers` (type: `array`):

Exact identifiers to look up, e.g. "9200835" (IMO) or "9VIP6" (call sign). An "IMO" prefix is ignored. Used when search mode is "By IMO number / official number / call sign".

## `flag` (type: `string`):

Flag state to sweep, spelled as the registry spells it, e.g. "PANAMA", "LIBERIA", "SINGAPORE", "MARSHALL ISLANDS". Used when search mode is "Fleet sweep".

## `serviceType` (type: `string`):

Service type to sweep, e.g. "Tank Ship", "Freight Ship", "Passenger Ship", "Offshore Supply Vessel", "Commercial Fishing Vessel". Used when search mode is "Fleet sweep".

## `buildYearFrom` (type: `integer`):

Only vessels whose construction was completed in this year or later. In fleet mode this also drives the sweep: the registry only accepts one build year per request, so the range is walked year by year.

## `buildYearTo` (type: `integer`):

Only vessels whose construction was completed in this year or earlier.

## `outputLevel` (type: `string`):

Vessel gives one rich record per ship with its inspections nested. Inspection gives one flat row per inspection (vessel details repeated), which is easier to pivot and chart.

## `maxRecords` (type: `integer`):

Stop after this many results. Free Apify plans are capped at 10 per run.

## `statusFilter` (type: `string`):

Keep only active hulls, only inactive ones, or both.

## `flagFilter` (type: `array`):

Post-filter on flag state, e.g. \["PANAMA", "LIBERIA"]. Useful to narrow a name search to specific registries.

## `serviceTypeFilter` (type: `array`):

Post-filter on service type, matched as a substring, e.g. \["Tank Ship"].

## `inspectionDateFrom` (type: `string`):

Only inspections on or after this date (YYYY-MM-DD).

## `inspectionDateTo` (type: `string`):

Only inspections on or before this date (YYYY-MM-DD).

## `portStateControlOnly` (type: `boolean`):

Keep only inspections flagged by the Coast Guard as Port State Control related — the foreign-flag exams that drive detention and targeting decisions.

## `detentionsOnly` (type: `boolean`):

Keep only inspections that resulted in a detention (deficiency action code 30) or a recorded control action.

## `withDeficienciesOnly` (type: `boolean`):

Drop clean inspections.

## `unresolvedDeficienciesOnly` (type: `boolean`):

Keep only inspections that still carry at least one deficiency the registry has not marked resolved.

## `minDeficiencies` (type: `integer`):

Drop vessels with fewer than this many recorded deficiencies in total. A quick way to isolate problem tonnage.

## `deficiencySystem` (type: `string`):

Keep only inspections with a deficiency against this system or sub-system, e.g. "Fire Fighting", "Engineering", "Lifesaving", "Pollution".

## `deficiencyKeyword` (type: `string`):

Free-text search inside the inspector's deficiency narrative, e.g. "lifeboat", "corrosion", "ISM", "oily water separator".

## `portContains` (type: `string`):

Keep only inspections at ports matching this text, e.g. "Houston", "Louisiana", "New Orleans".

## `maxInspectionsPerVessel` (type: `integer`):

Newest inspections first. Lower this to speed up large sweeps; raise it for a complete inspection history.

## `includeInspections` (type: `boolean`):

Nest every matching inspection in the vessel record.

## `includeDeficiencies` (type: `boolean`):

Include each deficiency's full narrative, system classification, action code and resolution. This is the slowest part of a run — switch it off for a fast fleet inventory.

## `includeCertificates` (type: `boolean`):

Include the certificate list (COI, load line, IOPP, class documents) with issue and expiry dates.

## `includeDimensions` (type: `boolean`):

Include length, breadth and depth.

## `includeTonnage` (type: `boolean`):

Include gross, net, deadweight and displacement tonnage.

## `maxConcurrency` (type: `integer`):

How many vessels to read at once.

## `proxyConfiguration` (type: `object`):

Optional. The registry is reachable without a proxy; add one only if your network needs it.

## Actor input object example

```json
{
  "searchMode": "name",
  "vesselName": "MAERSK",
  "identifiers": [
    "9200835",
    "9VIP6"
  ],
  "flag": "PANAMA",
  "outputLevel": "vessel",
  "maxRecords": 20,
  "statusFilter": "any",
  "portStateControlOnly": false,
  "detentionsOnly": false,
  "withDeficienciesOnly": false,
  "unresolvedDeficienciesOnly": false,
  "maxInspectionsPerVessel": 25,
  "includeInspections": true,
  "includeDeficiencies": true,
  "includeCertificates": true,
  "includeDimensions": true,
  "includeTonnage": true,
  "maxConcurrency": 6,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

# 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": "MAERSK",
    "identifiers": [
        "9200835",
        "9VIP6"
    ],
    "flag": "PANAMA"
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers_lat/uscg-psix-vessel-inspections-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": "MAERSK",
    "identifiers": [
        "9200835",
        "9VIP6",
    ],
    "flag": "PANAMA",
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers_lat/uscg-psix-vessel-inspections-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": "MAERSK",
  "identifiers": [
    "9200835",
    "9VIP6"
  ],
  "flag": "PANAMA"
}' |
apify call scrapers_lat/uscg-psix-vessel-inspections-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers_lat/uscg-psix-vessel-inspections-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/i9xyolWEN77w8X6MS/builds/X84J3eX70x7AHUR4a/openapi.json