> ## Content Index
> Fetch the complete content index at: https://blog.afi.io/llms.txt
> Use this file to discover other available public pages before exploring further.

# Create a Google Maps truck route with the Routes API
- URL: https://blog.afi.io/blog/create-a-google-maps-truck-route-with-the-routes-api/
- Published: 2026-09-11T22:45:46.000Z
- Updated: 2026-09-12T00:04:14.000Z
- Description: A developer's guide to creating a Google Maps truck route with the Routes API, accounting for truck height, weight, and hazmat restrictions.
- Author: Afian Anwar
- Tags: googlemaps

Once a shipment is too heavy or too large for a single driver to load into a standard delivery van, it becomes freight, and freight runs on a different road network from regular vehicles. Trucks that carry freight need to avoid low bridges, narrow tunnels, tight turns, weight restricted roads, and any other obstacles that could block or delay a large vehicle. In this post, I'll walk you through the new [Large Vehicle Routing](https://developers.google.com/maps/documentation/routes/lvr?ref=blog.afi.io) feature of the Google Maps [Routes API](https://developers.google.com/maps/documentation/routes?ref=blog.afi.io), and show you how to generate Google Maps truck routes that automatically avoid roads restricted by vehicle height, weight, length, or hazardous material classification.

![google maps truck route created with the routes api](https://storage.ghost.io/c/c6/4d/c64da7e8-63a6-4cff-acdc-2782a6ebc377/content/images/2026/09/gg-blog-routes-api-large-vehicle-routing-truyck-routing.png)

Part 1: [A developer's guide to the Google Routes API](https://blog.afi.io/blog/a-developers-guide-to-the-google-routes-api/)  
Part 2: [Plan a route with multiple stops using the Routes API](https://blog.afi.io/blog/plan-a-route-with-multiple-stops-using-the-routes-api/)  
Part 3: [Using the Google Distance Matrix API for taxi dispatch](https://blog.afi.io/blog/using-the-google-distance-matrix-api-for-taxi-dispatch/)  
Part 4: [Google Maps Search Along Route](https://blog.afi.io/blog/google-maps-search-along-route/)  
Part 5: How to draw a route on Google Maps for Android with the Routes API  
**Part 6: Create a Google Maps truck route with the Routes API (this article)**

[Google Large Vehicle Routing DemoDemo for Google’s Large Vehicle Routing API. Visualize and optimize delivery routes for large fleets.![](https://storage.ghost.io/c/c6/4d/c64da7e8-63a6-4cff-acdc-2782a6ebc377/content/images/icon/favicon-0b8cc9d3-65ec-4155-a9a5-8b2b8705ffcd.ico)![](https://storage.ghost.io/c/c6/4d/c64da7e8-63a6-4cff-acdc-2782a6ebc377/content/images/thumbnail/logo512-6098cd52-8ccf-4b21-aeb1-b255bdb5cb60.png)](https://google-lvr.afi.dev/?ref=blog.afi.io)

### What is Google Maps truck routing?

Google Maps truck routing (officially called [Large Vehicle Routing](https://mapsplatform.google.com/resources/blog/introducing-large-vehicle-routing-address-the-unique-logistics-needs-of-large-vehicle-fleets/?ref=blog.afi.io), or LVR for short) is Google's routing and driver navigation technology adapted specifically for large commercial vehicles like trucks and buses. Traditional routing algorithms are optimized for the routes and speeds of standard cars and typically do not account for the factors that affect large vehicle fleets such as bridge height clearances, road weight limits, truck prohibited zones and hazardous material regulations.

Google Maps truck routing isn't available in the consumer Google Maps app. It's accessed through two APIs: the [Routes API](https://developers.google.com/maps/documentation/routes?ref=blog.afi.io) (which this article covers) and the Route Optimization API (see [How to use Google Large Vehicle Routing (LVR) with the Route Optimization API](https://blog.afi.io/blog/gmpro-docs-google-large-vehicle-routing/)). Large enterprise fleets can integrate truck routing directly into their own dispatch and delivery software, while smaller owner-operators are more likely to use it indirectly through their transportation or fleet management platform. To see it in action, try our Large Vehicle Routing demo at [https://google-lvr.afi.dev/](https://google-lvr.afi.dev/?ref=blog.afi.io).

### Does Google Maps have truck routes?

The consumer Google Maps app doesn't support truck routing, largely for liability reasons. If Google's mapping data were inaccurate e.g. routing a truck under a low bridge or over a weight restricted one, Google could be held responsible for catastrophic damages.

There's also the matter of cost. Mapping commercial truck corridors, bridge heights, clearance restrictions, turning radius limits, and local truck bans requires specialized datasets that are expensive to acquire and even more expensive to maintain. Commercial truckers represent only a small fraction of overall GPS users, and they're already well served by specialized navigation providers like [Garmin](https://www.garmin.com/en-CA/c/automotive/semi-truck-gps-navigation/?ref=blog.afi.io), [Rand McNally](https://randmcnally.com/product-category/rand-mcnally-truck-gps/?ref=blog.afi.io), and [PC\*MILER](https://pcmilerweb.com/?ref=blog.afi.io), companies that charge high upfront hardware costs or ongoing subscription fees specifically to cover the upkeep of this niche data collection.

### Why did Google launch Large Vehicle Routing?

![](https://storage.ghost.io/c/c6/4d/c64da7e8-63a6-4cff-acdc-2782a6ebc377/content/images/2026/09/route-demo-mockup-2.png)

So what changed? Google Maps has been the leading routing and navigation app for millions of drivers for a decade or more. Its algorithms power not only the consumer app but also tens of thousands of enterprise routing, transportation management, and last mile delivery products. But Google Maps hit market saturation years ago, and once you've reached nearly every driver, the only way to grow is to build new products and features. Truck routing is part of that push.

Launching [Large Vehicle Routing](https://mapsplatform.google.com/resources/blog/introducing-large-vehicle-routing-address-the-unique-logistics-needs-of-large-vehicle-fleets/?ref=blog.afi.io) as an API also gave Google control over its early rollout. By limiting access to a small group of technically sophisticated customers (ones capable of integrating truck routing into both their route planning and driver navigation apps) Google could gather real world feedback on route quality and catch problems before releasing the feature to the general public.

👨‍💻

The screenshots in this post come from our unofficial [Google LVR Demo](https://google-lvr.afi.dev/?ref=blog.afi.io). Feel free to use it yourself to compare car and truck routes side by side.

### How do you create a Google Maps truck route with the Routes API?

For truck routing purposes, what makes a vehicle "large" isn't just size. It's the combination of height, weight, length, axle configuration, and cargo type (especially hazmat) that determines which road restrictions apply. It's easy to add truck routing to the [Compute Routes](https://developers.google.com/maps/documentation/routes/compute-route-over?ref=blog.afi.io) endpoint of the [Routes API](https://developers.google.com/maps/documentation/routes?ref=blog.afi.io). Simply set `travelMode` to "TRUCK" and add a `vehicleInfo` spec that contains the physical dimensions of the vehicle:

```
{
  "travelMode": "TRUCK",
  "routeModifiers": {
    "vehicleInfo": {
      "totalAxleCount": 5,
      "totalHeightMm": 4114,
      "totalLengthMm": 21945,
      "totalWidthMm": 2590,
      "totalWeightKg": 36287,
      "trailerInfo": [
        {
          "lengthMm": 16154
        }
      ],
      "hazardousGoodsTypes": [
        "FLAMMABLE"
      ]
    }
  }
}
```

Before we go any further, it's worth explaining how trucks and other large vehicles are built. A freight truck has two parts: the *tractor*, which the driver operates, and the *trailer*, which is towed behind it and holds the cargo. Think of [Optimus Prime](https://blog.afi.io/blog/fleet-tracking-with-the-google-navigation-connect-api/), leader of the [Autobots](https://en.wikipedia.org/wiki/Autobot?ref=blog.afi.io). He's the tractor, and when he transforms, a trailer magically appears. He probably doesn't use LVR, but he really should.

![](https://storage.ghost.io/c/c6/4d/c64da7e8-63a6-4cff-acdc-2782a6ebc377/content/images/2026/09/image-1.png)

`totalAxleCount` is the combined number of axles on the tractor and trailer (e.g. 3 + 2 = 5). An axle is the central shaft that connects a pair of wheels and supports the vehicle's weight. Some bridges, like the [Lacamas Creek Bridge](https://www.piercecountywa.gov/3419/Bridge-Road-Restrictions?ref=blog.afi.io) near Seattle, set their weight limits by axle count.

`totalHeightMm` is the height of the trailer, which is always taller than the tractor. With LVR enabled, the Routes API routes vehicles around low bridges, tunnels, and overpasses. Standard US trailer height is 13' 6" (4,114 mm).

`totalLengthMm` is the end-to-end length of the tractor and trailer combined. LVR avoids length-restricted roads and tight turns.

`totalWidthMm` is the width of the vehicle. The Routes API actively avoids narrow roads and bridges. Maximum legal trailer width is 8' 6" (2,590 mm).

`totalWeightKg` is the total weight of the loaded tractor-trailer combination. The US federal maximum Gross Vehicle Weight (GVW) is 80,000 lb (36,287 kg).

`trailerInfo[].lengthMm` is the length of the trailer alone. Some cities restrict roads by trailer length independent of total truck length.

`hazardousGoodsTypes` is an array specifying any hazardous materials on board e.g. **"EXPLOSIVES"**, **"FLAMMABLE"**, or **"ENVIRONMENTAL\_HAZARD"** ([Energon cubes](https://tfwiki.net/wiki/Energon?ref=blog.afi.io) probably qualify). This triggers avoidance of tunnels and any routes where that hazard class is prohibited.

### Google Maps truck route worked example

Here's an example of LVR applied to a Routes API [Compute Routes](https://developers.google.com/maps/documentation/routes/reference/rest/v2/TopLevel/computeRoutes?ref=blog.afi.io) request, running from Maspeth, Queens to Jones Beach State Park. The fastest route would normally send you down the [Meadowbrook State Parkway](https://en.wikipedia.org/wiki/Meadowbrook%5FState%5FParkway?ref=blog.afi.io), which is closed to all commercial traffic because of the [low overpasses](https://patch.com/new-york/merrick/truck-hits-highway-overpass-1-person-hurt-police?ref=blog.afi.io) running its length, so LVR has to find a way around it.

**Endpoint** `POST` [https://routes.googleapis.com/directions/v2:computeRoutes](https://routes.googleapis.com/directions/v2:computeRoutes?ref=blog.afi.io)

**Headers**  
Content-Type: *application/json*  
X-Goog-Api-Key: *YOUR\_API\_KEY*  
X-Goog FieldMask: *routes.duration,routes.distanceMeters,routes.routeToken, routes.polyline*

**Request Body**

```
{
 "origin": {
    "location": {
      "latLng": {
        "latitude": 40.728300,
        "longitude": -73.903800
      }
    }
  },
  "destination": {
    "location": {
      "latLng": {
        "latitude": 40.5889,
        "longitude": -73.5124
      }
    }
  },
  "travelMode": "TRUCK",
  "routingPreference": "TRAFFIC_AWARE_OPTIMAL",
  "routeModifiers": {
    "vehicleInfo": {
      "totalAxleCount": 5,
      "totalHeightMm": 4114,
      "totalLengthMm": 21945,
      "totalWidthMm": 2590,
      "totalWeightKg": 32658,
      "trailerInfo": [{
        "lengthMm": 16154
      }]
    }
  }
}
```

You should set `routingPreference` to **"TRAFFIC\_AWARE\_OPTIMAL"** for Large Vehicle Routing requests because it forces the Routes API to consider many more candidate roads to find one that actually satisfies all the vehicle's height, weight, length, and hazmat constraints. Cheaper modes e.g. **"TRAFFIC\_UNAWARE"** prune the search space in ways that can miss a compliant route.

**Response**

```
{
    "routes": [
        {
            "distanceMeters": 68245,
            "duration": "3871s",
            "polyline": {
                "encodedPolyline": "}vqwFjkabMzAB|A}D|@cCVkIbAw@\\c@rEwDnA_^@aDQaFg@oEWqA_AuC[s@]]{FkLs@iBo@{Bc@wB]sC]cGESq@yRQg@WeBe@iBk@mBUSwC_KgAyEiKug@aGiWiPoy@u@oF}@mJo@oEcAeF_@uAF[aB{GkA{DiJqV{EqMwAwEOsAIoB@mBHMLu@^aAl@}@lAmAv@e@bAc@z@UJS`HqAlCWXLtED^FlCIrBO^G\\HhBIXHTV\\n@}AZwBs@aAAMt@Q`@mBBc@K_@UW]sBmD[]_@KkACmAJq@TsCrAq@TqFt@aCVgAAcAUwCyAk@o@Qc@Ec@V_FIYF}FIYvBud@`@cEj@{Dj@oC`P_r@t@kEVgCZqELcHt@mk@NqQ^yXCeCMyC[eDm@qDcTclAD_@]mDD]k@oD}Cy_@?cANeAh@aBd@wAV}AJ_B@uBIuBUuBa@kBk@aBk@_Aw@s@m@[kGoBe@]]k@Oi@eGe]cB_JkA_FaA_D_BuDq@{BoAyFwByMSSk@yBQ]m@mEqAgNg@aDy@iDo@oByAcDee@uy@_DmGiBkE}@sCaDqMg@}AkA{CaB}CuEeIaA_CsA{DaAsDs@{Di@iEUsCo@cO[_Ea@oCk@eCs@{Bm@yA{AqCoGoIgB{BgAyBgA_Dg@iBc@cC_@gD[qEi@aLCiDDoCNaCX}Bb@gCb@cBbFoPr@eDb@_DViDJkD?iDI_CWwDc@aDo@cD{@yCiAwCkRa`@_AkCq@gCa@aC[qCcGw}@a@mFi@uDq@iDw@sCw@yBoAoCwA_CsAcBoHoH_BuBsAeCcAgCs@kCk@cDsCuV]iB}@uC{@yBeAoB}IoMyAkCsAcDgAsDo@{Cg@aD]sDMwCE_DLeYCsPHgE`AwTJuG?eGIaJBoEP{EVeEdA_JhB_OXaEJsDAgEMeEo@oJEoCBkDReDVgCl@gDz@aDbAoCvIeSz@iC`AsE`@{CVaDFqC?}BI}CWiDi@{Eu@{EgAkF{FsT}AaHsAaHaAmG]aDQiDGiDByDPgD\\gDf@_Dr@{C|@uCfAkC`IcP|AyDl@mBn@{BbA}E`@qCPiBPmDByCAiBOkD]eFe@oEwSk_BWeCc@{FYmFOoGQmRYuMg@iNw@{N{@yLw@kIkBcQuAqKmBeMyB{MeAcFoBwHaA}C{D}IwC}FuOkZ}AqD{@}BsEkNuD_MyCaLeAoEkIwb@sAiI_A_I}@mKw@eLa@yHJWBs@XcCZsAzCeJAW~A{Eh@_At@w@b@Ul@QLUrPwDvdAmVfF_AdFk@rF_@fKg@fEc@~Du@lEmAnQsGpEqAnp@gObp@_OvDk@bCQpEEn|@u@|IDfIVrfBxHlDTjDb@`BZnGbBpEjBfCrA`EfCfDnCzCvCxQfTtEjFzDzDhGpFpEfDdFjDjEfCvFpClBx@rj@dTnGrBdHjBvHzAdHdArHr@~G^tHNbHC~GQ`Hc@rHy@nHkAxGwA|_@kJlBYjCMXLfDFzBRnAZ|H|DpCzATZL^J`@FvDHvHJTlAxeAFdBTrCzB|TBXQf@WRW@[KOWGc@B_@BIA_@x@kBx@wAdBsBxAgAlAm@bBi@dBU|kAcBpDDb[v@`BK~A]zAm@fAm@fR{SzAmA`BaAbBo@vV{GlHmAph@kD~Ba@~@U`MeFrA[vAItAB~@FtA\\zJxDfBf@jBTtABvAIjB_@bAYf@UfNmKnAm@tAa@tAQtAEvADjBXrA`@nAl@hAz@dAdAz@pAt@zAvAdEjEzMjAlCtA`C|AvBfBfBnBzAlAr@vAp@~@VHVbAj@vBhBjArA|AxBdAnBtAdDdAzDf@hCd@pEd@|Gd@|Dj@~CxAnGr@|Dd@|D\\dEP|DBjAVNRCPUKyDG}@jPkB~AfYRRP?LKDU[yFiAcNe@_GuDcq@x@?PDRNPj@JrBzAQ@E"
            },
            "routeToken": "CscDCswCMskCGq0CCmgCFhumAbwsZ8qOCPi4CP6EAoG8Jt-GAYm-vQHqq8sE3dYM3roO2JsFm9oC-bIFsa0QwIUTsY6YEO-xkAS5qviPAoba1ZwDi5amKc2TngGE36AKz7nmCfGrmgG-0wuhhw6h3y7C1YUBABJsnXvKhyVJDLZE7EbbmJjzrT652VvO63AvAA3et6gJuxA9uP416sbzlN7pU00yROelXJSgkwj4OOMnHGyNLgyVr8NZQEYpZpv3YYatmHcBQQuG9QjYvAhlFZOIGVxeyF2Bl5-mBjimYXocwoAGGiEALAkhFwgBAAUdQgxQHKMBogG1C9wGgAIMnwY2SH4GOCUqGz0Jam0Ad3YCBwc2XgcGc3YGAAMaCWALYXIqTj01gxg_RRk-qj5IzIKfnZCS5ev8ASIXYkVxamFzSENQTjN3LWRJUC1ZSFl5QVkQBRpdClsSFggAEAMQBhATEBIYAkIEGgIIBUoCCAEiGwoXYkVxamFydldIOTN3LWRJUC1ZSFl5QVlwASgEMiJ1bmlmaWVkLWNvc3Q6OmRyaXZpbmctZmFzdGVzdC1wYXRoIhUAQzqku8idA6uVevkct-e4Bjw8aLsSICIedHJ1Y2tpbmc6OnVuaWZpZWQtcmVzdHJpY3Rpb25zGhgKCg14pUYYFbEi89MSCg04pUYYFdAs89MiFSAFKJIgMLmrATieFECS_wFSAxCafigBMAE"
        }
    ]
}

```

Compared to a regular Routes API request, the Google Maps truck route takes almost three times as long. That's not only because it avoids the Meadowbrook State Parkway. The travel speeds modeled for trucks are also much slower.

![](https://storage.ghost.io/c/c6/4d/c64da7e8-63a6-4cff-acdc-2782a6ebc377/content/images/2026/09/image-2.png)

The response from a LVR request looks no different from a standard Routes API response. The `routes` array contains one or more `route` objects, each with:

`distanceMeters`, the total distance of the route,

`duration`, the total travel time, in seconds,

`polyline.encodedPolyline`, the encoded route geometry, which can be decoded into a list of latitude/longitude pairs and used to draw the truck route on a map.

`routeToken`, an encoded string that can be passed to the [Navigation SDK](https://mapsplatform.google.com/maps-products/navigation-sdk/?ref=blog.afi.io) to ensure the driver is shown the same truck specific route.

🌐

For a deep dive on the Routes API, see my other blog post [Plan a route with multiple stops using the Routes API](https://blog.afi.io/blog/plan-a-route-with-multiple-stops-using-the-routes-api/). 

### Google Maps truck route use cases

Unlike LVR on the [Route Optimization API](https://developers.google.com/maps/documentation/route-optimization?ref=blog.afi.io) which is built for optimizing multi stop routes across an entire fleet, truck routing on the [Routes API](https://developers.google.com/maps/documentation/routes?ref=blog.afi.io) is designed for point to point routing with a single origin to a single destination. It's still early days, but here's how I think large trucking companies could use LVR:

**In-app truck navigation**

By passing the `routeToken` from the response into the [Navigation SDK](https://mapsplatform.google.com/maps-products/navigation-sdk/?ref=blog.afi.io), your drivers get truck specific turn-by-turn navigation that keeps them on a truck legal route, instead of a consumer GPS route that could send them down a restricted road ([docs](https://developers.google.com/maps/documentation/navigation/android-sdk/large-vehicle-navigation?ref=blog.afi.io)).

![](https://storage.ghost.io/c/c6/4d/c64da7e8-63a6-4cff-acdc-2782a6ebc377/content/images/2026/09/lvr_flow--1-.png)

The workflow is straightforward. Your backend requests a truck route from the Routes API and gets back a `routeToken`. It passes that token to your mobile driver app, which hands it off to the Navigation SDK to start the trip. From there, the SDK takes over the entire turn-by-turn experience, and if the driver misses a turn or hits an unexpected closure, it reroutes automatically while still respecting the vehicle restrictions baked into the original token.

**Freight rate and billing calculation**

Freight is typically priced on some combination of distance, weight, and the amount of trailer space it takes up. And because distance drives so much of that price, the mileage figure itself has to be trustworthy. Before a common standard emerged, carriers, shippers, and brokers routinely disagreed on how far a load had actually traveled, which made billing and settlement inconsistent. The current system of record for distance in the US comes from [PC\*MILER](https://pcmilerweb.com/?ref=blog.afi.io), a truck specific mileage and routing program developed in 1986\. PC\*MILER isn't going anywhere. It's the mileage system of record that the US trucking industry runs on. 

But that dominance was built in an era when accurate truck mileage was expensive and hard to produce, which is exactly what Google Maps is trying to disrupt with LVR. By putting truck specific distances and ETAs behind a modern, low cost API backed by Google's global map and traffic data, LVR gives any Transportation Management System (TMS) or logistics developer the ability to generate their own truck mileage, chipping away at the assumption that there's only one trusted source of trucking distance.

**Calculating driver pay**

Many carriers pay drivers by the mile, and Large Vehicle Routing on the Routes API can serve as a consistent, defensible source for that mileage, keeping pay disputes down and giving both sides a number they trust.

In practice, though, it will be a while before LVR is used this way. Driver pay in US trucking is rarely calculated by a standalone payroll app. It's almost always a module inside the carrier's TMS, because pay has to be computed from operational data. Mileage, loads, stops, backhauls etc that already lives there. And most of those systems ([McLeod Software](https://www.mcleodsoftware.com/?ref=blog.afi.io), [Trimble](https://transportation.trimble.com/en?ref=blog.afi.io), [TruckLogics](https://www.trucklogics.com/?ref=blog.afi.io)) already rely on PC\*MILER or an equivalent legacy mileage engine. For LVR to become the source of pay mileage, it has to displace that engine inside the TMS, a much harder path than simply offering a better API.

### Google Maps truck route pricing

Large Vehicle Routing doesn't cost extra. There's no separate LVR SKU. A Google Maps truck route is billed exactly like any other Routes API request, based on the features it uses. Because LVR requires `routingPreference` to be set to **"TRAFFIC\_AWARE\_OPTIMAL"**, each request falls under the Compute Routes Pro SKU (currently at $10 CPM, with a monthly free tier), the same as any other traffic aware route. In other words, you get Google Maps truck routing at no cost beyond the standard traffic aware Routes API request you're already paying for.

This is great news, especially if you're already using the Routes API for standard car routing and want to add truck routing to your existing stack.

### Where Google Maps truck routing is headed next

Google Maps Large Vehicle Routing is a big deal, but it won't transform commercial trucking overnight.

First, it's still limited in reach. LVR is generally available only across the contiguous 48 US states, with experimental support in Japan, and it's missing some features fleets will expect, like truck toll pricing and speed limits. ([Reach out](https://www.linkedin.com/in/afian-anwar/?ref=blog.afi.io) if you run a large freight operation outside these regions and want LVR in your country).

Second, it's not in the consumer Google Maps app, so individual owner-operators can't simply pull it up on their phones. And enterprise carriers running TMSs built on [PC\*MILER](https://pcmilerweb.com/?ref=blog.afi.io) or other legacy truck-routing providers won't touch LVR until their TMS vendors make the switch.

Third, and most importantly, many freight contracts between carriers, brokers, and shippers explicitly tie rates and driver pay to PC\*MILER mileage. That's a lock in that has nothing to do with routing quality and everything to do with contractual inertia.

Where I've seen LVR gain significant traction is with large delivery fleets that:

1. **Run a mix of trucks and standard delivery vans.** These operators typically have their own in-house software and already use the standard Google Maps APIs for route planning and dispatch, but rely on a *different* mapping provider for truck navigation. Standardizing everything on Google Maps cuts costs and keeps ETAs and stop sequences consistent from planning through execution.
2. **Operate somewhere like the New York tri-state area** or regions packed with truck-restricted roads, low bridges, and tunnels can easily trip up an inexperienced driver, with serious consequences.
3. **Need accurate customer facing ETAs and delivery windows** that reflect the actual routes and speeds of large vehicles, not passenger cars.

If this sounds like you, [reach out](https://www.afi.io/contact%5Fus?ref=blog.afi.io). I'm happy to walk you through a demo of LVR and set you up with a working Google Maps API key.

**This article was written by** [**Afi Labs**](https://afi.io/?ref=blog.afi.io)**, a** [**Google Maps Premier Partner**](https://www.afi.io/?ref=blog.afi.io) **and reseller. We build route optimization, navigation, and fleet tracking software on Google Maps, and offer volume pricing on GMP licensing.** [**Talk to an engineer**](https://www.afi.io/contact%5Fus?ref=blog.afi.io) **or** [**follow Afian on LinkedIn**](https://www.linkedin.com/in/afian-anwar/?ref=blog.afi.io)**.**