# FMCSA Carrier Lookup & Authority Watch (`mikee368/fmcsa-carrier-watch`) Actor

Look up a US motor carrier by USDOT, MC/MX/FF docket, or name and state, and watch authority, insurance, revocation, and out-of-service changes. Not affiliated with FMCSA.

- **URL**: https://apify.com/mikee368/fmcsa-carrier-watch.md
- **Developed by:** [Mike Berckmoes](https://apify.com/mikee368) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 carrier records

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/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

## FMCSA Carrier Lookup & Authority Watch

Look up a US motor carrier by USDOT number, MC/MX/FF docket, or legal/DBA name and state. List carriers newly added to the FMCSA census. Or watch a list for authority, insurance, revocation, and out-of-service changes since the last run.

This Actor is not affiliated with or endorsed by the Federal Motor Carrier Safety Administration or the US Department of Transportation.

### What you get

Lookup and new-carrier rows include `dotNumber`, `legalName`, `dbaName`, `statusCode`, `addDate`, `mcs150Date`, `carrierOperation`, `classdef`, `powerUnits`, `trucks`, `totalDrivers`, `hazmat`, `physicalAddress`, `safetyRating`, `safetyRatingDate`, `authorities` (docket, type, normalized status, last reason, status-change date), `insurance` (insurer, policy, type, BIPD max, effective date), `bipdOnFile`, `bipdRequired`, `activeRevocations`, `oosOrder`, `authoritySource`, `freshness`, `sourceUrls`, and `retrievedAt`.

A USDOT that is not in the census, Motus, or the legacy files is returned as `notFound: true` and is not charged.

Watch mode emits one change row per difference: `dotNumber`, `changeType`, `field`, `before`, `after`, `detectedAt`, `sourceDataset`. Change types include `AUTHORITY_GRANTED`, `AUTHORITY_INACTIVE`, `AUTHORITY_REINSTATED`, `INSURANCE_ADDED`, `INSURANCE_REMOVED`, `INSURANCE_CANCEL_SCHEDULED`, `REVOCATION_NOTICE`, `OOS_ORDER`, `OOS_RESCINDED`, `NAME_CHANGED`, `ADDRESS_CHANGED`, and `PHONE_CHANGED`.

### How to use it

- **Lookup (default).** Pass USDOT numbers, docket numbers (`MC1760297` or `MC-1760297`), or a name plus state.
- **New carriers.** Set mode to `newCarriers`. Filter with `since`, `states`, `carrierOperation` (A/B/C), `minPowerUnits`, and `entityType`. An empty `since` means the last 30 days.
- **Watch.** Set mode to `watch`, pass the DOT or docket list, and schedule the Actor with a stable `watchlistId`. The first run stores a baseline and charges nothing. Later runs emit only changes. The same change is not alerted twice.

Phone, email, and officer names are omitted unless `includeContacts` is true.

### Motus and the frozen legacy files

Authority and insurance are read from FMCSA's Motus datasets, which refresh daily. Each row is labeled `authoritySource: motus` and `freshness` is the newest `:updated_at` used for that carrier.

Carriers that are not in Motus fall back to the legacy authority and insurance files. Those files were last refreshed on **2026-05-14** and are no longer updated. Those rows are labeled `authoritySource: legacy-frozen-2026-05-14` and `freshness: 2026-05-14`. The Actor downloads only the missing DOTs, stores a compact index in the named key-value store `fmcsa-legacy-index`, and does not download those DOTs again.

Requests always send `$select` (only the columns this Actor uses) and a server-side `$where`. Pages are at most 1,000 rows. Watch runs ask for `:updated_at` after the cursor saved with that watchlist, then re-read the current row only for DOTs that showed up in that delta.

The watch snapshot is one gzipped record per watchlist in `fmcsa-watch-state`: a hash per DOT, plus the comparable fields (not the full census row). A failed dataset does not move the cursor. An alert that does not fit in the buyer's charge limit is not marked as sent, so the next run can deliver it once.

### How much does it cost?

Pay per event, with no start fee: **$0.002** for each `carrier-record` (a lookup or new-carrier row) and **$0.004** for each `change-alert`. A row that is not stored is not charged. Runs use 128–256 MB and do not use proxies. A one-DOT lookup is a handful of small Socrata requests.

No API key is required. An optional Socrata app token uses your own pool instead of the shared unauthenticated one, which can be throttled.

### Data source and licence

Source: FMCSA open data on [data.transportation.gov](https://data.transportation.gov). The Socrata metadata licence field points at `project-open-data.cio.gov/unknown-license`. DOT Order 1351.34 says:

> 34.4.26 DOT will clearly indicate that data and information it produces is free from copyright protection within the United States.

> 34.4.27 DOT will avoid establishing restrictions or regulations, including the charging of fees or royalties, on the reuse, resale, or redissemination of DOT data.

Commercial reuse of this public data is allowed. The QCMobile API is not used.

Census legal names include sole proprietors, because that is the carrier's registered name. Phone numbers, email addresses, and officer names are personal data and stay off unless you set `includeContacts`.

### FAQ

**Do I need an API key?** No. A Socrata app token is optional.

**Why do some carriers say legacy-frozen?** They are not in the Motus registration files yet. Their authority and insurance are the 14 May 2026 snapshot, not today's filing.

**What does the first watch run return?** Nothing. It stores the baseline. The next run returns changes.

# Actor input Schema

## `mode` (type: `string`):

lookup = carriers you name by USDOT, MC/MX/FF docket, or legal/DBA name. newCarriers = carriers added to the FMCSA census on or after Since. watch = authority, insurance, revocation, and out-of-service changes since the last run with the same Watchlist ID.

## `dotNumbers` (type: `array`):

USDOT numbers to look up or watch. Leading zeros are ignored.

## `mcNumbers` (type: `array`):

Docket numbers such as MC1760297 or MC-1760297. Resolved to a USDOT, then looked up the same way.

## `name` (type: `string`):

Case-insensitive match against the census legal name and DBA. Use with States to keep the search small.

## `states` (type: `array`):

Two-letter physical states. Used by name search and by new-carrier search. Empty means all states.

## `since` (type: `string`):

New-carrier mode only. Census add date (YYYY-MM-DD). Empty means the last 30 days.

## `carrierOperation` (type: `string`):

New-carrier filter. A = interstate, B = intrastate hazmat, C = intrastate non-hazmat. Empty means all.

## `minPowerUnits` (type: `integer`):

New-carrier filter. 0 means no minimum.

## `entityType` (type: `string`):

New-carrier filter on the census carrier/shipper code. Empty means all.

## `watchlistId` (type: `string`):

Name of the saved watch snapshot. Use different IDs for different lists. The snapshot is one gzipped record in the key-value store fmcsa-watch-state.

## `alertOn` (type: `array`):

Watch mode only. Which changes to emit: authority, insurance, revocation, oos, name, address, phone.

## `includeContacts` (type: `boolean`):

Off by default. When on, census phone, email, and company officer names are added to carrier rows. Watch mode can still alert on phone changes without putting the phone on every carrier row.

## `socrataAppToken` (type: `string`):

Optional token from data.transportation.gov. Leave empty to use the shared unauthenticated pool, which can be throttled.

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

Maximum carrier rows or change alerts pushed in this run (1-500).

## Actor input object example

```json
{
  "mode": "lookup",
  "dotNumbers": [
    "4462942"
  ],
  "mcNumbers": [],
  "states": [],
  "carrierOperation": "",
  "minPowerUnits": 0,
  "entityType": "",
  "watchlistId": "default",
  "alertOn": [
    "authority",
    "insurance",
    "revocation",
    "oos",
    "name",
    "address",
    "phone"
  ],
  "includeContacts": false,
  "maxItems": 25
}
```

# Actor output Schema

## `dataset` (type: `string`):

Dataset with one carrier row or one change alert per item

## `summary` (type: `string`):

Status, requests, charge limit, and legacy-cache use

# 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 = {
    "dotNumbers": [
        "4462942"
    ],
    "mcNumbers": [],
    "name": "",
    "states": [],
    "since": "",
    "alertOn": [
        "authority",
        "insurance",
        "revocation",
        "oos",
        "name",
        "address",
        "phone"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mikee368/fmcsa-carrier-watch").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 = {
    "dotNumbers": ["4462942"],
    "mcNumbers": [],
    "name": "",
    "states": [],
    "since": "",
    "alertOn": [
        "authority",
        "insurance",
        "revocation",
        "oos",
        "name",
        "address",
        "phone",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("mikee368/fmcsa-carrier-watch").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 '{
  "dotNumbers": [
    "4462942"
  ],
  "mcNumbers": [],
  "name": "",
  "states": [],
  "since": "",
  "alertOn": [
    "authority",
    "insurance",
    "revocation",
    "oos",
    "name",
    "address",
    "phone"
  ]
}' |
apify call mikee368/fmcsa-carrier-watch --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mikee368/fmcsa-carrier-watch"
        }
    }
}
```

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/5LWMeTwlMLByMLhyD/builds/rQIjQA4sxlJ9GmWBu/openapi.json