# FMCSA Trucking API - DOT Lookup, Carriers & Enrichment (`makework36/fmcsa-trucking-api`) Actor

Search US trucking companies by DOT, MC/MX or name. Get phone, address, safety rating, power units, drivers + Google-enriched website & emails.

- **URL**: https://apify.com/makework36/fmcsa-trucking-api.md
- **Developed by:** [deusex machine](https://apify.com/makework36) (community)
- **Categories:** Lead generation, Business, AI
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, NaN 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/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

## FMCSA Trucking API — DOT Lookup, Carriers & Enrichment

Search every U.S. trucking carrier registered with the **Federal Motor Carrier Safety Administration (FMCSA / SAFER)** and turn it into a clean B2B lead list. Look up by **US DOT number**, **MC/MX number**, or **company name**, then optionally enrich each carrier with a website, LinkedIn, Facebook page and secondary emails. Built on top of the public FMCSA SAFER Company Snapshot — the same dataset insurance underwriters, freight brokers and load boards use, exposed as an API you can run on a schedule and export to CSV.

If you have searched for **DOT number lookup**, **MC number lookup**, **trucking company database**, **FMCSA carrier search by name free**, **trucking leads**, **freight broker leads**, or **us dot scraper**, this is the actor. It works for all 50 states, returns ~30 structured fields per carrier, and supports bulk lookups of thousands of DOTs in a single run.

> 💡 The FMCSA SAFER dataset is the only legally authoritative US trucking carrier database. Every active carrier, broker, shipper, freight forwarder or HAZMAT permittee with interstate authority is in it.

---

### 🚀 Why this FMCSA Trucking API

- **All ~2M US trucking carriers + brokers + shippers + freight forwarders** registered with FMCSA SAFER
- **Three lookup modes** — by US DOT (bulk), by MC/MX (bulk), or by company name keyword
- **30+ structured fields per carrier** — DOT, MC/MX, legal name, DBA, operating status, entity type, cargo type, power units, drivers, mileage, address, mailing address, phone, DUNS, MCS-150 date
- **Operating status filter** — Authorized For Hire, Not Authorized, Out of Service
- **Cargo carried** — Household Goods, Refrigerated Food, General Freight, Hazmat, Liquid / Gas, Auto Carrier, etc.
- **Web enrichment** — per carrier, find website, LinkedIn, Facebook and secondary emails via SERP (no API key)
- **No login, no DOT account, no scraping CAPTCHAs** — runs against the public SAFER endpoints
- **Outputs** — Apify Dataset → CSV, JSON, Excel, XML, RSS, HTML

Built for freight broker sales teams running carrier outreach, insurance underwriting and pre-qualification, trucking SaaS founders ($/DOT pricing), compliance teams onboarding new carriers, and analysts building fleet / M&A intelligence.

---

### 📊 What this FMCSA Trucking API extracts

| Field | Description |
| --- | --- |
| `usDot` | US DOT number |
| `mcMx` | MC / MX authority number(s) |
| `legalName` | Legal company name |
| `dbaName` | Doing-business-as name |
| `entityType` | Carrier, Broker, Shipper, Freight Forwarder, IEP, Cargo Tank Facility |
| `operatingStatus` | Authorized For Hire / Not Authorized / Out of Service |
| `outOfServiceDate` | Date placed out of service (when applicable) |
| `operationClassification` | Authorized For Hire, Private (Property), Private (Passengers), … |
| `carrierOperation` | Interstate / Intrastate Hazmat / Intrastate Non-Hazmat |
| `cargoCarried` | Array of cargo types (General Freight, Refrigerated, Hazmat, …) |
| `hmFlag` | Whether HAZMAT-certified |
| `pcFlag` | Whether passenger-certified |
| `powerUnits` | Number of trucks / tractors |
| `drivers` | Number of drivers (interstate + intrastate) |
| `mcs150Date` | Last MCS-150 update date |
| `mcs150Mileage` | Reported annual mileage |
| `mcs150MileageYear` | Year of the mileage report |
| `addressStreet` | Physical street address |
| `addressCity` | Physical city |
| `addressState` | Physical state (2-letter) |
| `addressZip` | Physical ZIP |
| `addressCountry` | Country code |
| `mailingStreet` | Mailing street (when different) |
| `mailingCity` | Mailing city |
| `mailingState` | Mailing state |
| `mailingZip` | Mailing ZIP |
| `phone` | Phone number on file |
| `dunsNumber` | DUNS number |
| `inspectionsSummary` | Counts of vehicle / driver / hazmat inspections (when published) |
| `crashesSummary` | Counts of crashes by category (when published) |
| `safetyRating` | Satisfactory / Conditional / Unsatisfactory / None |
| `safetyRatingDate` | Date of the safety rating |
| `enrichment.website` | Carrier website (optional) |
| `enrichment.linkedin` | Carrier LinkedIn (optional) |
| `enrichment.facebook` | Carrier Facebook (optional) |
| `enrichment.emails` | Secondary emails from SERP (optional) |
| `enrichment.phones` | Phone numbers from the carrier's website (optional) |
| `saferUrl` | Direct link to the SAFER Company Snapshot |

---

### 🎯 Search modes

#### 1. `byDot` — DOT number lookup (bulk)

Hand the actor a list of US DOT numbers and get the full SAFER snapshot for each. Perfect for compliance workflows, insurance underwriting, or batch CRM enrichment.

```json
{
  "searchMode": "byDot",
  "usDotNumbers": ["3475632", "1234567", "987654"],
  "enrichWithGoogle": true,
  "enrichLimit": 3
}
````

#### 2. `byMc` — MC / MX number lookup (bulk)

Same idea but using motor-carrier (MC) or transport-of-migrant (MX) authority numbers. Provide digits only — no `MC-` prefix.

```json
{
  "searchMode": "byMc",
  "mcMxNumbers": ["654321", "123456"],
  "enrichWithGoogle": false
}
```

#### 3. `byName` — FMCSA carrier search by name

Search by company name keyword and return all matching carriers, paginating across SAFER's full keyword index. This is the same endpoint that powers the SAFER carrier search box.

```json
{
  "searchMode": "byName",
  "companyName": "PREMIER VALLEY",
  "maxResults": 100,
  "enrichWithGoogle": true,
  "enrichLimit": 50
}
```

Tip: a generic keyword like `"LOGISTICS"`, `"FREIGHT"`, `"TRANSPORT"`, `"EXPRESS"`, `"HOTSHOT"` returns thousands of carriers — pair with `maxResults` and post-filter by state in the Dataset view.

***

### 💡 Use cases

This FMCSA Trucking API is built for **B2B lead generation, insurance underwriting, compliance and SaaS sales** targeting the U.S. trucking and freight industry.

- **Freight broker prospecting** — pull every Authorized For Hire carrier in a state with at least 5 power units, then run enrichment to get the dispatcher's email. Better signal than load-board scraping and 100% legal
- **Trucking leads & freight broker leads** — combine `cargoCarried` + state + power-units filter to build targeted lead lists for insurance, factoring, ELD vendors, dispatch SaaS, fuel cards
- **Trucking insurance leads** — Authorized For Hire carriers, sorted by power units. Add MCS-150 freshness as a quality signal
- **Carrier qualification & onboarding** — freight brokers can pre-vet a new carrier in seconds: operating status, safety rating, insurance authority, MCS-150 freshness
- **Fleet acquisition & M\&A research** — find small carriers (under 50 power units) by state and cargo type for roll-up plays
- **Hazmat shipper compliance discovery** — find every HM-flagged carrier carrying specific hazmat classes
- **Hotshot trucking leads** — filter on small power-unit counts (1–3) + Authorized For Hire to find owner-operators
- **DOT compliance audits** — bulk lookup an entire customer base by DOT to verify operating status weekly
- **Insurance renewals** — feed a list of insured DOTs into the actor every quarter to flag any carrier whose authority has changed
- **Trucking company directory by state** — by `state` + `entityType: Carrier` + `operatingStatus: Authorized For Hire`
- **Buy trucking leads** — instead of paying a list broker, run this actor on a schedule and own the list

***

### 🧾 Example output

```json
{
  "usDot": "3475632",
  "mcMx": ["MC-1167489"],
  "legalName": "PREMIER VALLEY TRANSPORT LLC",
  "dbaName": null,
  "entityType": "Carrier",
  "operatingStatus": "AUTHORIZED FOR HIRE",
  "operationClassification": ["Auth. For Hire"],
  "carrierOperation": "Interstate",
  "cargoCarried": ["General Freight", "Refrigerated Food"],
  "hmFlag": false,
  "pcFlag": false,
  "powerUnits": 12,
  "drivers": 14,
  "mcs150Date": "2025-11-04",
  "mcs150Mileage": 1820000,
  "mcs150MileageYear": 2024,
  "addressStreet": "1500 INDUSTRIAL BLVD",
  "addressCity": "FRESNO",
  "addressState": "CA",
  "addressZip": "93725",
  "addressCountry": "US",
  "phone": "+1-559-555-0142",
  "dunsNumber": "123456789",
  "safetyRating": "Satisfactory",
  "safetyRatingDate": "2024-08-12",
  "enrichment": {
    "website": "https://premiervalleytransport.com",
    "linkedin": "https://www.linkedin.com/company/premier-valley-transport",
    "facebook": null,
    "emails": ["dispatch@premiervalleytransport.com", "rates@premiervalleytransport.com"],
    "phones": ["+1-559-555-0142", "+1-559-555-0277"]
  },
  "saferUrl": "https://safer.fmcsa.dot.gov/query.asp?searchtype=ANY&query_type=queryCarrierSnapshot&query_param=USDOT&query_string=3475632"
}
```

***

### 🆚 Compared to alternatives

| Tool | DOT lookup | Name search | Enrichment | Bulk | Export | Cost |
| --- | --- | --- | --- | --- | --- | --- |
| **FMCSA Trucking API** (this actor) | ✅ | ✅ | ✅ | ✅ Up to 1,000 | CSV / JSON / Excel | Pay-per-event |
| SAFER web portal | ✅ | ✅ | ❌ | ⚠️ 1 at a time | ❌ | Free, painful |
| FMCSA SAFER API | ✅ | ⚠️ | ❌ | ⚠️ Slow | ⚠️ | Free, undocumented |
| DAT carrier reports | ✅ | ✅ | ⚠️ | ✅ | ✅ | $$$ subscription |
| Truckstop.com | ✅ | ✅ | ⚠️ | ✅ | ⚠️ | $$$ subscription |
| Carrier411 | ✅ | ✅ | ⚠️ | ⚠️ | ⚠️ | Subscription |
| HighWay / FreightWaves SONAR | ⚠️ | ⚠️ | ⚠️ | ✅ | ✅ | $$$$ enterprise |

If you only need to verify one DOT, the SAFER web portal is free and fine. For bulk extraction, enrichment, scheduled refresh and CSV export, this actor is the cheapest path.

***

### ⚙️ Input parameters reference

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `searchMode` | string enum | `byName` | `byDot` / `byMc` / `byName` |
| `usDotNumbers` | string\[] | — | Used with `byDot`. One DOT per line |
| `mcMxNumbers` | string\[] | — | Used with `byMc`. Digits only, no `MC-` prefix |
| `companyName` | string | — | Used with `byName`. Partial match on legal / DBA name |
| `maxResults` | integer | `50` | Hard cap (1–1,000) |
| `enrichWithGoogle` | boolean | `false` | Find website + LinkedIn + secondary emails per carrier |
| `enrichLimit` | integer | `50` | Max carriers to enrich (1–1,000) |
| `proxyConfig` | proxy | residential | Used for SAFER and enrichment requests |

***

### 💰 Pricing & cost

Pay-per-event:

- **Per carrier returned** — small fee, scales linearly
- **Per enriched carrier** — only when `enrichWithGoogle: true`, capped by `enrichLimit`

A 100-carrier name-search run with no enrichment is essentially free. Adding enrichment to all 100 carriers stays under a couple of dollars. Bulk DOT lookups of a 1,000-carrier customer base for renewal season runs at roughly the cost of a single SaaS seat.

Failed lookups, retries and rate-limit backoffs are not charged.

***

### 🧭 Quick reference — common cargo classifications

| `cargoCarried` value | Description |
| --- | --- |
| General Freight | Dry van, flatbed, standard freight |
| Refrigerated Food | Reefer carriers |
| Liquids/Gases | Tankers (chemicals, fuel, milk) |
| Hazmat | Hazardous materials (multiple classes) |
| Auto Carrier | Car haulers |
| Household Goods | Moving / relocation carriers |
| Building Materials | Construction freight |
| Mobile Homes | Manufactured housing |
| Logs, Poles, Beams, Lumber | Forestry haulers |
| Grain, Feed, Hay | Agricultural haulers |
| Beverages | Beer / soda / water distribution |
| Garbage / Refuse / Trash | Waste haulers |
| Livestock | Animal transport |
| Intermodal Containers | Drayage |
| Passengers | Bus / motorcoach / limo |

Use the `cargoCarried` field to segment your TAM by vertical (insurance, factoring, dispatch SaaS).

***

### ❓ Frequently asked questions

**Is this an official FMCSA product?**
No. The actor wraps the **public** FMCSA SAFER Company Snapshot endpoints (and the Carrier Search API). It returns the same data as the SAFER web portal, just in structured JSON.

**Is the data real and verified?**
Yes. SAFER is the legal source of truth for US trucking authority. Insurance companies, brokers and government auditors use it.

**Can I do an FMCSA carrier search by name free?**
Yes — use `searchMode: "byName"` with a keyword. The base lookup uses the same endpoint as the public SAFER carrier search box.

**Can I do a DOT number lookup by name free?**
Yes — search by name, then read the `usDot` field on the returned records. This is the standard way to map "company name" → DOT number.

**What's the difference between DOT and MC numbers?**
US DOT is the identifier every commercial vehicle operator needs. MC (Motor Carrier) is the **authority** number that lets you haul regulated freight or passengers for hire across state lines. Many carriers have both; brokers only have an MC.

**Can I scrape the entire FMCSA database in one run?**
\~2M carriers across all entity types. Doable but rarely useful. Most users filter by state + entity type + operating status and pull a manageable slice.

**How fresh is the data?**
Live. Every request hits SAFER in real time. Operating-status changes typically reflect within 24 hours of FMCSA action.

**Can I get trucking leads with emails?**
Yes. The SAFER record gives you the carrier name + phone + address. The optional enrichment step pulls the website, LinkedIn, and any emails published on those pages. Same approach Apollo / Hunter use, applied to trucking.

**Does this include CSA / BASIC scores?**
The SAFER snapshot returns inspection and crash counts. Detailed CSA / BASIC scores require a separate FMCSA SMS portal which is not currently included in this actor.

**Can I filter by safety rating?**
The record returns `safetyRating` (Satisfactory / Conditional / Unsatisfactory / None). Use the Dataset filter or download to CSV and filter downstream.

**Does it work for Canadian or Mexican carriers?**
FMCSA covers US-based carriers + cross-border US-Mexico (MX-authority). It is not the right source for purely domestic Canadian carriers.

**Is this legal to use for outbound sales?**
The dataset is public. Outbound sales must still follow CAN-SPAM, TCPA, DNC and state law. The actor does not generate or send any messages.

**How does this compare to DAT or Truckstop?**
DAT and Truckstop are subscription products with proprietary load-board data. The SAFER dataset is the **authority** source for carrier identity — it does not have loads. Most freight broker teams use both.

**Can I run this on a schedule?**
Yes — Apify Schedules supports cron expressions. Common pattern: weekly refresh of your active-carrier list to detect any authority changes (Out of Service flips).

**Can I integrate this with Claude, Cursor, or other AI agents?**
Yes — call the actor via the Apify API from your agent, or wrap it with Apify's MCP server.

***

### 🔗 Other actors by makework36

Useful companions for B2B lead-gen and logistics workflows:

- [PPP Loan Finder API](https://apify.com/makework36/ppp-loan-finder) — 11M US SMBs from the SBA PPP dataset with NAICS + enrichment
- [NPI Registry API](https://apify.com/makework36/npi-registry-api) — every US healthcare provider with NPI, taxonomy, address
- [Website Email & Contact Finder](https://apify.com/makework36/email-finder-scraper) — extract emails from any URL
- [Google Maps Scraper](https://apify.com/makework36/google-maps-scraper-full) — local business data + emails + phones at $1/1K
- [Facebook Ad Library Scraper](https://apify.com/makework36/facebook-adlib-scraper) — competitor ad intelligence
- [IndiaMART Suppliers Scraper](https://apify.com/makework36/indiamart-suppliers-scraper) — B2B suppliers with verified phones + GST
- [Reddit SaaS Leads Scraper](https://apify.com/makework36/reddit-leads-saas) — find startup pain points and early adopters
- [Reddit Real Estate Leads](https://apify.com/makework36/reddit-realestate-scraper) — buyers, investors, landlords
- [Shopify Products Scraper](https://apify.com/makework36/shopify-products-scraper) — any Shopify store catalog
- [Trustpilot Scraper API](https://apify.com/makework36/trustpilot-reviews-scraper) — reviews + ratings
- [Substack Scraper](https://apify.com/makework36/substack-scraper) — newsletter posts and authors
- [NPM Package Scraper](https://apify.com/makework36/npm-package-scraper) — JavaScript ecosystem + maintainer emails
- [HuggingFace Hub Scraper](https://apify.com/makework36/huggingface-hub-scraper) — AI models + datasets + author profiles

***

### 📝 Changelog

- **v0.1** — Initial release. Three search modes (byDot / byMc / byName), 30+ fields per carrier, optional Google enrichment.

***

### 🛠️ Support

Missing a field, need CSA scores, want a CDL-driver scraper? Open an issue or message me directly from the Apify Console. Fast turnaround for paying users.

# Actor input Schema

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

How to query FMCSA SAFER: by US DOT numbers, MC/MX numbers, or by company name.

## `usDotNumbers` (type: `array`):

Used when searchMode = byDot.

## `mcMxNumbers` (type: `array`):

Used when searchMode = byMc. Provide digits only (no MC- prefix).

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

Used when searchMode = byName. Partial match on legal/DBA name.

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

Cap on records to return. SAFER name-search returns ~100 keyword matches per page.

## `enrichWithGoogle` (type: `boolean`):

For each carrier, find website, LinkedIn, Facebook page, and secondary emails using an internal SERP fetcher. No API key required. Adds ~2-4s per carrier.

## `enrichLimit` (type: `integer`):

Max number of carriers to enrich.

## `proxyConfig` (type: `object`):

Apify proxy for both SAFER + enrichment requests.

## Actor input object example

```json
{
  "searchMode": "byName",
  "usDotNumbers": [],
  "mcMxNumbers": [],
  "maxResults": 50,
  "enrichWithGoogle": false,
  "enrichLimit": 50,
  "proxyConfig": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `carriers` (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 = {
    "usDotNumbers": [],
    "mcMxNumbers": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("makework36/fmcsa-trucking-api").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 = {
    "usDotNumbers": [],
    "mcMxNumbers": [],
}

# Run the Actor and wait for it to finish
run = client.actor("makework36/fmcsa-trucking-api").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 '{
  "usDotNumbers": [],
  "mcMxNumbers": []
}' |
apify call makework36/fmcsa-trucking-api --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FMCSA Trucking API - DOT Lookup, Carriers & Enrichment",
        "description": "Search US trucking companies by DOT, MC/MX or name. Get phone, address, safety rating, power units, drivers + Google-enriched website & emails.",
        "version": "1.0",
        "x-build-id": "Uofaqkl2mq67f3ktb"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/makework36~fmcsa-trucking-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-makework36-fmcsa-trucking-api",
                "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/makework36~fmcsa-trucking-api/runs": {
            "post": {
                "operationId": "runs-sync-makework36-fmcsa-trucking-api",
                "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/makework36~fmcsa-trucking-api/run-sync": {
            "post": {
                "operationId": "run-sync-makework36-fmcsa-trucking-api",
                "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": {
                    "searchMode": {
                        "title": "Search mode",
                        "enum": [
                            "byDot",
                            "byMc",
                            "byName"
                        ],
                        "type": "string",
                        "description": "How to query FMCSA SAFER: by US DOT numbers, MC/MX numbers, or by company name.",
                        "default": "byName"
                    },
                    "usDotNumbers": {
                        "title": "US DOT numbers (one per line)",
                        "type": "array",
                        "description": "Used when searchMode = byDot.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "mcMxNumbers": {
                        "title": "MC/MX numbers (one per line)",
                        "type": "array",
                        "description": "Used when searchMode = byMc. Provide digits only (no MC- prefix).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "companyName": {
                        "title": "Company name keyword",
                        "type": "string",
                        "description": "Used when searchMode = byName. Partial match on legal/DBA name."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on records to return. SAFER name-search returns ~100 keyword matches per page.",
                        "default": 50
                    },
                    "enrichWithGoogle": {
                        "title": "Enrich with web search",
                        "type": "boolean",
                        "description": "For each carrier, find website, LinkedIn, Facebook page, and secondary emails using an internal SERP fetcher. No API key required. Adds ~2-4s per carrier.",
                        "default": false
                    },
                    "enrichLimit": {
                        "title": "Enrich limit",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Max number of carriers to enrich.",
                        "default": 50
                    },
                    "proxyConfig": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Apify proxy for both SAFER + enrichment requests.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
