# DOT Number Lookup & FMCSA Carrier Check API (`reliable_tools/dot-number-lookup`) Actor

DOT number lookup and MC number lookup from official FMCSA open data: authority, insurance, safety rating, out-of-service orders, inspections, crashes, risk level, name match.

- **URL**: https://apify.com/reliable_tools/dot-number-lookup.md
- **Developed by:** [Reliable Tools](https://apify.com/reliable_tools) (community)
- **Categories:** Developer tools, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## DOT Number Lookup & FMCSA Carrier Check API

This DOT number lookup checks motor carriers in bulk against official FMCSA data: USDOT status, MC number and operating
authority, insurance on file, safety rating, out-of-service orders, and 24 months of inspections and crashes. You can
look up by USDOT number, by MC number or by company name, or upload your whole carrier list. Every fact comes from the
FMCSA files that the U.S. Department of Transportation publishes as open data, and each carrier also gets a risk level
and, for your own list, a check that the record really is the company you have on file.

### What does DOT Number Lookup do?

Freight brokers, shippers and insurers vet carriers before every load or policy. On the FMCSA website that means one
carrier at a time. This Actor does it for hundreds of carriers in one run:

1. **Look up USDOT and MC numbers.** Paste numbers, get one clean carrier record each.
2. **Search carriers by name**, optionally within a state.
3. **Vet your carrier list.** Give your records (USDOT or MC number, or only name and state). Each row gets the FMCSA
   record, a risk level with the hard flags behind it, and a **same company** verdict with a probability.

### What data you get

| Field | What it is |
|---|---|
| `dotNumber`, `legalName`, `dbaName` | USDOT number and names as registered |
| `usdotStatus` | `active`, `inactive` or `pending` |
| `entityType`, `carrierOperation`, `businessType` | For hire or private, interstate or intrastate, corporation or sole proprietor |
| `mcNumbers`, `operatingAuthority` | Docket numbers; common, contract and broker authority status; pending applications and revocations |
| `operatingAuthority[].bipdRequiredUsd` / `bipdOnFileUsd` | Liability insurance required and on file; cargo and bond required and on file |
| `insurancePolicies` | Active and pending filings: type, insurer, policy number, effective and cancellation date, coverage |
| `hasActiveAuthority` | True if any common, contract or broker authority is active |
| `safetyRating` | Satisfactory, conditional, unsatisfactory or not rated, with dates |
| `outOfServiceOrder` | Whether an out-of-service order is active, and the latest order with date and reason |
| `fleet` | Power units, trucks, buses, drivers, CDL drivers |
| `hazmat`, `cargoCarried` | Hazmat flag and cargo types |
| `registeredSince`, `monthsRegistered` | USDOT registration date and age |
| `mcs150Date`, `mcs150AgeMonths`, `mcs150Mileage` | Last biennial update and reported mileage |
| `physicalAddress`, `phone` | Business address and phone |
| `inspections24Months` | Inspections, vehicle and driver out-of-service counts and rates, next to the national rates from the same file |
| `crashes24Months` | Crashes, fatalities, injuries and tow-aways, plus `notPreventableCrashes` (crashes FMCSA marked not preventable) |
| `individualOperator` | `true` when the FMCSA census lists the carrier as an individual (sole proprietor or owner-operator), `false` when it is clearly an organisation (census says corporation or partnership, or the legal name carries a registered legal form such as LLC, INC, CORP, LTD, LP, LLP, PLLC or PC and neither the legal name nor the DBA name looks like a person's name), `null` when this is not clear, which is the case for most carriers. "Co.", "Company" or "Trucking" in a name do not count as a legal form. `null` is treated like a possible individual |
| `risk` | Level (`low`, `moderate`, `elevated`, `high`), hard flags, the AI score and a usage note |
| `companyMatch` | For your own list: verdict, probability and evidence |
| `saferUrl` | The official SAFER company snapshot |

Officer names and email addresses are in the FMCSA census, but this Actor leaves them out because vetting does not need
them.

### How to look up a DOT number step by step

1. Paste USDOT numbers into **USDOT numbers** or MC numbers into **MC numbers**.
2. Or put your carrier list into **Your carrier list**, or link a CSV export.
3. Or search by name under **Search carriers by name**, for example `{"name": "werner enterprises", "state": "NE"}`.
4. Click **Start**. The sample input finishes in about two minutes, because the Actor sends at most one request per
   second to the open-data portal (as its robots.txt asks). With your own free app token it runs faster.
5. Download JSON, CSV or Excel, or read the results through the API.

### How the risk level works

Code reads the hard facts first and sets a minimum level:

| Flag set by code | Minimum level |
|---|---|
| `usdot_not_active`, `active_out_of_service_order`, `for_hire_without_active_authority`, `unsatisfactory_rating` | high |
| `conditional_rating`, `liability_insurance_below_required`, `authority_revocation_pending` | elevated |
| `mcs150_older_than_24_months`, `new_carrier_under_12_months`, vehicle or driver out-of-service rate above 1.5 times the national rate (at least 10 inspections) | moderate |

Then an AI judge reads the whole record, including fleet size next to crash and inspection counts, and gives a
calibrated level on the same four-step scale. The final level is the AI level, but never below the minimum from code,
and the AI alone can never set `high`: it can raise a carrier at most to `elevated`.
So an active out-of-service order is always `high`, whatever else the record says.

Crashes that FMCSA marked as not preventable stay in the output but are left out of the risk input, so a carrier is
never rated higher because of a crash it could not have prevented.

The risk level supports your own review. It must not be the sole basis for decisions about individual owner-operators.
`high` always needs one of the hard official facts above (inactive USDOT number, active out-of-service order, for-hire without
active authority, unsatisfactory rating). Every row carries this note in `risk.note`. For carriers that may be individuals,
`risk.note` also says that the record is not a consumer report under the US FCRA.

### How the same-company match works

For each row of your list the Actor compares your company name and address with the FMCSA legal name, DBA name and
physical address. Legal forms (LLC, Inc., Corp.) are separated first, then code compares names, state, city and ZIP. An
AI judge returns the probability that it is the same business, and code turns it into `same`, `uncertain`, `related`
(for example an older inactive registration of the same business) or `different`. When you give only a name and state,
up to five candidates are compared and the best one is returned.

### How much does it cost?

Pay per event:

| Event | Price | When |
|---|---|---|
| Carrier record | $0.004 | Each carrier found: census, authority, insurance, out-of-service orders, inspections and crashes |
| Risk label | $0.003 | Each carrier that gets a risk level |
| Company match | $0.006 | Each row of your own list compared with the FMCSA record |
| Actor start | $0.00005 | Once per run |

Not charged: numbers that are not in the FMCSA census and rows where the open-data service did not answer. Example:
vetting 500 carriers from your TMS with risk level and match costs about $6.50.

### Input

```json
{
  "dotNumbers": ["264184", "53467"],
  "mcNumbers": ["MC-138328"],
  "records": [
    {"reference": "C-1", "dotNumber": "264184", "name": "Schneider National Carriers, Inc.", "state": "WI"},
    {"reference": "C-2", "name": "Blue Water Trucking LLC", "state": "GA"}
  ],
  "carrierSearch": [{"name": "werner enterprises", "state": "NE"}],
  "includeSafetyHistory": true,
  "riskLabel": true,
  "companyMatch": true
}
```

CSV columns for your list: `dotNumber` (or `dot`, `usdot`), `mcNumber` (or `mc`), `name`, `city`, `state`, `zip`,
`reference`.

### Output

One row from the sample run on 29 October 2026 (shortened):

```json
{
  "dotNumber": "53467",
  "legalName": "WERNER ENTERPRISES INC",
  "usdotStatus": "active",
  "entityType": "PRIVATE PROPERTY;AUTHORIZED FOR HIRE",
  "carrierOperation": "interstate",
  "mcNumbers": ["MC138328"],
  "hasActiveAuthority": true,
  "safetyRating": {"rating": "satisfactory", "ratingDate": "1995-08-08", "reviewDate": "1995-08-04"},
  "outOfServiceOrder": {"active": false, "latest": null, "ordersOnRecord": 0},
  "fleet": {"powerUnits": 9863, "trucks": 9821, "buses": 42, "drivers": 9107, "cdlDrivers": 9107},
  "hazmat": true,
  "registeredSince": "1974-06-01",
  "mcs150Date": "2024-07-23",
  "mcs150AgeMonths": 27,
  "physicalAddress": {"street": "14507 FRONTIER ROAD", "city": "OMAHA", "state": "NE", "postalCode": "68138", "country": "US"},
  "inspections24Months": {
    "inspections": 11654, "vehicleInspections": 6250, "vehicleOutOfService": 1243,
    "vehicleOosRate": 0.199, "nationalVehicleOosRate": 0.226,
    "driverInspections": 11641, "driverOutOfService": 113,
    "driverOosRate": 0.01, "nationalDriverOosRate": 0.061, "hazmatOutOfService": 11
  },
  "crashes24Months": {"crashes": 675, "fatalities": 15, "injuries": 301, "towAways": 652},
  "risk": {"level": "moderate", "flags": ["mcs150_older_than_24_months"], "aiScore0to3": 0.64, "confidence": 0.36},
  "summary": "USDOT 53467: WERNER ENTERPRISES INC, USDOT active, operating authority active. Risk: moderate."
}
```

In the same run, a carrier with an out-of-service order issued two days earlier came back as `high` with the flag
`active_out_of_service_order`, and a for-hire carrier whose authority was inactive and whose last MCS-150 dated from 2008
also came back as `high`.

### Use cases

- **Freight brokers:** vet a new carrier before tendering a load; re-check your whole carrier base every week.
- **Shippers and 3PLs:** audit the carriers your brokers use.
- **Insurers and factoring companies:** check authority, insurance filings and crash history of carrier businesses as
  one input to your own commercial review (not as a consumer report on individuals; see the FAQ).
- **Fleet and compliance teams:** find overdue MCS-150 updates and authority issues in your own registrations.

### Why not the FMCSA website or the QCMobile API?

The SAFER website shows one carrier per page. The FMCSA QCMobile API needs a personal web key and is built for
looking up one carrier at a time. This Actor reads the same FMCSA data from data.transportation.gov,
where FMCSA publishes the census, authority, insurance, out-of-service and SMS files as public open data, joins them
into one record per carrier and adds the risk level and the match. No key is needed.

### FAQ

#### Is this official FMCSA data?

Yes. Every field comes from FMCSA datasets published on data.transportation.gov, the U.S. Department of Transportation
open-data portal: the Company Census File, the Carrier (authority) file, active and pending insurance, out-of-service
orders, and the SMS input files for inspections and crashes. The risk level and the company match are added by this
Actor and are marked as such.

#### Where does the data come from and how may I use it?

The Actor reads only datasets that FMCSA publishes on data.transportation.gov as public U.S. government open data
(dataset rights: public). You are responsible for using the results lawfully. This is not a consumer report: do not use
it for employment, consumer credit, personal insurance or tenant decisions (US FCRA). Many carriers are sole
proprietors, so some names, addresses and phone numbers are personal data. Use them only for carrier vetting and follow
the privacy rules that apply to you. The Actor leaves out officer names and emails.

Not affiliated with or endorsed by FMCSA or the U.S. DOT.

#### What happens to the data I put in?

Your input and the results are stored in your own Apify account (dataset and key-value store of the run) under your
Apify retention settings. When the risk level or the company match is switched on, the carrier record and, for the
match, the name and address from your list are sent to an external AI scoring service that returns the score. Switch
off `riskLabel` and `companyMatch` to keep all data within the run on Apify.

#### How current is the data?

The census, authority, insurance and out-of-service files are updated daily on data.transportation.gov. The SMS
inspection and crash files are updated monthly and cover the last 24 months. The run summary lists the sources.

#### Does FMCSA have an API?

Yes, the QCMobile API, which needs a free web key. The open-data files used here need no
key. See "Why not the FMCSA website or the QCMobile API?" above.

#### How much does a DOT number lookup cost?

$0.004 per carrier record, $0.003 for the risk level and $0.006 for the match against your own record.

#### Is the risk level an FMCSA safety rating?

No. The safety rating field is FMCSA's own rating. The risk level is this Actor's summary to help your review: hard
facts set the minimum in code, and a calibrated AI level is added on top. It must not be the sole basis for decisions
about individual owner-operators.

#### How accurate is the company match?

The probability is calibrated across many rows. The hard cases are generic names ("Blue Water Trucking" exists in
several states). Add the state, city or ZIP to your records for the best results.

#### Can I use it from Python, n8n, Make or an AI agent (MCP)?

Yes. Every Apify Actor has a REST API, Python and JavaScript clients, and integrations with n8n, Make, Zapier and
MCP-capable AI agents. See the API tab.

#### Can I monitor my carriers every day?

Yes. Save your carrier list as an Actor task and schedule it daily or weekly in Apify. Compare the risk level and the
out-of-service flag between runs.

### About Reliable Tools

[Reliable Tools](https://apify.com/reliable_tools) builds compliance and lookup Actors on official public registries,
with calibrated AI checks where a plain lookup leaves a question open. Found a problem or need a field? Open an issue on
the Issues tab and we answer fast.

# Actor input Schema

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

One USDOT number per line.

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

One MC (docket) number per line, with or without the MC prefix. The Actor finds the USDOT number and returns the full carrier record.

## `records` (type: `array`):

One object per carrier from your own records: "reference", "dotNumber" or "mcNumber" (or only "name" and "state" to find it), and "name", "city", "state", "postalCode" for the same-company match. The prefill is sample data.

## `csvUrl` (type: `string`):

Optional: a link to a CSV file with a header row, read as your carrier list. Recognised columns: dotNumber (or dot, usdot), mcNumber (or mc), name, city, state, zip, reference.

## `carrierSearch` (type: `array`):

One object per search: "name" (part of the legal or DBA name), optional "state" (two letters) and "activeOnly" (default true).

## `includeSafetyHistory` (type: `boolean`):

Adds inspection counts, vehicle and driver out-of-service rates next to the national average, and crash, injury and fatality counts from the FMCSA SMS files.

## `riskLabel` (type: `boolean`):

Adds a risk level (low, moderate, elevated, high) with the hard flags found in the record, such as an active out-of-service order or a for-hire carrier without active authority.

## `companyMatch` (type: `boolean`):

For your carrier list: compares the FMCSA legal and DBA name and address with the name in your records and says whether it is the same company, a related one or a different one, with a probability.

## `maxResultsPerSearch` (type: `integer`):

Stops each name search after this many carriers.

## `maxResults` (type: `integer`):

Stops after this many carriers in total, from your numbers, your list and the name searches.

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

Optional free app token from data.transportation.gov. It raises the open-data rate limit for very large batches. Not needed for normal runs.

## Actor input object example

```json
{
  "dotNumbers": [
    "264184",
    "53467"
  ],
  "mcNumbers": [
    "MC-138328"
  ],
  "records": [
    {
      "reference": "C-1",
      "dotNumber": "264184",
      "name": "Schneider National Carriers, Inc.",
      "state": "WI"
    },
    {
      "reference": "C-2",
      "name": "Blue Water Trucking LLC",
      "state": "GA"
    },
    {
      "reference": "C-3",
      "dotNumber": "1751773",
      "name": "Long Island Landscape Designs"
    }
  ],
  "carrierSearch": [
    {
      "name": "werner enterprises",
      "state": "NE"
    }
  ],
  "includeSafetyHistory": true,
  "riskLabel": true,
  "companyMatch": true,
  "maxResultsPerSearch": 5,
  "maxResults": 5000
}
```

# Actor output Schema

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

Dataset in the carriers view.

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

Counts per status, risk level and match verdict, and the national out-of-service rates used.

# 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": [
        "264184",
        "53467"
    ],
    "mcNumbers": [
        "MC-138328"
    ],
    "records": [
        {
            "reference": "C-1",
            "dotNumber": "264184",
            "name": "Schneider National Carriers, Inc.",
            "state": "WI"
        },
        {
            "reference": "C-2",
            "name": "Blue Water Trucking LLC",
            "state": "GA"
        },
        {
            "reference": "C-3",
            "dotNumber": "1751773",
            "name": "Long Island Landscape Designs"
        }
    ],
    "carrierSearch": [
        {
            "name": "werner enterprises",
            "state": "NE"
        }
    ],
    "maxResultsPerSearch": 5
};

// Run the Actor and wait for it to finish
const run = await client.actor("reliable_tools/dot-number-lookup").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": [
        "264184",
        "53467",
    ],
    "mcNumbers": ["MC-138328"],
    "records": [
        {
            "reference": "C-1",
            "dotNumber": "264184",
            "name": "Schneider National Carriers, Inc.",
            "state": "WI",
        },
        {
            "reference": "C-2",
            "name": "Blue Water Trucking LLC",
            "state": "GA",
        },
        {
            "reference": "C-3",
            "dotNumber": "1751773",
            "name": "Long Island Landscape Designs",
        },
    ],
    "carrierSearch": [{
            "name": "werner enterprises",
            "state": "NE",
        }],
    "maxResultsPerSearch": 5,
}

# Run the Actor and wait for it to finish
run = client.actor("reliable_tools/dot-number-lookup").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": [
    "264184",
    "53467"
  ],
  "mcNumbers": [
    "MC-138328"
  ],
  "records": [
    {
      "reference": "C-1",
      "dotNumber": "264184",
      "name": "Schneider National Carriers, Inc.",
      "state": "WI"
    },
    {
      "reference": "C-2",
      "name": "Blue Water Trucking LLC",
      "state": "GA"
    },
    {
      "reference": "C-3",
      "dotNumber": "1751773",
      "name": "Long Island Landscape Designs"
    }
  ],
  "carrierSearch": [
    {
      "name": "werner enterprises",
      "state": "NE"
    }
  ],
  "maxResultsPerSearch": 5
}' |
apify call reliable_tools/dot-number-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,reliable_tools/dot-number-lookup"
        }
    }
}
```

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/ydLoxf1LqQ0h6mq9l/builds/qgOBIckPSgr0MRim5/openapi.json