# FMCSA Carrier Safety Scraper (`parseforge/fmcsa-carrier-safety-scraper`) Actor

Collect motor carrier safety data from FMCSA. Search by company name or DOT number. Get operating status, safety ratings, BASIC scores, power units, driver counts, cargo types, authority types, addresses, and contact info for trucking companies and freight carriers across the US.

- **URL**: https://apify.com/parseforge/fmcsa-carrier-safety-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Developer tools, Other
- **Stats:** 3 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

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

![ParseForge Banner](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)

## 🚛 FMCSA Carrier Safety Scraper

Whether you're a logistics company vetting carriers, a compliance team monitoring fleet safety, or a researcher analyzing transportation data, this tool makes it easy to collect structured motor carrier safety records from the Federal Motor Carrier Safety Administration.

> **The FMCSA Carrier Safety Scraper collects carrier data including operating status, safety ratings, BASIC safety scores, power units, driver counts, cargo types, authority types, and contact information. Search by company name or look up specific carriers by DOT number.**

### ✨ What Does It Do

- 🔍 **Name search** - search carriers by company name and get enriched results with full details
- 🔢 **DOT number lookup** - look up a specific carrier by their USDOT number for instant results
- 🛡️ **Safety ratings** - get official FMCSA safety ratings and rating dates for each carrier
- 📊 **BASIC scores** - fetch the 7 Behavior Analysis and Safety Improvement Categories scores with percentiles and alert indicators
- 🚚 **Fleet data** - collect power unit counts, driver counts, and total miles driven
- 📦 **Cargo and authority** - get cargo types carried and operating authority details
- 📍 **Contact info** - extract physical addresses, mailing addresses, and phone numbers

### 🔧 Input

- **Search by Carrier Name** - company name to search (e.g., 'swift transportation')
- **Max Items** - how many carriers to collect (free users get 10, paid users up to 1,000,000)
- **DOT Number** - look up a specific carrier by USDOT number (overrides name search)
- **API Web Key** - your free FMCSA API key (required, get one at mobile.fmcsa.dot.gov)
- **Include Safety BASIC Scores** - fetch the 7 BASIC category scores for each carrier

```json
{
    "searchName": "swift transportation",
    "maxItems": 10,
    "webKey": "your-api-key-here",
    "includeBasics": true
}
````

### 📊 Output

Each carrier record includes up to 22 data fields. Download as JSON, CSV, or Excel.

| Field | Description |
|-------|-------------|
| dotNumber | USDOT number |
| legalName | Legal business name |
| dbaName | Doing business as name |
| phone | Phone number |
| physicalAddress | Full physical address |
| mailingAddress | Full mailing address |
| city | City |
| state | State |
| zipcode | ZIP code |
| country | Country |
| operatingStatus | Current operating status code |
| safetyRating | Official FMCSA safety rating |
| safetyRatingDate | Date of safety rating |
| powerUnits | Number of power units (trucks) |
| drivers | Number of drivers |
| totalMiles | Total vehicle miles traveled |
| carrierOperation | Type of carrier operation |
| hmFlag | Hazardous materials flag |
| passengerCarrier | Passenger carrier flag |
| cargoTypes | List of cargo types carried |
| basicScores | BASIC safety category scores with percentiles |
| authorityTypes | Operating authority types |
| scrapedAt | Timestamp when data was collected |

```json
{
    "dotNumber": "2247837",
    "legalName": "ACME TRUCKING LLC",
    "dbaName": null,
    "phone": "(555) 123-4567",
    "physicalAddress": "123 MAIN ST, DALLAS, TX, 75201, US",
    "operatingStatus": "AUTHORIZED FOR HHG",
    "safetyRating": "Satisfactory",
    "powerUnits": 45,
    "drivers": 52,
    "carrierOperation": "Interstate",
    "hmFlag": false,
    "cargoTypes": ["General Freight", "Household Goods"],
    "basicScores": {
        "Unsafe Driving": {
            "measure": "2.5",
            "percentile": 35,
            "alert": false
        }
    },
    "authorityTypes": ["Common", "Contract"],
    "scrapedAt": "2026-04-08T16:54:43.328Z"
}
```

### 💎 Why Choose the FMCSA Carrier Safety Scraper?

| Feature | Our Tool | Manual FMCSA Search |
|---------|----------|---------------------|
| Batch search | Up to 50 carriers per run | One at a time |
| BASIC scores | All 7 categories included | Click into each carrier |
| Enriched data | 22+ fields per carrier | Basic info only |
| Structured output | JSON, CSV, Excel | HTML pages |
| Automated scheduling | Daily/weekly monitoring | Manual visits |
| DOT lookup | Instant single carrier | Navigate the site |

### 📋 How to Use

1. **Sign Up** - [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp)
2. **Get API Key** - register for a free FMCSA API key at mobile.fmcsa.dot.gov
3. **Configure** - enter your API key, search by name or DOT number
4. **Run It** - click "Start" and get structured carrier safety data in seconds

No coding, no setup, no manual browsing required.

### 🎯 Business Use Cases

- 🚛 **Freight brokers** - vet carriers before booking loads by checking safety ratings and BASIC scores
- 📋 **Compliance teams** - monitor carrier safety data for regulatory compliance and risk management
- 🏢 **Shippers** - evaluate carrier safety records before signing transportation contracts
- 📊 **Insurance companies** - assess carrier risk profiles using safety scores and violation history
- 🔍 **Fleet managers** - benchmark your fleet's safety performance against industry peers
- 📰 **Researchers** - analyze transportation safety trends across carriers, regions, and cargo types

### ❓ FAQ

🚛 **What is FMCSA?**
The Federal Motor Carrier Safety Administration (FMCSA) regulates and provides safety oversight for commercial motor vehicles in the United States, including trucks and buses.

🔑 **How do I get an API key?**
Register for a free web key at mobile.fmcsa.dot.gov. The key is required to access carrier data.

📊 **What are BASIC scores?**
BASICs (Behavior Analysis and Safety Improvement Categories) are 7 safety measurement areas: Unsafe Driving, Hours-of-Service, Driver Fitness, Controlled Substances, Vehicle Maintenance, Hazardous Materials, and Crash Indicator.

🔍 **How many carriers can I search?**
Name searches return up to 50 results from FMCSA. For larger datasets, use DOT number lookups.

⏱️ **How long does a run take?**
A single DOT lookup takes 1-2 seconds. Name searches with enrichment take 10-30 seconds depending on result count.

### 🔗 Integrate FMCSA Scraper with any app

- [Make](https://docs.apify.com/platform/integrations/make) - Automate carrier vetting workflows
- [Zapier](https://docs.apify.com/platform/integrations/zapier) - Get alerts on carrier safety changes
- [Slack](https://docs.apify.com/platform/integrations/slack) - Get notified about safety alerts
- [Google Drive](https://docs.apify.com/platform/integrations/drive) - Export carrier data to spreadsheets
- [Webhooks](https://docs.apify.com/platform/integrations/webhooks) - Trigger actions when runs complete

### 💡 Recommended Actors

Looking for more government and business data tools? Check out these related actors:

| Actor | Description | Link |
|-------|-------------|------|
| FAA Aircraft Registry Scraper | Extract aircraft registration data | [Link](https://apify.com/parseforge/faa-aircraft-registry-scraper) |
| Grants.gov Scraper | Collect federal grant opportunities | [Link](https://apify.com/parseforge/grants-gov-scraper) |
| Federal Register Scraper | Collect regulatory notices and rules | [Link](https://apify.com/parseforge/federal-register-regulatory-notices-rules-scraper) |
| FINRA BrokerCheck Scraper | Look up broker registration data | [Link](https://apify.com/parseforge/finra-brokercheck-scraper) |
| GSA eLibrary Scraper | Collect government contract data | [Link](https://apify.com/parseforge/gsa-elibrary-scraper) |

**Pro Tip:** Browse our complete collection of [data collection actors](https://apify.com/parseforge) to find the perfect tool for your needs.

### 🆘 Need Help?

- Check the FAQ section above for common questions
- Visit the [Apify documentation](https://docs.apify.com) for platform guides
- Contact us at [Tally contact form](https://tally.so/r/BzdKgA)

### ⚠️ Disclaimer

> This Actor is an independent tool and is not affiliated with, endorsed by, or connected to the Federal Motor Carrier Safety Administration (FMCSA) or the U.S. Department of Transportation. It accesses only publicly available data through the official FMCSA public API.

# Actor input Schema

## `companyName` (type: `string`):

Search carriers by name (e.g., 'swift transportation', 'fedex'). Returns matching carriers with full safety data.

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000.

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

Look up specific carriers by USDOT number. Provide one or more DOT numbers.

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

Look up specific carriers by MC/MX number.

## Actor input object example

```json
{
  "companyName": "swift transportation",
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Overview of scraped data

# 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 = {
    "companyName": "swift transportation",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/fmcsa-carrier-safety-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 = {
    "companyName": "swift transportation",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/fmcsa-carrier-safety-scraper").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 '{
  "companyName": "swift transportation",
  "maxItems": 10
}' |
apify call parseforge/fmcsa-carrier-safety-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/fmcsa-carrier-safety-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FMCSA Carrier Safety Scraper",
        "description": "Collect motor carrier safety data from FMCSA. Search by company name or DOT number. Get operating status, safety ratings, BASIC scores, power units, driver counts, cargo types, authority types, addresses, and contact info for trucking companies and freight carriers across the US.",
        "version": "0.0",
        "x-build-id": "LcZSGaAaWgUtdKTPc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~fmcsa-carrier-safety-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-fmcsa-carrier-safety-scraper",
                "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/parseforge~fmcsa-carrier-safety-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-fmcsa-carrier-safety-scraper",
                "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/parseforge~fmcsa-carrier-safety-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-fmcsa-carrier-safety-scraper",
                "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": {
                    "companyName": {
                        "title": "Company Name",
                        "type": "string",
                        "description": "Search carriers by name (e.g., 'swift transportation', 'fedex'). Returns matching carriers with full safety data."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000."
                    },
                    "dotNumbers": {
                        "title": "DOT Numbers",
                        "type": "array",
                        "description": "Look up specific carriers by USDOT number. Provide one or more DOT numbers.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "mcNumbers": {
                        "title": "MC/MX Numbers",
                        "type": "array",
                        "description": "Look up specific carriers by MC/MX number.",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
