This page shows how to get started with the client libraries for Routes API.

Read more about the client libraries in [Client Libraries
Explained](https://cloud.google.com/apis/docs/client-libraries-explained).

## Installing the client library

### Java

For more information, see
[Setting Up a Java Development Environment](https://cloud.google.com/java/docs/setup).

See [Google Routes API Client for Java](https://github.com/googleapis/google-cloud-java/tree/main/java-maps-routing)
for the installation instructions.

### Go


```
go get cloud.google.com/go/maps
```
For more information, see [Setting Up a Go Development Environment](https://cloud.google.com/go/docs/setup).

<br />

See [Google Routes API Client for Go](https://pkg.go.dev/cloud.google.com/go/maps/routing/apiv2)
for the installation instructions.

### Node.js


```
npm install @googlemaps/routing
```
For more information, see [Setting Up a Node.js Development Environment](https://cloud.google.com/nodejs/docs/setup).

<br />

For the complete installation instructions, see [Google Routes API Client for Node.js](https://github.com/googleapis/google-cloud-node/tree/main/packages/google-maps-routing)

### Python


For more information, see
[Setting Up a Python Development Environment](https://cloud.google.com/python/docs/setup).

For the complete installation instructions, see [Google Routes API Client for Python](https://github.com/googleapis/google-cloud-python/tree/main/packages/google-maps-routing)

### .Net


For more information, see
[Setting Up a .Net Development Environment](https://cloud.google.com/dotnet/docs/setup).

For the complete installation instructions, see [Google Routes API Client for .Net](https://github.com/googleapis/google-cloud-dotnet/tree/main/apis/Google.Maps.Routing.V2)

## Setting up authentication

When you use client libraries, you use
[Application Default Credentials (ADC)](https://cloud.google.com/docs/authentication/application-default-credentials)
to authenticate. For information about setting up ADC, see
[Provide credentials for Application Default Credentials](https://cloud.google.com/docs/authentication/provide-credentials-adc).
For information about using ADC with client libraries, see
[Authenticate using client libraries](https://cloud.google.com/docs/authentication/client-libraries).

## Using the client library

### Java


**Compute Routes example:**

```java
import com.google.maps.routing.v2.*;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
   
public class Main {
  public static void main(String[] arguments) throws IOException {
      RoutesSettings routesSettings = RoutesSettings.newBuilder()
              .setHeaderProvider(() -> {
                  Map<String, String> headers = new HashMap<>();
                  headers.put("X-Goog-FieldMask", "*");
                  return headers;
              }).build();
      RoutesClient routesClient = RoutesClient.create(routesSettings);
       
      ComputeRoutesResponse response = routesClient.computeRoutes(ComputeRoutesRequest.newBuilder()
              .setOrigin(Waypoint.newBuilder().setPlaceId("ChIJeRpOeF67j4AR9ydy_PIzPuM").build())
              .setDestination(Waypoint.newBuilder().setPlaceId("ChIJG3kh4hq6j4AR_XuFQnV0_t8").build())
              .setRoutingPreference(RoutingPreference.TRAFFIC_AWARE)
              .setTravelMode(RouteTravelMode.DRIVE).build());
      System.out.println("Response: " + response.toString());
  }
}
```

<br />

**Route Matrix example:**

```java
import com.google.api.gax.rpc.ServerStream;
import com.google.api.gax.rpc.ServerStreamingCallable;
import com.google.maps.routing.v2.*;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
   
public class Main {
  public static void main(String[] arguments) throws IOException {
      RoutesSettings routesSettings = RoutesSettings.newBuilder()
              .setHeaderProvider(() -> {
                  Map<String, String> headers = new HashMap<>();
                  headers.put("X-Goog-FieldMask", "*");
                  return headers;
              }).build();
      RoutesClient routesClient = RoutesClient.create(routesSettings);
       
      ServerStreamingCallable<ComputeRouteMatrixRequest, RouteMatrixElement> computeRouteMatrix = routesClient.computeRouteMatrixCallable();
      ServerStream<RouteMatrixElement> stream = computeRouteMatrix.call(ComputeRouteMatrixRequest.newBuilder()
              .addOrigins(RouteMatrixOrigin.newBuilder()
                      .setWaypoint(Waypoint.newBuilder().
                              setPlaceId("ChIJeRpOeF67j4AR9ydy_PIzPuM").build()))
              .addDestinations(RouteMatrixDestination.newBuilder()
                      .setWaypoint(Waypoint.newBuilder().setPlaceId("ChIJG3kh4hq6j4AR_XuFQnV0_t8").build())
                      .build()).setTravelMode(RouteTravelMode.DRIVE)
              .build());
      for (RouteMatrixElement element : stream) {
          System.out.println("Response : " + element.toString());
      }
  }
}
```

<br />

### Go


**Compute Routes example:**

```go
import (
  "context"
  "fmt"
  "io"
  "os"
     
  routing "cloud.google.com/go/maps/routing/apiv2"
  "cloud.google.com/go/maps/routing/apiv2/routingpb"
  "google.golang.org/grpc/metadata"
)
   
func main() {
  ctx := context.Background()
  client, err := routing.NewRoutesClient(ctx)
  if err != nil {
    fmt.Fprintf(os.Stderr, "error: %v\n", err)
    os.Exit(1)
  }
     
  computeRoutesReq := routingpb.ComputeRoutesRequest{
    Origin: &routingpb.Waypoint{
      LocationType: &routingpb.Waypoint_PlaceId{
        PlaceId: "ChIJeRpOeF67j4AR9ydy_PIzPuM",
      },
    },
    Destination: &routingpb.Waypoint{
      LocationType: &routingpb.Waypoint_PlaceId{
        PlaceId: "ChIJG3kh4hq6j4AR_XuFQnV0_t8",
      },
    },
    RoutingPreference: routingpb.RoutingPreference_TRAFFIC_AWARE,
    TravelMode:        routingpb.RouteTravelMode_DRIVE,
  }
  ctx = metadata.AppendToOutgoingContext(ctx, "X-Goog-FieldMask", "*")
  computeRoutesResponse, err := client.ComputeRoutes(ctx, &computeRoutesReq)
  if err != nil {
    fmt.Fprintf(os.Stderr, "error: %v\n", err)
    os.Exit(1)
  }
  fmt.Fprintf(os.Stdout, "response: %v\n", computeRoutesResponse)
}
```

<br />

**Route Matrix example:**

```go
import (
  "context"
  "fmt"
  "io"
  "os"
     
  routing "cloud.google.com/go/maps/routing/apiv2"
  "cloud.google.com/go/maps/routing/apiv2/routingpb"
  "google.golang.org/grpc/metadata"
)
   
func main() {
  ctx := context.Background()
  client, err := routing.NewRoutesClient(ctx)
  if err != nil {
    fmt.Printf("error: %v\n", err)
    os.Exit(1)
  }
     
  computeRouteMatrixReq := routingpb.ComputeRouteMatrixRequest{
    Origins: []*routingpb.RouteMatrixOrigin{
      {
        Waypoint: &routingpb.Waypoint{
          LocationType: &routingpb.Waypoint_PlaceId{
            PlaceId: "ChIJeRpOeF67j4AR9ydy_PIzPuM",
          },
        },
      },
    },
    Destinations: []*routingpb.RouteMatrixDestination{
      {
        Waypoint: &routingpb.Waypoint{
          LocationType: &routingpb.Waypoint_PlaceId{
            PlaceId: "ChIJG3kh4hq6j4AR_XuFQnV0_t8",
          },
        },
      },
    },
    TravelMode: routingpb.RouteTravelMode_DRIVE,
  }
  ctx = metadata.AppendToOutgoingContext(ctx, "X-Goog-FieldMask", "*")
  stream, err := client.ComputeRouteMatrix(ctx, &computeRouteMatrixReq)
  if err != nil {
    fmt.Fprintf(os.Stderr, "error: %v\n", err)
    os.Exit(1)
  }
  for {
    element, err := stream.Recv()
    if err == io.EOF {
      break
    }
    if err != nil {
      fmt.Fprintf(os.Stderr, "error: %v\n", err)
      os.Exit(1)
    }
    fmt.Fprintf(os.Stdout, "element: %v\n", element)
  }
}
```

<br />

### Node.js


**Compute Routes example:**

```javascript
// Imports the Routing library
const { RoutesClient } = require("@googlemaps/routing").v2;
const origin = {
  location: {
    latLng: {
      latitude: 37.419734,
      longitude: -122.0827784,
    },
  },
};
const destination = {
  location: {
    latLng: {
      latitude: 37.41767,
      longitude: -122.079595,
    },
  },
};
// Instantiates a client
const routingClient = new RoutesClient();
async function callComputeRoutes() {
  const request = {
    origin,
    destination,
  };
  // Run request
  const response = await routingClient.computeRoutes(request, {
    otherArgs: {
      headers: {
        "Content-Type": "application/json",
        "X-Goog-Api-Key": "YOUR_API_KEY",
        "X-Goog-FieldMask":
          "routes.duration,routes.distanceMeters,routes.polyline.encodedPolyline",
      },
    },
  });
  console.log(response);
}
callComputeRoutes();
```

<br />

**Compute Route Matrix example:**

```javascript
// Imports the Routing library
const { RoutesClient } = require("@googlemaps/routing").v2;
const origins = [
  {
    waypoint: {
      location: {
        latLng: {
          latitude: 37.420761,
          longitude: -122.081356,
        },
      },
    },
  },
  {
    waypoint: {
      location: {
        latLng: {
          latitude: 37.403184,
          longitude: -122.097371,
        },
      },
    },
  },
];
const destinations = [
  {
    waypoint: {
      location: {
        latLng: {
          latitude: 37.420999,
          longitude: -122.086894,
        },
      },
    },
  },
  {
    waypoint: {
      location: {
        latLng: {
          latitude: 37.383047,
          longitude: -122.044651,
        },
      },
    },
  },
];
// Instantiates a client
const routingClient = new RoutesClient();
async function callComputeRouteMatrix() {
  // Construct request
  const request = {
    origins,
    destinations,
  };
  // Run request
  const stream = await routingClient.computeRouteMatrix(request, {
    otherArgs: {
      headers: {
        "Content-Type": "application/json",
        "X-Goog-Api-Key": "YOUR_API_KEY",
        "X-Goog-FieldMask": "*",
      },
    },
  });
  stream.on("data", (response) => {
    console.log(response);
  });
  stream.on("error", (err) => {
    throw err;
  });
  stream.on("end", () => {
    /* API call completed */
  });
}
callComputeRouteMatrix();
```

<br />

### Python


[View on GitHub](https://github.com/googleapis/google-cloud-python/blob/main/packages/google-maps-routing/samples/generated_samples/routes_v2_generated_routes_compute_routes_async.py)

```python
# This snippet has been automatically generated and should be regarded as a
# code template only.
# It will require modifications to work:
# - It may require correct/in-range values for request initialization.
# - It may require specifying regional endpoints when creating the service
#   client as shown in:
#   https://googleapis.dev/python/google-api-core/latest/client_options.html
from google.maps import routing_v2


async def sample_compute_routes():
    # Create a client
    client = routing_v2.RoutesAsyncClient()

    # Initialize request argument(s)
    request = routing_v2.ComputeRoutesRequest()

    # Make the request
    response = await client.compute_routes(request=request)

    # Handle the response
    print(response)

```

### .Net


[View on GitHub](https://github.com/googleapis/google-cloud-dotnet/blob/main/apis/Google.Maps.Routing.V2/Google.Maps.Routing.V2.GeneratedSnippets/RoutesClient.ComputeRoutesRequestObjectAsyncSnippet.g.cs)

```c#
using Google.Maps.Routing.V2;
using Google.Protobuf.WellKnownTypes;
using System.Threading.Tasks;

public sealed partial class GeneratedRoutesClientSnippets
{
    /// <summary>Snippet for ComputeRoutesAsync</summary>
    /// <remarks>
    /// This snippet has been automatically generated and should be regarded as a code template only.
    /// It will require modifications to work:
    /// - It may require correct/in-range values for request initialization.
    /// - It may require specifying regional endpoints when creating the service client as shown in
    ///   https://cloud.google.com/dotnet/docs/reference/help/client-configuration#endpoint.
    /// </remarks>
    public async Task ComputeRoutesRequestObjectAsync()
    {
        // Create client
        RoutesClient routesClient = await RoutesClient.CreateAsync();
        // Initialize request argument(s)
        ComputeRoutesRequest request = new ComputeRoutesRequest
        {
            Origin = new Waypoint(),
            Destination = new Waypoint(),
            Intermediates = { new Waypoint(), },
            TravelMode = RouteTravelMode.TravelModeUnspecified,
            RoutingPreference = RoutingPreference.Unspecified,
            PolylineQuality = PolylineQuality.Unspecified,
            DepartureTime = new Timestamp(),
            ComputeAlternativeRoutes = false,
            RouteModifiers = new RouteModifiers(),
            LanguageCode = "",
            Units = Units.Unspecified,
            PolylineEncoding = PolylineEncoding.Unspecified,
            OptimizeWaypointOrder = false,
            RequestedReferenceRoutes =
            {
                ComputeRoutesRequest.Types.ReferenceRoute.Unspecified,
            },
            ExtraComputations =
            {
                ComputeRoutesRequest.Types.ExtraComputation.Unspecified,
            },
            RegionCode = "",
            TrafficModel = TrafficModel.Unspecified,
            ArrivalTime = new Timestamp(),
            TransitPreferences = new TransitPreferences(),
        };
        // Make the request
        ComputeRoutesResponse response = await routesClient.ComputeRoutesAsync(request);
    }
}
```

## Additional resources

### Java

- [Source Code](https://github.com/googleapis/google-cloud-java/tree/main/java-maps-routing)
- [GitHub Issue Tracker](https://github.com/googleapis/google-cloud-java/issues)
- [Stack Overflow](https://stackoverflow.com/questions/tagged/google-routes-api+java)

### Go

- [Source Code](https://github.com/googleapis/google-cloud-go/tree/main/maps)
- [Package Documentation](https://pkg.go.dev/cloud.google.com/go/maps/routing/apiv2)
- [GitHub Issue Tracker](https://github.com/googleapis/google-cloud-go/issues)
- [Stack Overflow](https://stackoverflow.com/questions/tagged/google-routes-api+go)

### Node.js

- [Source Code](https://github.com/googleapis/google-cloud-node/tree/main/packages/google-maps-routing)
- [GitHub Issue Tracker](https://github.com/googleapis/google-cloud-node/issues)
- [Stack Overflow](https://stackoverflow.com/questions/tagged/google-routes-api+node.js)

### Python

- [Source Code](https://github.com/googleapis/google-cloud-python/tree/main/packages/google-maps-routing)
- [GitHub Issue Tracker](https://github.com/googleapis/google-cloud-python/issues)
- [Stack Overflow](https://stackoverflow.com/questions/tagged/google-routes-api+python)

### .Net

- [Source Code](https://github.com/googleapis/google-cloud-dotnet/tree/main/apis/Google.Maps.Routing.V2)
- [GitHub Issue Tracker](https://github.com/googleapis/google-cloud-dotnet/issues)
- [Stack Overflow](https://stackoverflow.com/questions/tagged/google-routes-api+.net)