Standard Routing¶

import { RoutingApi, Configuration, RouteRequest, instanceOfRouteResponse, instanceOfOsrmRouteResponse } from '@stadiamaps/api';

// If you are writing for a backend application or can't use domain-based auth,
// then you'll need to add your API key like so:
// 
// const config = new Configuration({ apiKey: "YOUR-API-KEY" }); (1)
// You can also use our EU endpoint to keep traffic within the EU using the basePath option:
// const config = new Configuration({ basePath: "https://api-eu.stadiamaps.com" });
// const api = new RoutingApi(config);
const api = new RoutingApi();

const locationA = {
    "lon": -76.306572,
    "lat": 40.042072,
    "type": RoutingWaypointTypeEnum.Break
};
const locationB = {
    "lon": -76.781559,
    "lat": 39.992115,
    "type": RoutingWaypointTypeEnum.Break
};
const req: RouteRequest = {
    locations: [
        locationA,
        locationB
    ],
    costing: "auto",
    costingOptions: {
        auto: {
            useHighways: 0.3,  // Take the scenic route ;)
        }
    },
    units: DistanceUnit.Mi,
};
const res = await api.route({ routeRequest: req });

if (instanceOfRouteResponse(res)) {
  // TODO: Process the response (default format)
} else if (instanceOfOsrmRouteResponse(res)) {
  // TODO: Process the response (for navigation requests where your request options include format: "osrm"
}

import os
import stadiamaps
from stadiamaps.rest import ApiException

# You can also use our EU endpoint to keep traffic within the EU like so:
# configuration = stadiamaps.Configuration(host="https://api-eu.stadiamaps.com")
configuration = stadiamaps.Configuration()

# Configure API key authentication (ex: via environment variable). (1)
configuration.api_key['ApiKeyAuth'] = os.environ["API_KEY"]

with stadiamaps.ApiClient(configuration) as api_client:
    # Create an instance of the API class
    api_instance = stadiamaps.RoutingApi(api_client)

    try:
        location_a = {"lat": 40.042072, "lon": -76.306572}
        location_b = {"lat": 39.992115, "lon": -76.781559}
        req = stadiamaps.RouteRequest(
            id="route",
            locations=[
                stadiamaps.RoutingWaypoint.from_dict(location_a),
                stadiamaps.RoutingWaypoint.from_dict(location_b)
            ],
            costing=stadiamaps.CostingModel.AUTO,
            costing_options=stadiamaps.CostingOptions(auto=stadiamaps.AutoCostingOptions(use_highways=0.3)),  # Take the scenic route ;)
            units=stadiamaps.DistanceUnit.MI
        )

        # NOTE: Usable properties vary depending on the format parameter of the request!
        # The standard (compact) format includes an id, trip, and alternates.
        # The OSRM (navigation details in a single response) format uses the routes and waypoints parameters.
        res = api_instance.route(req).actual_instance
    except ApiException as e:
        # Add your error handling here
        print("Exception when calling the Stadia Maps API: %s\n" % e)

// Imports (at the top of your source file; we've used some wildcard imports for simplicity)
import com.stadiamaps.api.apis.*
import com.stadiamaps.api.auth.ApiKeyAuth
import com.stadiamaps.api.infrastructure.*
import com.stadiamaps.api.models.*

// Set your API key (from an environment variable in this case) (1)
val apiKey = System.getenv("STADIA_API_KEY") ?: throw RuntimeException("API Key not set")

// Defining the host is optional and defaults to https://api.stadiamaps.com
// You can also use our EU endpoint to keep traffic within the EU like so:
// val client = ApiClient(baseUrl = "https://api-eu.stadiamaps.com")
val client = ApiClient()
client.addAuthorization("ApiKeyAuth", ApiKeyAuth("query", "api_key", apiKey))

// Configure a service for the group of APIs we want to talk to
val service = client.createService(RoutingApi::class.java)

// Set up the request.
// Note: this code is blocking for demonstration purposes.
// If you're using Kotlin with coroutines,
// you can also use these asynchronously within suspend functions.
// Synchronous code can enqueue a callback to avoid blocking
// (you'll definitely want to do one of these instead when on the main thread of an app).
// See the docs for details: https://square.github.io/retrofit/2.x/retrofit/retrofit2/Call.html
val locations = listOf(
    RoutingWaypoint(40.042072, -76.306572), RoutingWaypoint(39.992115, -76.781559)
)
val costingOptions = CostingOptions(auto = AutoCostingOptions(useHighways = 0.3))  // Take the scenic route ;)
val req = RouteRequest(
    id = "route",
    locations = locations,
    costing = CostingModel.auto,
    costingOptions = costingOptions,
    units = DistanceUnit.mi,
    language = ValhallaLanguages.enMinusGB
)
val res = service.route(req).execute()

if (res.isSuccessful) {
    println("Found result: ${res.body()}")
} else {
    println("Request failed with error code ${res.code()}")
}

import StadiaMaps

// This setup code can go anywhere before you actually make an API call (typically in your app init)
func setupStadiaMapsAPI() {
    // Set your API key (1)
    StadiaMapsAPI.customHeaders = ["Authorization": "Stadia-Auth YOUR-API-KEY"]
    // Optionally use our EU endpoint to keep traffic within the EU
    // StadiaMapsAPI.basePath = "https://api-eu.stadiamaps.com"
}

// This function demonstrates how to call the Stadia Maps API.
// If you have not yet adopted async/await in your Swift codebase, you can use the Task API
// to call async functions in a non-async context: https://developer.apple.com/documentation/swift/task.
func myFunction() async throws {
    let req = RouteRequest(units: .mi,
                           id: "route",
                           locations: [
                               RoutingWaypoint(lat: 40.042072, lon: -76.306572),
                               RoutingWaypoint(lat: 39.992115, lon: -76.781559),
                           ],
                           costing: .auto,
                           costingOptions: CostingOptions(auto: AutoCostingOptions(useTolls: 0.3)))  // Take the scenic route :)
    let res = try await RoutingAPI.route(routeRequest: req)

    // Do something with the response...
    print(res)
}

<?php
// use or require, depending on your installation method.

// Configure API key authorization (replace with your Stadia Maps API key) (1)
$config = OpenAPI\Client\Configuration::getDefaultConfiguration()->setApiKey('api_key', 'YOUR-API-KEY');
// You can also use our EU endpoint to keep traffic within the EU using setHost:
// $config = Configuration::getDefaultConfiguration()->setApiKey('api_key', 'YOUR-API-KEY')->setHost('https://api-eu.stadiamaps.com');

$apiInstance = new OpenAPI\Client\Api\RoutingApi(
    new GuzzleHttp\Client(),
    $config
);

try {
    $locationA = (new RoutingWaypoint())
        ->setLat(40.042072)
        ->setLon(-76.306572)
        ->setType(RoutingWaypoint::TYPE__BREAK);
    $locationB = (new RoutingWaypoint())
        ->setLat(39.992115)
        ->setLon(-76.781559)
        ->setType(RoutingWaypoint::TYPE__BREAK);
    $req = (new RouteRequest())
        ->setId('route')
        ->setLocations([$locationA, $locationB])
        ->setCosting(CostingModel::AUTO)
        ->setUnits(DistanceUnit::MI)
        ->setCostingOptions((new CostingOptions())
            ->setAuto((new AutoCostingOptions())
                ->setUseHighways(0.3)));
    $result = $apiInstance->route($req);
} catch (Exception $e) {
    // Add your error handling here
    echo 'Exception when calling the Stadia Maps API: ', $e->getMessage(), PHP_EOL;
}

curl -X POST -H "Content-Type: application/json" -d '{
    "locations": [
        {
            "lon": -76.306572,
            "lat": 40.042072,
            "type": "break"
        },
        {
            "lon": -76.781559,
            "lat": 39.992115,
            "type": "break"
        }
    ],
    "costing": "auto",
    "costing_options": {
        "auto": {
            "use_highways": 0.3
        }
    },
    "units": "miles"
}' "https://api.stadiamaps.com/route/v1?api_key=YOUR-API-KEY"