# FMCSA New Carrier Feed — Fresh Trucking Authority Leads (`curative_blanket/fmcsa-new-carrier-feed`) Actor

Every carrier added in the last N days legal name, location, operation type, fleet size, phone, USDOT and MC numbers  normalized into a clean lead schema. Built for insurance agencies, freight factoring, brokers, and AI lead agents targeting the highest-value slice.

- **URL**: https://apify.com/curative\_blanket/fmcsa-new-carrier-feed.md
- **Developed by:** [Salim](https://apify.com/curative_blanket) (community)
- **Categories:** Lead generation, Other
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 carrier results

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 New Carrier Feed — Fresh Trucking Authority Leads (Daily)

Get **every newly registered motor carrier** — legal name, location, phone, USDOT and MC numbers, fleet size, and operation type — pulled directly from the official FMCSA registration data and normalized into a clean lead schema. Run it daily and you receive **only the carriers added since your last run**: deduplicated, incremental, pay-per-result.

New authorities are the highest-value moment in a carrier's life. Factoring companies, insurance agencies, brokers, dispatch services, ELD and fuel-card vendors all compete to reach a carrier in its first weeks of operation — before its phone starts ringing. This feed exists to put you first in line, every morning, automatically.

### Who uses this feed

- **Freight factoring** — new authorities need cash flow before their first invoices clear. Day-one outreach wins the account.
- **Trucking insurance agencies** — every new authority needs liability and cargo coverage to operate.
- **Freight brokers & dispatchers** — build carrier networks from the newest entrants before competitors onboard them.
- **ELD, fuel card, and compliance vendors** — new carriers are buying their entire operating stack right now.
- **AI sales agents** — stable JSON schema and incremental output make this feed safe to wire directly into automated outreach pipelines.

### What you get (every record)

| Field | Description |
|---|---|
| `legal_name` / `dba_name` | Carrier's registered and operating names |
| `usdot_number` / `mc_number` | Federal identifiers for lookup and enrichment |
| `phone` | Registration phone number on file |
| `city`, `state`, `zip` | Physical location for territory targeting |
| `operation_type` | Authority/operation classification |
| `power_units` | Fleet size — segment owner-operators from fleets |
| `added_date` | When the carrier appeared in the federal data |

Export as JSON, CSV, or Excel from the dataset tab, or pull via the Apify API into your CRM, dialer, or spreadsheet.

### Quick start (the 2-minute setup that pays for itself)

1. **Run once** with the default lookback window — you'll get a backfill of recent new carriers so your first run is never empty.
2. **Create a daily schedule** (Schedules → new schedule → pick this Actor). Every morning the feed delivers only carriers added since yesterday.
3. **Connect the output** — download CSV, or push rows automatically to Google Sheets, your CRM, or anywhere else via Apify integrations (Make, Zapier, n8n) or the API.

You are billed per carrier record delivered. No subscription, no seat licenses, no minimums — a quiet day costs you almost nothing.

### FAQ

**How fresh is the data?**
The feed reads the official federal registration data, which updates on business days. Running on a daily schedule keeps you within roughly one business day of a carrier's registration — earlier than typical purchased lead lists reach the market.

**Will I get duplicates?**
No. The feed tracks previously seen USDOT numbers and emits each carrier once. Every row in your dataset is a new carrier.

**Do I need an API key or account with FMCSA?**
No. The Actor handles the source directly. Press run.

**Can I filter by state or fleet size?**
Every record carries `state` and `power_units`, so you can segment in your sheet or CRM. Native input filters are on the roadmap — open an issue on this page and tell me which filter you need first; user requests set the priority.

**How is this different from buying carrier lead lists?**
Lead-list brokers typically resell this same public data on a delay, at a fixed monthly fee, with no control over freshness. This feed is the primary source on your own schedule, billed per record. You own the pipeline.

**What about carrier safety scores?**
This feed is built for *new authority* discovery. For safety snapshots on a specific carrier, pair it with a safety-lookup tool using the USDOT number from each record — the two workflows complement each other.

**Is this legal to use?**
The feed reads official U.S. government open data published for public use. No login walls, no terms-of-service gray zones, no scraping fragility.

### Sample output

First 10 rows of a 50-row export from a live run (every record also carries a SAFER lookup URL keyed to the USDOT number):

| legal name | added | state | city | operation | trucks | phone | USDOT |
|---|---|---|---|---|---|---|---|
| VISUAL COMFORT & CO | 2026-06-10 | GA | SAVANNAH | Authorized For-Hire | 14 | 8036276697 | 5170958 |
| ZENCORE LOGISTICS LLC | 2026-06-10 | PA | PHILADELPHIA | Authorized For-Hire | 1 | 2158344025 | 5252912 |
| TRIPLE VALOR TRANSPORT LLC | 2026-06-10 | TX | CLEBURNE | Private | 1 | 4694862440 | 5326009 |
| TOOTHMAN AND SONS CONSTRUCTION LLC | 2026-06-10 | WV | RACHEL | Private | 2 | 3046124472 | 5639476 |
| HS TREE SERVICE LLC | 2026-06-10 | GA | ACWORTH | Private | 2 | 7705488454 | 5863693 |
| DMB TRANSPORTATION LLC | 2026-06-10 | CA | SAN JOSE | Private | 1 | 4087969570 | 6541541 |
| MC LAUD TRUCKING DELIVERY SERVICES LLC | 2026-06-10 | FL | POMPANO BEACH | Private | 2 | 9545206269 | 6720273 |
| DK EXCAVATION LLC. | 2026-06-10 | MT | BOZEMAN | Authorized For-Hire | 2 | 4065811348 | 7145764 |
| GEEZ TRUCKING LLC | 2026-06-10 | WA | SEATTLE | Private | 2 | 2064747562 | 7454249 |
| NEXT LEVEL EXCAVATING INC | 2026-06-10 | CA | SAN JOSE | Private | 1 | 5109217288 | 7521312 |

Run it once and the dataset tab gives you all fields as JSON, CSV, or Excel.

### Reliability

Official structured government sources — no headless browsers, no proxies, no anti-bot roulette. That's why runs complete in seconds and the success rate stays above 99%. If anything ever looks off in your output, open an issue on this page; data quality reports get same-day attention.

### More official-data feeds by this developer

- [US Building Permits Scraper — Construction & Contractor Leads](https://apify.com/curative_blanket/us-building-permits) — daily permits from 5 major US cities, normalized for lead gen
- [Austin Building Permits API](https://apify.com/curative_blanket/austin-permits-api) — the deep single-city permit feed with contractor phone numbers
- [SEC Form D Feed — New Private Fundraises](https://apify.com/curative_blanket/sec-form-d-feed) — companies file with the SEC before the press writes about them
- [USAJobs Federal Jobs Feed](https://apify.com/curative_blanket/usajobs-federal-jobs-feed) — incremental federal job announcements, agent-ready

*Official data in. Clean leads out. Every day.*

# Actor input Schema

## `daysBack` (type: `integer`):

Return carriers added/authorized in the last N days. Default 30 ensures a cold first run always returns data. For a daily scheduled feed, 2–3 is typical.
## `state` (type: `string`):

Optional 2-letter state code, e.g. 'TX'. Leave blank for all states.
## `carrierOperation` (type: `string`):

Optional. A = Authorized For-Hire, B = Exempt For-Hire, C = Private, D = Other. For-hire (A) carriers are the highest-value insurance/factoring leads.
## `maxResults` (type: `integer`):

Cost guard. New-carrier volume runs to thousands per week nationally.
## `incremental` (type: `boolean`):

On: each run emits only carriers (by DOT number) not seen in prior runs.
## `resetDedup` (type: `boolean`):

Clears the 'seen' memory so the next run re-emits everything. Use for the first run or a health check.
## `datasetId` (type: `string`):

FMCSA census dataset ID on data.transportation.gov. Confirm/update from the portal if FMCSA changes it.
## `dateField` (type: `string`):

Text field (YYYYMMDD) used to detect new carriers. Confirmed: add_date. Alternative: mcs150_date.
## `stateField` (type: `string`):

Field used for the state filter. Confirmed: phy_state.
## `socrataDomain` (type: `string`):

Open-data host.
## `extraWhere` (type: `string`):

Optional raw SoQL appended with AND, e.g. "hm_ind = 'Y'".
## `appToken` (type: `string`):

Optional free token from data.transportation.gov for higher rate limits. Falls back to the SOCRATA_APP_TOKEN env var.

## Actor input object example

```json
{
  "daysBack": 30,
  "maxResults": 1000,
  "incremental": true,
  "resetDedup": false,
  "datasetId": "az4n-8mr2",
  "dateField": "add_date",
  "stateField": "phy_state",
  "socrataDomain": "data.transportation.gov"
}
````

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("curative_blanket/fmcsa-new-carrier-feed").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("curative_blanket/fmcsa-new-carrier-feed").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 '{}' |
apify call curative_blanket/fmcsa-new-carrier-feed --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "FMCSA New Carrier Feed — Fresh Trucking Authority Leads",
        "description": "Every carrier added in the last N days legal name, location, operation type, fleet size, phone, USDOT and MC numbers  normalized into a clean lead schema. Built for insurance agencies, freight factoring, brokers, and AI lead agents targeting the highest-value slice.",
        "version": "0.1",
        "x-build-id": "jlG8Q1vMzg7ZbOY0O"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/curative_blanket~fmcsa-new-carrier-feed/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-curative_blanket-fmcsa-new-carrier-feed",
                "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/curative_blanket~fmcsa-new-carrier-feed/runs": {
            "post": {
                "operationId": "runs-sync-curative_blanket-fmcsa-new-carrier-feed",
                "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/curative_blanket~fmcsa-new-carrier-feed/run-sync": {
            "post": {
                "operationId": "run-sync-curative_blanket-fmcsa-new-carrier-feed",
                "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": {
                    "daysBack": {
                        "title": "Days back",
                        "minimum": 1,
                        "maximum": 365,
                        "type": "integer",
                        "description": "Return carriers added/authorized in the last N days. Default 30 ensures a cold first run always returns data. For a daily scheduled feed, 2–3 is typical.",
                        "default": 30
                    },
                    "state": {
                        "title": "State filter",
                        "type": "string",
                        "description": "Optional 2-letter state code, e.g. 'TX'. Leave blank for all states."
                    },
                    "carrierOperation": {
                        "title": "Carrier operation type",
                        "type": "string",
                        "description": "Optional. A = Authorized For-Hire, B = Exempt For-Hire, C = Private, D = Other. For-hire (A) carriers are the highest-value insurance/factoring leads."
                    },
                    "maxResults": {
                        "title": "Max results per run",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Cost guard. New-carrier volume runs to thousands per week nationally.",
                        "default": 1000
                    },
                    "incremental": {
                        "title": "Incremental mode (only new carriers)",
                        "type": "boolean",
                        "description": "On: each run emits only carriers (by DOT number) not seen in prior runs.",
                        "default": true
                    },
                    "resetDedup": {
                        "title": "Reset dedup memory",
                        "type": "boolean",
                        "description": "Clears the 'seen' memory so the next run re-emits everything. Use for the first run or a health check.",
                        "default": false
                    },
                    "datasetId": {
                        "title": "Socrata dataset ID (advanced)",
                        "type": "string",
                        "description": "FMCSA census dataset ID on data.transportation.gov. Confirm/update from the portal if FMCSA changes it.",
                        "default": "az4n-8mr2"
                    },
                    "dateField": {
                        "title": "Date field (advanced)",
                        "type": "string",
                        "description": "Text field (YYYYMMDD) used to detect new carriers. Confirmed: add_date. Alternative: mcs150_date.",
                        "default": "add_date"
                    },
                    "stateField": {
                        "title": "State field (advanced)",
                        "type": "string",
                        "description": "Field used for the state filter. Confirmed: phy_state.",
                        "default": "phy_state"
                    },
                    "socrataDomain": {
                        "title": "Socrata domain (advanced)",
                        "type": "string",
                        "description": "Open-data host.",
                        "default": "data.transportation.gov"
                    },
                    "extraWhere": {
                        "title": "Extra SoQL filter (advanced)",
                        "type": "string",
                        "description": "Optional raw SoQL appended with AND, e.g. \"hm_ind = 'Y'\"."
                    },
                    "appToken": {
                        "title": "Socrata app token (optional)",
                        "type": "string",
                        "description": "Optional free token from data.transportation.gov for higher rate limits. Falls back to the SOCRATA_APP_TOKEN env var."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```