CarrierOk

CarrierOk vs. the official FMCSA APIs.

FMCSA publishes two carrier APIs of its own, QCMobile and MOTUS, and both are free. Here’s what each returns, what it withholds, and what you’d be building yourself, compared against CarrierOk on data we probe every day.

Get a sandbox keyView API docs
The short answer

FMCSA publishes two free APIs, QCMobile and MOTUS. Between them they return registration, operating authority and out-of-service status, and neither returns a BASIC percentile, an ISS score, insurance history, or any record of what changed. A commercial carrier data API is what you buy when you need those. CarrierOk returns all of them in one call.

Free options
QCMobile and MOTUS are authoritative for what they carry, free to use, and documented by FMCSA. For registration and authority lookups, they are enough.
What they withhold
Neither computes a BASIC percentile or an ISS score, and FMCSA's public SMS site withholds two of the seven percentiles it does publish.
What is missing
No change tracking, no monitoring, and no history: each call answers about now, so you cannot tell what moved since the last time you asked.
What to compare
Coverage, the field count per record, whether risk is computed or raw, update cadence, whether pricing is published, and whether you can evaluate it without a sales call.
CarrierOk's shape
One REST call returns 300+ fields with all 7 percentiles, the ISS score and 50+ named risk signals. Free sandbox key, published per-endpoint rates, pay-as-you-go.
Bottom Line

In any FMCSA data provider comparison, start with the free official APIs: QCMobile and MOTUS handle registration and authority lookups at low volume. The difference is what they cannot serve. CarrierOk adds the complete aggregated record in one call, the computed scores FMCSA does not publish (the ISS and all 7 BASIC percentiles), and portfolio monitoring.

Last updated September 2026, checked against each provider’s live API responses, which we probe daily.

Feature Matrix

Side by side, from daily probes.

Official-API cells from live responses we probe daily, as of September 2026

Scroll the table sideways to compare all three →

Feature comparison: CarrierOk API against the official FMCSA sources
FeatureCarrierOkQCMobileMOTUS
Cost
Pay-as-you-go ($50 credit)
Free
Free
Authentication
API key (Bearer)
webKey on every request
None on public endpoints
Format
REST / JSON
REST / JSON
REST / JSON
Lookup keys
DOT, MC/docket, name, phone, email
DOT, docket, name
DOT or legal/DBA name only
Complete record in one call
236 fields raw, 300+ full
Several endpoints
Several endpoints
Operating authority & dockets
Yes
Yes
Yes
Registration history
20 years
Current state only
Registration-history endpoints
Daily register of new entrants
Yes
No
Daily REGISTER report
BASIC percentiles
All 7 computed, including the 2 FMCSA withholds
Field returned, but “Not Public” where FMCSA withholds
No
Computed ISS score (1–100)
Yes
No
No
50+ named risk signals
Yes
No
No
Chameleon carrier detection
Yes
No
No
Policy-level insurance data
Yes
No
Insurance-requirement flags & filing counts
VIN-decoded fleet data
Yes
No
No
Portfolio monitoring & alerts
Yes
No
No
Interface stability
Versioned (/v2)
Stable
Early-stage, still changing

All product and company names are trademarks or registered trademarks of their respective holders. Use of them does not imply any affiliation with or endorsement by them. Information about third-party products is based on each vendor’s publicly available materials and customer reports as of September 2026; capabilities and pricing change; confirm current details directly with each vendor. Statements identified as customer reports reflect individual experiences and may not be representative.

Building on FMCSA Directly

Why teams stop building directly on FMCSA.

QCMobile and MOTUS are free, official, and genuinely useful. These are the four things teams run into once a prototype turns into a workflow.

The percentiles arrive withheld

QCMobile returns a basicsPercentile field on every BASIC, and its value is often the string “Not Public”. FMCSA withholds Crash Indicator and Hazmat from public view entirely. You get the shape of the answer without the number, and no way to rank a carrier against its peers.

One carrier is several calls

QCMobile splits a carrier across separate endpoints for authority, cargo carried, operation classification, out-of-service and BASICs. MOTUS splits entity, registrations, business information and filings again. Assembling one profile means fanning out and reconciling, on every lookup.

Nothing tells you when something changed

Neither API has monitoring. Detecting an insurance lapse or a revoked authority means re-querying every carrier you care about on a schedule and diffing the results yourself, for as many carriers as you have.

You inherit a migration in progress

MOTUS is replacing the legacy registration endpoints and is still changing shape. Building directly on FMCSA means tracking that migration yourself, on FMCSA's timetable rather than yours.

Response Quality

The same carrier lookup, answered twice.

On the left, one CarrierOk profile call. On the right, a QCMobile BASICs response captured from our own probes, shown verbatim.

CarrierOk APIone call
{
  "total_count": 1,
  "items": [{
    "dot_number": "1234567",
    "legal_name": "APEX TRANSPORT LLC",
    "authority_common": "Active",
    "iss_value": "82",
    "iss_recommendation": "INSPECT",
    "basic_percentile_unsafe_driving": 0.84,
    "basic_percentile_vehicle_maintence": 0.83,
    "basic_percentile_hours_of_service": 0.29,
    "basic_percentile_crash_indicator": 0.62,
    "basic_alert_unsafe_driving": true,
    "basic_alert_vehicle_maintence": true,
    "risk_score": "High",
    "risk_score_probability": 0.84,
    "insurance_bipd_on_file": "1000000",
    "...": "300+ fields per record"
  }]
}
QCMobile BASICsreal response, DOT 568253
{
  "content": [{
    "basic": {
      "basicsType": { "basicsCode": "Unsafe Driving" },
      "basicsPercentile": "Not Public",
      "measureValue": "1.65",
      "basicsViolationThreshold": "65",
      "onRoadPerformanceThresholdViolationIndicator": "Not Public",
      "basicsRunDate": "2017-01-27T05:00:00.000+0000"
    }
  }],
  "retrievalDate": "..."
}

// The percentile field is there. The number is not.
// Crash Indicator and Hazmat are withheld outright.
// No ISS. No risk signals. No insurance policy data.
Decision Guide

Which API should you use?

Use QCMobile or MOTUS when:

  • ·You need occasional, low-volume carrier lookups
  • ·Registration and authority status is all you need
  • ·You're prototyping and cost is the only constraint
  • ·You don't need monitoring or computed scores

Use CarrierOk when:

  • You want the complete FMCSA record in one call (/v2/profile-fmcsa, priced per call)
  • You need computed ISS scores and all 7 BASIC percentile ranks
  • You need a monitored portfolio instead of a polling loop
  • You're building insurance, factoring, brokerage, or TMS workflows
  • You need chameleon carrier detection or fraud signals

Carrier Data API Comparison: Frequently Asked Questions

CarrierOk is a carrier intelligence API. It consolidates the FMCSA record on any motor carrier or broker and adds the scoring FMCSA does not publish: all 7 BASIC percentiles, a computed ISS score, 50+ named risk signals, and policy-level insurance history, with monitoring that reports changes the same day. The same record is delivered however you consume it: a REST API, the web app, a Chrome extension, or bulk files.
Compare six things, in this order: coverage (every FMCSA registrant, or only active carriers), what each record returns (raw federal fields, or computed scoring on top), whether the API tells you what changed since your last call, update cadence, whether pricing is published rather than quoted, and whether you can evaluate it without talking to sales. FMCSA's own QCMobile and MOTUS APIs are free and authoritative for registration and authority, and return no BASIC percentiles, no ISS score and no change tracking, which is the line where a commercial API starts to earn its price.
Two, both free. QCMobile (mobile.fmcsa.dot.gov) is the long-standing one: request a webkey through an FMCSA developer account and pass it on every call; our QCMobile API guide walks through the setup. MOTUS (motus.dot.gov) is newer and is replacing the legacy registration endpoints; a large part of its surface needs no key at all. Neither is deprecated, and for straightforward registration and authority lookups either one may be all you need.
MOTUS is FMCSA's newer registration system at motus.dot.gov, replacing the legacy LIVIEW Daily Register endpoints. It returns REST/JSON: carrier search, carrier detail by DOT, entity registrations with operating authority status, business information, registration history, filing counts and a daily register report. Search accepts a USDOT number or a legal/DBA name; it does not accept an MC docket number, an EIN, or an entity UUID. It is early-stage and still changing, so treat any integration as a moving target.
Partly. QCMobile's BASICs endpoint returns a percentile field for each BASIC, but its value comes back as “Not Public” wherever FMCSA withholds it, and Crash Indicator and Hazmat are withheld from public view outright. You also get the raw measure value and the intervention threshold, so you can see that a measure exists without being able to rank it against peers. CarrierOk computes all seven percentiles, including the two FMCSA withholds; the BASIC Percentiles API page has the details.
SAFER is a public lookup website with a company snapshot. It is not a production API, and FMCSA does not operate something called “the SAFER API”. What people usually mean by that phrase is saferwebapi.com, a third-party commercial service unaffiliated with FMCSA that resells the snapshot behind a REST interface. Worth knowing before you plan an integration around the name.
CarrierOk ingests FMCSA's official data, the same sources QCMobile and MOTUS read from, and reconciles them into one record: the raw endpoint (/v2/profile-fmcsa) returns 236 FMCSA fields in one call, priced per call. On top of that it computes what FMCSA does not publish: all 7 BASIC percentiles including the two withheld from public view, the ISS score, 50+ risk signals, policy-level insurance records, VIN-decoded fleet data, and cross-entity analysis for chameleon detection. It is not a reseller of another vendor's API.
When you need current registration status, operating authority, or basic identity for a handful of carriers, and you can absorb assembling a profile from several endpoints. Both official APIs are free and neither is going away. The trade is everything FMCSA does not compute (percentile ranks, ISS, risk signals) plus change detection, which neither API offers at all. The full CarrierOk vs. QCMobile comparison takes this question feature by feature.
Underwriting needs percentile ranks rather than raw counts, and it needs the two BASICs FMCSA withholds. Neither official API returns those, so an underwriting workflow built directly on FMCSA stalls at exactly the point that matters. CarrierOk returns all 7 BASIC percentiles with alert flags, the ISS score with its PASS / OPTIONAL / INSPECT recommendation and the reason behind it, policy-level insurance records with coverage amounts and effective dates, and chameleon detection in one call.
The API has no trial tier; evaluation happens in the free sandbox, which returns fixture data for 10 carriers with no credit card required and all endpoints available. When you're ready for live data, a $50 activation is applied as $50 of API credit, and billing is usage-based and priced by endpoint: the raw FMCSA endpoint per call, full profiles and monitoring per unique carrier per month.

Related pages

CarrierOk vs. QCMobile, in depthQCMobile API guide (WebKey setup)Full FMCSA API referenceWhere to find FMCSA API documentationHow to get an FMCSA API key

Start in the free sandbox.

Fixture data for 10 carriers, every endpoint, no card required. Live access is pay-as-you-go: the raw FMCSA endpoint per call, full profiles and monitoring per unique carrier per month.

Get a sandbox keyExplore the API