Using the Motive API: Integration Guide
Quick Summary
Fleet operators who want to connect their trucks, drivers, and compliance data to outside software eventually run into the same question: how do you actually pull that data out of Motive? The answer is the Motive API, a set of secured endpoints that let developers read and update fleet information without logging into the dashboard manually. This guide walks through what the API does, how authentication works, and how a typical integration comes together from start to finish.
Because this topic sits at the intersection of telematics and software development, it helps to see how a broader platform documents the same territory. Motive Fleet Management provides an overview of Motive’s core fleet features, and it is a useful companion resource if you want context on the product before diving into the technical side covered here. With that groundwork in place, let’s look at what the Motive API actually offers and how to start building with it.
What Is the Motive API and Why Would You Use It?
What problem does the API actually solve?
Fleets generate a constant stream of data: vehicle locations, hours-of-service logs, fuel transactions, inspection reports, and driver safety events. Without an API, someone has to export that information manually or re-key it into another system. Consequently, the Motive API exists to automate that transfer, letting a transportation management system (TMS), a maintenance platform, or a custom dashboard pull the data directly and in near real time.
Who typically builds on top of it?
Three groups tend to use the API most often. First, software vendors building integrations that plug into Motive’s App Marketplace, where the goal is usually a polished, reusable connector that many carriers can install. Second, internal engineering teams at trucking companies who want their own reporting tools or dashboards tailored to a specific operation rather than a one-size-fits-all report. Third, freight brokers and TMS providers who need visibility into a carrier’s live location and delivery status, since customers increasingly expect real-time tracking rather than a phone call for an update. Because the use cases differ so much, Motive organizes its documentation around specific workflows rather than a single generic reference, which makes it easier to find the exact endpoints a given project needs instead of wading through an undifferentiated list of routes.
How mature does your team need to be to use it?
You do not need a large engineering department to get value from the API, but you do need someone comfortable making authenticated HTTP requests and parsing JSON or XML responses. Smaller teams often start with a single read-only integration, such as pulling vehicle locations into a spreadsheet or lightweight dashboard, before expanding into two-way syncing with a TMS. Starting small and validating the data first tends to produce a more reliable integration than attempting to build every workflow at once.
What kind of data can you access?
The table below summarizes the main data categories exposed through the API.
| Data Category | Example Endpoints or Use Cases |
|---|---|
| Vehicles and assets | Location, VIN, odometer, engine hours |
| Drivers | Driver profiles, license details, HOS logs |
| Compliance | Inspection reports, violations, ELD logs |
| Safety | Driver performance events, speeding alerts |
| Dispatch and TMS | Loads, routes, dispatch status |
| Fuel and spend | Motive Card transactions and fuel data |
How Do You Get Started With the Motive API?
Where do you find the documentation?
All current documentation lives on the Motive Developer Hub, and it replaced an older, less structured set of guides in January 2025. The refreshed hub organizes content into guides, a searchable API reference, ready-made recipes, and a changelog, so developers no longer have to hunt through scattered pages to find a working example. Postman collections were also added around the same update, giving teams a faster way to test calls before writing any code.
What base URL should your requests use?
Newer integrations should call endpoints under the api.gomotive.com base URL. However, Motive still supports the earlier api.keeptruckin.com base URL for backward compatibility, since that was the company’s original product name before its rebrand. If you are maintaining an older integration, it will likely still work, but new projects should default to the current domain to avoid a future migration.
What do you need before writing any code?
Before touching the API, confirm a few basics:
- An active Motive account with admin or developer access to the dashboard.
- A clear list of the data your integration actually needs, since scopes are granted per use case.
- A decision on authentication method, covered in detail below.
- A test environment or sandbox account, so live fleet data is not affected while you build.
How Does Authentication Work in the Motive API?
What is the simplest way to authenticate?
For straightforward, server-to-server integrations, Motive issues API keys. Each organization receives a unique key that must be included in every request header, which tells the API which account’s data to return. Generating one is a dashboard task rather than a coding task:
- Log in to the Motive Dashboard with an admin account.
- Open the admin view from the icon at the bottom of the menu.
- Navigate to the Developers section.
- Click +Request API Key and give it a name.
- Save the key and store it securely.
Once generated, the key gets passed in a request header, as shown below.
| Header Name | Value |
|---|---|
| X-API-Key | Your generated API key |
A useful detail here is that Motive also offers a Test Mode toggle on the Developers page, so a new key can be exercised against the API without touching live production data.
When should you use OAuth 2.0 instead?
API keys work well for single-organization integrations, but they are not ideal for products that need to connect to many different customer accounts. For that scenario, Motive supports OAuth 2.0, which allows a third-party application to request limited, scoped access to a customer’s data without ever handling that customer’s login credentials directly. This approach is standard for marketplace apps and multi-tenant TMS platforms, since each customer authorizes access independently.
How do scopes affect what your app can do?
OAuth access in Motive uses scopes, so an application receives permission only for the specific data categories it requests, such as vehicle locations or HOS logs, rather than gaining blanket access to the entire account. Consequently, requesting only the scopes your integration truly needs is not just good security practice; it also speeds up customer approval, since fleet administrators are more comfortable granting narrow permissions.
How Do You Structure a Typical Integration Project?
What does a freight visibility integration look like?
Freight visibility integrations are among the most common use cases, since brokers and shippers want to see where a load is without calling the driver. Motive documents this workflow in four general steps: generating an access token, connecting to a customer’s account, fetching that customer’s location and load data, and mapping the response into your own system. Because these integrations typically serve many carriers at once, OAuth is the recommended authentication path here rather than a single shared API key.
What does a TMS integration involve?
Transportation Management System integrations follow a slightly different path, since they usually need to sync entities in both directions rather than just read data. The general sequence looks like this:
- Sync entities — pull driver, vehicle, and asset records so both systems agree on identifiers.
- Set up operations — configure how loads and jobs map between the two platforms.
- Configure dispatches — push dispatch assignments from the TMS into Motive or vice versa.
- View reports — retrieve status updates and reporting data once the sync is live.
What about maintenance and safety integrations?
Maintenance-focused integrations follow the same entity-sync pattern before moving on to vehicle readings such as odometer and engine-hour data, engine fault codes, and inspection reports. Safety integrations, meanwhile, focus on extracting driver performance events and speeding incidents after entities are synced, which supports coaching programs or third-party safety scoring tools. In both cases, starting with entity synchronization first prevents mismatched records later, so it is worth resisting the temptation to skip ahead to the more interesting endpoints.
What Should You Watch Out for During Integration?
How does Motive handle formats and response codes?
Responses come back in JSON or XML, which accommodates different development stacks without forcing a single format. Standard HTTP response codes indicate success or failure, so building solid error handling around those codes early will save debugging time later. Pagination also applies to endpoints that return large data sets, so your integration should request additional pages instead of assuming that a single response contains everything.
Why do time zones and units matter more than they seem?
Fleet data spans multiple time zones and measurement systems, and Motive allows you to configure both to match your application’s needs. Ignoring this early is a common source of subtle bugs, since a timestamp or a distance value that looks correct in testing can be off once real fleets in different regions start using the integration. Setting these preferences at the start of a project is far easier than adding them later, after you have already synced the data.
Is there a way to test calls without writing code first?
Yes. The Developer Hub includes an interactive API explorer along with Postman collections, so a team can test endpoints and inspect real responses before committing to a specific implementation. This proves particularly useful during the planning phase of a project, when the goal is simply to confirm that an endpoint returns the fields you actually need, rather than discovering a missing field after you have already written code around it.
What is the best way to avoid rework later?
Two habits go a long way toward preventing rework. First, map out every field your integration depends on before writing a single line of code, since discovering a missing field midway through development usually forces a redesign. Second, treat the sandbox or Test Mode environment as mandatory rather than optional, even for a small internal tool, because fleet data is operationally sensitive and a bad write request can disrupt dispatch or compliance records. Teams that skip testing to save time in the short term generally spend more time fixing production issues afterward.
Conclusions
Building on the Motive API does not require reinventing how a fleet operates; it requires understanding which workflow best matches your project, whether that is freight visibility, TMS synchronization, maintenance tracking, or safety reporting. Start by confirming the correct base URL and authentication method, since that single decision shapes how the rest of the integration is built. From there, follow Motive’s documented workflows rather than improvising endpoint order, since the entity-sync-first pattern shows up across several integration types for good reason. For readers who want the bigger product picture surrounding these APIs, revisiting Motive Fleet Management alongside the developer documentation gives a fuller view of how the platform’s data and features connect. With the fundamentals in place, most integrations come down to careful scope selection, solid error handling, and testing against Motive’s sandbox tools before going live.
Frequently Asked Questions
It depends on your integration’s shape. A single-organization tool, such as an internal dashboard for your own fleet, generally works fine with a simple API key. A multi-tenant product that connects to many different customers’ Motive accounts should use OAuth 2.0 instead, since it lets each customer authorize access independently without sharing credentials.
New projects should use the api.gomotive.com base URL, since it reflects Motive’s current documentation and naming. The older api.keeptruckin.com base URL still works for existing integrations, but Motive has indicated it may eventually be retired, so building new projects on the current domain avoids a future migration.
Yes. Motive’s Developer Hub provides an interactive API explorer and Postman collections, and API keys can be run in Test Mode so calls do not affect live data. This makes it possible to validate request and response formats fully before an integration touches an actual fleet account.
