Valhalla

https://valhalla.github.io/valhalla
Admin
Valhalla is an open source routing engine and accompanying libraries for use with OpenStreetMap...
Tokens:86,601
Snippets:804
Trust Score:8.3
Update:4 months ago
Show doc for...
Tokens:
Raw
### Build and Install Valhalla on Linux

Source: https://valhalla.github.io/valhalla/building

Configure, build, and install Valhalla on a Linux system. This example sets the build type to Release and uses parallel jobs for compilation.

```bash
# will build to ./build
cmake -B build -DCMAKE_BUILD_TYPE=Release
make -C build -j$(nproc)
sudo make -C build install
```

--------------------------------

### Start Valhalla Service

Source: https://valhalla.github.io/valhalla/building

Starts the Valhalla service using a specified configuration file. This is the primary command to get Valhalla running.

```bash
valhalla_service valhalla.json 1
```

--------------------------------

### Build and Install Valhalla on macOS

Source: https://valhalla.github.io/valhalla/building

Configures the build using CMake, compiles the project with parallel jobs, and installs the built binaries. Assumes dependencies are already installed.

```bash
# will build to ./build
cmake -B build -DCMAKE_BUILD_TYPE=Release
make -C build -j$(sysctl -n hw.physicalcpu)
sudo make -C build install

```

--------------------------------

### Install Valhalla Node.js Bindings

Source: https://valhalla.github.io/valhalla/README_nodejs

Install the Valhalla Node.js bindings using npm. This is the first step before using the library.

```bash
npm install @valhallajs/valhallajs

```

--------------------------------

### Install protobufjs for Protocol Buffer Decoding

Source: https://valhalla.github.io/valhalla/README_nodejs

Install the protobufjs library using npm. This is required to decode Protocol Buffer responses from Valhalla.

```bash
npm install protobufjs

```

--------------------------------

### Editable Install for Developers

Source: https://valhalla.github.io/valhalla/README_python

Perform an editable installation for development, enabling incremental builds by specifying a build directory and release type. Optionally configure vcpkg for dependency management.

```bash
pip install -e . --no-build-isolation \
  -Cbuild-dir=build_python (or other build dir) \
  -Ccmake.build-type=Release \
  -Ccmake.define.VALHALLA_VERSION_MODIFIER="$(git rev-parse --short HEAD)"
  # optionally for vcpkg package management
  -Ccmake.define.CMAKE_TOOLCHAIN_FILE="$VCPKG_ROOT/scripts/buildsystems/vcpkg.cmake"
  -Ccmake.define.VCPKG_TARGET_TRIPLET=x64-windows
  -Ccmake.define.VCPKG_OVERLAY_PORTS=overlay-ports-vcpkg
```

--------------------------------

### Install Linux Dependencies

Source: https://valhalla.github.io/valhalla/building

Install necessary system dependencies for building Valhalla on Debian or Ubuntu systems using a provided script.

```bash
./scripts/install-linux-deps.sh
```

--------------------------------

### Install Valhalla Python Bindings

Source: https://valhalla.github.io/valhalla/README_python

Install the pyvalhalla package from source in the current Python environment.

```bash
git clone https://github.com/valhalla/valhalla
cd valhalla
pip install .
```

--------------------------------

### Install and Run cibuildwheel

Source: https://valhalla.github.io/valhalla/README_python

Install cibuildwheel and use it to print build identifiers or build wheels for specific platforms. For Windows, set the VCPKG_ARCH_ROOT environment variable.

```bash
python -m pip install cibuildwheel
cibuildwheel --print-build-Identifiers
cibuildwheel --only cp313-manylinux_x86_64

# for windows you'll have to set an env var to the vcpkg win root
VCPKG_ARCH_ROOT="build/vcpkg_installed/custom-x64-windows" cibuildwheel --only cp313-win_amd64
```

--------------------------------

### Install Windows Dependencies with vcpkg

Source: https://valhalla.github.io/valhalla/building

Installs Valhalla's dependencies on Windows using vcpkg. It checks out a specific commit of vcpkg, configures it to build only Release versions, and then installs the packages for the x64-windows triplet.

```bash
git -C C:\path\to\vcpkg checkout f330a32
# only build release versions for vcpkg packages
echo.set(VCPKG_BUILD_TYPE Release)>> path\to\vcpkg\triplets\x64-windows.cmake
cd C:\path\to\valhalla
C:\path\to\vcpkg.exe install --triplet x64-windows

```

--------------------------------

### Run Valhalla Python Wheel Build in Docker

Source: https://valhalla.github.io/valhalla/README_python

Start a Docker container from the manylinux image and execute the build script to create Valhalla Python wheels. This process includes building and installing libvalhalla.

```bash
cd valhalla
docker run -dt -v $PWD:/valhalla-py --name valhalla-py --workdir /valhalla-py ghcr.io/valhalla/manylinux:2_28_valhalla_python
docker exec -t valhalla-py /valhalla-py/src/bindings/python/scripts/build_manylinux.sh build_manylinux 3.13
```

--------------------------------

### Install Dependencies

Source: https://valhalla.github.io/valhalla/elevation

Installs the parallel and curl packages required for Valhalla's elevation service.

```bash
sudo apt-get install parallel
sudo apt-get install curl
```

--------------------------------

### Example Service API Request

Source: https://valhalla.github.io/valhalla/meili/service_api

Demonstrates how to make a POST request to the service API with URL parameters for search radius and mode.

```bash
curl -X POST "https://localhost:8002?search_radius=35&mode=auto"
```

--------------------------------

### Get Tile Index Example

Source: https://valhalla.github.io/valhalla/baldr

Demonstrates how to extract the tile index from a 64-bit GraphId using the provided Python function.

```python
>>> get_tile_index(73160266)
756425
>>> get_tile_index(142438865769)
37741
```

--------------------------------

### Install and Run Pre-commit Hooks

Source: https://valhalla.github.io/valhalla/contributing

Installs the pre-commit hook and runs it on all files to ensure code is formatted and linted according to project standards. This should be done before opening a Pull Request.

```bash
# installs the pre-commit hook
./scripts/format.sh
pre-commit run --all-files
```

--------------------------------

### Get Valhalla Configuration Help

Source: https://valhalla.github.io/valhalla/python/config

Returns a dictionary containing help information for Valhalla configuration keys. This can be useful for understanding available settings.

```python
get_help() -> Dict[str, Union[Dict[str, str], str]]
```

--------------------------------

### Start Elevation Service

Source: https://valhalla.github.io/valhalla/elevation

Starts the Valhalla elevation service using the generated configuration file and specifies the number of threads to use.

```bash
valhalla_service config.json 1
```

--------------------------------

### Example Usage: get_tile_index_from_latlon

Source: https://valhalla.github.io/valhalla/tiles

Shows how to use `get_tile_index_from_latlon` to find tile indices for specific geographic points at different hierarchy levels.

```python
>>> get_tile_index_from_latlon(0, 14.601879, 120.972545)
2415
>>> get_tile_index_from_latlon(1, 14.601879, 120.972545)
37740
>>> get_tile_index_from_latlon(2, 41.413203, -73.623787)
756425
```

--------------------------------

### Install macOS Dependencies with Homebrew

Source: https://valhalla.github.io/valhalla/building

Installs necessary build tools and libraries for Valhalla on macOS using Homebrew. Automake and czmq are specifically required for the prime_server component.

```bash
# install dependencies (automake & czmg are required by prime_server)
brew install automake cmake libtool protobuf protobuf-c libspatialite pkg-config sqlite3 jq curl wget czmq lz4 spatialite-tools unzip luajit boost
# following packages are needed for running Linux compatible scripts
brew install bash coreutils binutils

```

--------------------------------

### Basic Tile Request Example

Source: https://valhalla.github.io/valhalla/api/tile/api-reference

Demonstrates a basic request for tile data using the XYZ pattern with 'tile' object wrapping.

```json
{
  "tile": {
    "x": 13107,
    "y": 8200,
    "z": 15
  }
}
```

--------------------------------

### Expansion Service Request Example

Source: https://valhalla.github.io/valhalla/api/expansion/api-reference

Example request for the Expansion service to generate an isochrone, including specific expansion properties and skipping opposite edges.

```json
{
    "costing": "pedestrian",
    "action": "isochrone",
    "id": 1,
    "locations": [
        {
            "lon": 14.440689,
            "lat": 50.087052
        }
    ],
    "contours": [
        {
            "time": 1
        }
    ],
    "skip_opposites": true,
    "expansion_properties": [
        "duration",
        "edge_id",
        "pred_edge_id",
        "edge_status",
        "cost",
        "expansion_type"
    ]

}
```

--------------------------------

### Example Usage: tiles_for_bounding_box

Source: https://valhalla.github.io/valhalla/tiles

Illustrates the `tiles_for_bounding_box` function by finding all tiles that intersect the bounding box of NYC.

```python
>>> from pprint import pp
>>> # NYC bounding box
>>> bottom, left = (40.512764, -74.251961)
>>> top, right = (40.903125, -73.755405)
>>> x = tiles_for_bounding_box(left, bottom, right, top)
>>> pp(sorted(x))
[(0, 2906),
 (1, 46905),
 (1, 46906),
 (2, 752102),
 (2, 752103),
 (2, 752104),
 (2, 753542),
 (2, 753543),
 (2, 753544)]
```

--------------------------------

### Lane Configuration Example

Source: https://valhalla.github.io/valhalla/api/turn-by-turn/api-reference

Illustrates a lanes array with two lanes, showing 'directions', 'active', and 'valid' bitmask values for turn directions.

```json
"lanes": [
  {
    "directions": 8,   // bitmask for Left (8)
    "active": 8        // indicates this lane should be preferred for a left turn
  },
  {
    "directions": 10,  // bitmask for Left (8) + Straight (2)
    "valid": 8         // indicates this lane can be used for a left turn
  }
]

```

--------------------------------

### Lane Guidance Example

Source: https://valhalla.github.io/valhalla/api/turn-by-turn/api-reference

Demonstrates the structure for lane-level guidance within a maneuver, specifying possible turn directions for a lane. This enhances navigation accuracy.

```JSON
{
  "directions": 1
}
```

--------------------------------

### Clone Demos Repository and Open Routing Sample

Source: https://valhalla.github.io/valhalla/building

Clones the Valhalla demos repository and opens the point-and-click routing sample in Firefox. Ensure you set the environment to 'localhost' to connect to your own server.

```bash
git clone --depth=1 --recurse-submodules --single-branch --branch=gh-pages https://github.com/valhalla/demos.git
firefox demos/routing/index-internal.html &
```

--------------------------------

### Get Hierarchy Level Example

Source: https://valhalla.github.io/valhalla/baldr

Demonstrates how to extract the hierarchy level from a 64-bit GraphId using the provided Python function.

```python
>>> get_hierarchy_level(73160266)
2
>>> get_hierarchy_level(142438865769)
1
```

--------------------------------

### Example JSON structure for a narrative language file

Source: https://valhalla.github.io/valhalla/locales

This is an example of the JSON structure for a language file, showing keys, example phrases, and localized values. Do not translate JSON keys or phrase tags.

```json
{
  "example_phrases": {
    "turn_instruction": {
      "en-US": "Head {{direction}} on {{street}}.",
      "es-ES": "Diríjase {{direction}} por {{street}}."
    }
  },
  "posix_locale": "en_US.UTF-8",
  "aliases": [
    "en"
  ]
}
```

--------------------------------

### Example Service API Request Body

Source: https://valhalla.github.io/valhalla/meili/service_api

Provides an example of the GeoJSON feature with coordinates to be sent in the request body.

```json
{
  "coordinates": [
    [ 13.288925, 52.438512 ],
    [ 13.288938, 52.438938 ],
    [ 13.288904, 52.439169 ],
    [ 13.288821, 52.439398 ],
    [ 13.288824, 52.439491 ],
    [ 13.288824, 52.439563 ]
  ]
}
```

--------------------------------

### Bootstrap vcpkg Dependency Manager

Source: https://valhalla.github.io/valhalla/building

Initialize the vcpkg dependency manager. This command is platform-specific.

```bash
./vcpkg/bootstrap-vcpkg.sh
```

```bash
./vcpkg/bootstrap-vcpkg.sh
```

```cmd
cmd.exe /c .\vcpkg\bootstrap-vcpkg.bat
```

--------------------------------

### get_help

Source: https://valhalla.github.io/valhalla/python/config

Returns the help dictionary, which contains the same keys as the configuration JSON.

```APIDOC
## get_help

### Description
Returns the help dictionary with the same keys as the config JSON.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Returns
A dictionary containing help information, with keys matching the config JSON.
```

--------------------------------

### Create Valhalla Graph Tiles

Source: https://valhalla.github.io/valhalla/README_python

Download an OSM PBF file and use the Valhalla command-line tool to build routing tiles. Replace '<valhalla.json>' with your Valhalla configuration file path.

```bash
wget https://download.geofabrik.de/europe/andorra-latest.osm.pbf
python -m valhalla valhalla_build_tiles -c <valhalla.json> andorra-latest.osm.pbf
```

--------------------------------

### Maneuver Transit Info Example

Source: https://valhalla.github.io/valhalla/api/turn-by-turn/api-reference

Provides an example of transit information associated with a maneuver, including route details and operator information. Used for public transport legs.

```JSON
{
  "onestop_id": "r-sv-1234",
  "short_name": "N",
  "long_name": "Broadway Express",
  "headsign": "ASTORIA - DITMARS BLVD",
  "color": 16567306,
  "text_color": 0,
  "description": "Trains operate from Ditmars Boulevard, Queens, to Stillwell Avenue, Brooklyn, at all times.",
  "operator_onestop_id": "o-sv-mta",
  "operator_name": "MTA",
  "operator_url": "https://web.mta.info/",
  "transit_stops": [
    {
      "type": 1,
      "name": "14 St - Union Sq",
      "arrival_date_time": "2015-12-29T08:06",
      "departure_date_time": "2015-12-29T08:06",
      "is_parent_stop": false,
      "assumed_schedule": false,
      "lat": 40.7307,
      "lon": -73.9874
    }
  ]
}
```

--------------------------------

### Download and Prepare Routing Data

Source: https://valhalla.github.io/valhalla/building

Downloads sample OSM data for Switzerland and Liechtenstein, creates directories for Valhalla tiles, and generates configuration files for building routing data.

```bash
# download some data and make tiles out of it
# NOTE: you can feed multiple extracts into pbfgraphbuilder
wget https://download.geofabrik.de/europe/switzerland-latest.osm.pbf https://download.geofabrik.de/europe/liechtenstein-latest.osm.pbf
# get the config and setup
mkdir -p valhalla_tiles
valhalla_build_config --mjolnir-tile-dir ${PWD}/valhalla_tiles --mjolnir-tile-extract ${PWD}/valhalla_tiles.tar --mjolnir-timezone ${PWD}/valhalla_tiles/timezones.sqlite --mjolnir-admin ${PWD}/valhalla_tiles/admins.sqlite > valhalla.json

```

--------------------------------

### Initialize Valhalla Actor and Route

Source: https://valhalla.github.io/valhalla/README_python

Instantiate the Valhalla Actor with a configuration and perform a routing query. Ensure the graph tiles are correctly specified in the configuration.

```python
from valhalla import Actor, get_config, get_help

# generate configuration
config = get_config(tile_extract='./custom_files/valhalla_tiles.tar', verbose=True)

# print the help for specific config items (has the same structure as the output of get_config()
print(get_help()["service_limits"]["auto"]["max_distance"])

# instantiate Actor to load graph and call actions
actor = Actor(config)
route = actor.route({"locations": [...]})
```

--------------------------------

### Example GeoJSON Feature for Map Roulette

Source: https://valhalla.github.io/valhalla/mjolnir/geojson

This is an example of a single task's GeoJSON structure required by Map Roulette. It includes an instruction, properties with a unique key, and geometry defining the location.

```json
{
    "instruction": "This node is either unreachable or unleavable. Edit the surrounding roads so that the node can be accessed properly",
    "properties": {
        "key": 4770031602477192848,
        "type": "Node"
    },
    "type": "Feature",
    "geometry": {
        "type": "Point",
        "coordinates": [8.64613, 44.63913]
    }
}

```

--------------------------------

### Open Standalone HTML Documentation

Source: https://valhalla.github.io/valhalla/api/openapi

Opens the generated 'redoc-static.html' file in the default browser. Use 'xdg-open' on Linux or 'open' on macOS.

```bash
xdg-open redoc-static.html   # Linux
```

```bash
open redoc-static.html        # macOS
```

--------------------------------

### Unreachable Location Error Example

Source: https://valhalla.github.io/valhalla/api/optimized/api-reference

This example demonstrates the expected JSON input that would trigger an error response due to an unreachable location. The service will return a 400 status code and list the index of the unreachable location.

```json
{"locations":[{"lat":40.306600,"lon":-76.900022},{"lat":40.293246,"lon":-76.936230},{"lat":40.448678,"lon":-76.932885},{"lat":40.419753,"lon":-76.999632},{"lat":40.211050,"lon":-76.777071},{"lat":40.306600,"lon":-76.900022}],"costing":"auto"}
```

--------------------------------

### Serve OpenAPI Spec with Stoplight Elements

Source: https://valhalla.github.io/valhalla/api/openapi

Uses npx to run Stoplight Elements, serving the OpenAPI specification directly from a local file. This is a quick way to preview the spec interactively without Docker.

```bash
npx @stoplight/elements-dev-portal --spec docs/docs/api/openapi.yaml
```

--------------------------------

### Isochrone Service Request Example

Source: https://valhalla.github.io/valhalla/api/isochrone/api-reference

An example of an Isochrone API request to find reachable areas within a 15-minute walk from a given location. The request specifies the location, costing model, and desired time contour. The response is in GeoJSON format.

```APIDOC
## POST /isochrone

### Description
Computes areas reachable within specified time intervals from a location, returning them as polygons or lines.

### Method
POST

### Endpoint
`/isochrone`

### Parameters
#### Request Body
- **locations** (array) - Required - An array of at least one location, each with `lat` (float) and `lon` (float) properties.
- **costing** (string) - Required - The costing model to use (e.g., `pedestrian`, `bicycle`, `auto`).
- **contours** (array) - Required - An array of contour objects, each with a `time` (float) in minutes and an optional `color` (string).
- **id** (string) - Optional - An identifier for the request, returned with the response.

### Request Example
```json
{
  "locations": [
    {
      "lat": 40.744014,
      "lon": -73.990508
    }
  ],
  "costing": "pedestrian",
  "contours": [
    {
      "time": 15.0,
      "color": "ff0000"
    }
  ]
}
```

### Response
#### Success Response (200)
- The response is in GeoJSON format, representing the reachable regions.

#### Response Example
(GeoJSON FeatureCollection)
```

--------------------------------

### Isochrone Request Example

Source: https://valhalla.github.io/valhalla/api/isochrone/api-reference

This example demonstrates a basic Isochrone API request to find reachable areas within a 15-minute walk from a specified location. The response is GeoJSON, suitable for map visualization. An optional 'id' parameter can be appended to match requests with responses.

```json
{"locations":[{"lat":40.744014,"lon":-73.990508}],"costing":"pedestrian","contours":[{"time":15.0,"color":"ff0000"}]}&id=Walk_From_Office

```

--------------------------------

### Minimal Gurka Test Case

Source: https://valhalla.github.io/valhalla/test/gurka

A basic example demonstrating how to set up a test map using ASCII art, build tiles, execute a route request, and assert the results. This snippet requires the 'gurka.h' header.

```cpp
#include <gtest/gtest.h>
#include "gurka.h"

TEST(TestSuite, TestName) {

    const std::string &ascii_map = R"(
        A----B----C
    )";
    const gurka::ways ways = {{"ABC", {{"highway", "primary"}}}};

    auto map = gurka::buildtiles(ascii_map, 100, ways, {}, {}, "test/data/example");

    auto result = gurka::route(map, "A", "C", "auto");

    EXPECT_EQ(result.directions().routes_size(), 1);
    EXPECT_EQ(result.directions().routes(0).legs_size(), 1);

}

```

--------------------------------

### get_tile_id_from_lon_lat

Source: https://valhalla.github.io/valhalla/python/graph_utils

Get the tile at this hierarchy level and geographic coordinate.

```APIDOC
## get_tile_id_from_lon_lat

```python
get_tile_id_from_lon_lat(level: int, coord: tuple) -> GraphId
```

### Description
Get the tile at this hierarchy level and geographic coordinate.

### Parameters
#### Path Parameters
- **level** (int) - Required - The hierarchy level of the searched tiles.
- **coord** (tuple) - Required - The geographic coordinate to intersect with tiles.

### Returns
- **GraphId** - GraphId of found tile.

### Raises
- **ValueError** - When the level or coord are invalid.
```

--------------------------------

### Initialize GraphUtils

Source: https://valhalla.github.io/valhalla/python/graph_utils

Initialize GraphUtils with Valhalla configuration. Configuration can be provided as a Path to a JSON config file, a JSON string, or a Python dict. The dict input is serialized to JSON internally. Requires valid mjolnir.tile_extract or mjolnir.tile_dir settings in the configuration.

```python
GraphUtils(config: Union[Path, str, dict])
```

--------------------------------

### get_tile_base_lon_lat

Source: https://valhalla.github.io/valhalla/python/graph_utils

Get the geographic coordinate of the south-western corner of this graph_id's tile.

```APIDOC
## get_tile_base_lon_lat

```python
get_tile_base_lon_lat(graph_id: GraphId) -> tuple
```

### Description
Get the geographic coordinate of the south-western corner of this graph_id's tile.

### Parameters
#### Path Parameters
- **graph_id** (GraphId) - Required - The tile's or object's GraphId

### Returns
- **tuple** - The lon/lat coordinate of the SW corner of the tile
```

--------------------------------

### Build Standalone HTML Documentation with Redocly CLI

Source: https://valhalla.github.io/valhalla/api/openapi

Bundles the OpenAPI specification into a single, self-contained HTML file named 'redoc-static.html'. This is ideal for sharing or hosting without a server. Customizes the title and theme.

```bash
npx @redocly/cli build-docs docs/docs/api/openapi.yaml \
  -o redoc-static.html \
  --title "Valhalla API" \
  --theme.openapi.typography.fontWeightRegular=bold
```

--------------------------------

### get_edge_shape

Source: https://valhalla.github.io/valhalla/python/graph_utils

Get the shape (polyline) for an edge as a list of (lon, lat) tuples.

```APIDOC
## get_edge_shape

```python
get_edge_shape(edge_id: GraphId) -> list[tuple[float, float]]
```

### Description
Get the shape (polyline) for an edge as a list of (lon, lat) tuples.

### Parameters
#### Path Parameters
- **edge_id** (GraphId) - Required - GraphId of the edge

### Returns
- **list[tuple[float, float]]** - List of (lon, lat) tuples representing the edge geometry

### Raises
- **RuntimeError** - When the tile or edge is not found
```

--------------------------------

### Example Usage: get_latlon

Source: https://valhalla.github.io/valhalla/tiles

Demonstrates the usage of the `get_latlon` function with different Graph IDs to retrieve tile coordinates.

```python
>>> get_latlon(73160266)
(41.25, -73.75)
>>> get_latlon(142438865769)
(14.0, 121.0)
```

--------------------------------

### Example Service API Response

Source: https://valhalla.github.io/valhalla/meili/service_api

Illustrates the expected GeoJSON response format containing matched routes and coordinates.

```json
{
  "status": 200,
  "message": "OK",
  "data": {
    "type": "Feature",
    "geometry": {
      "type": "MultiLineString",
      "coordinates": [
        [
          [ 13.288884, 52.438507 ],
          [ 13.288852, 52.438835 ],
          [ 13.288844, 52.439090 ],
          [ 13.288825, 52.439136 ],
          [ 13.288805, 52.439159 ],
          [ 13.288601, 52.439365 ],
          [ 13.288538, 52.439384 ],
          [ 13.288719, 52.439636 ]
        ]
      ]
    },
    "properties": {
      "matched_coordinates": [
        [ 13.288884, 52.438507 ],
        [ 13.288848, 52.438934 ],
        [ 13.288805, 52.439159 ],
        [ 13.288601, 52.439365 ],
        [ 13.288685, 52.439590 ],
        [ 13.288719, 52.439640 ]
      ]
    }
  }
}
```

--------------------------------

### Tile Request with Included Attributes

Source: https://valhalla.github.io/valhalla/api/tile/api-reference

Example of using 'filters' to include specific edge attributes like 'speed' and 'length'.

```json
{
  "tile": {
    "x": 13107,
    "y": 8200,
    "z": 15
  },
  "filters": {
    "attributes": [
      "edge.speed",
      "edge.length"
    ],
    "action": "include"
  }
}
```

--------------------------------

### Run Redoc with Local OpenAPI File

Source: https://valhalla.github.io/valhalla/api/openapi

Launches Redoc in a Docker container, mounting a local OpenAPI file. This provides a clean, static documentation view. Access the documentation at http://localhost:8080.

```bash
docker run --rm -p 8080:80 \
  -v $(pwd)/docs/docs/api/openapi.yaml:/usr/share/nginx/html/openapi.yaml \
  -e SPEC_URL=openapi.yaml \
  redocly/redoc
```

--------------------------------

### Isochrone Action GeoJSON Response

Source: https://valhalla.github.io/valhalla/api/expansion/api-reference

Example GeoJSON response for an isochrone action, showing a FeatureCollection of LineString features with their properties.

```json
{
    "type": "FeatureCollection",
    "features": [
        {
            "type": "Feature",
            "geometry": {
                "type": "LineString",
                "coordinates": [
                    [
                        14.441804,
                        50.087371
                    ],
                    [
                        14.440275,
                        50.087137
                    ]
                ]
            },
            "properties": {
                "duration": 19,
                "cost": 19,
                "edge_status": "s",
                "edge_id": 4049718357265,
                "pred_edge_id": 70368744177663
            }
        },
        {
            "type": "Feature",
            "geometry": {
                "type": "LineString",
                "coordinates": [
                    [
                        14.440275,
                        50.087137
                    ],
                    [
                        14.439981,
                        50.087084
                    ]
                ]
            },
            "properties": {
                "duration": 34,
                "cost": 34,
                "edge_status": "s",
                "edge_id": 4049617693969,
                "pred_edge_id": 4049718357265
            }
        },
        {
            "type": "Feature",
            "geometry": {
                "type": "LineString",
                "coordinates": [
                    [
                        14.439981,
                        50.087084
                    ],
                    [
                        14.438998,
                        50.086788
                    ]
                ]
            },
            "properties": {
                "duration": 89,
                "cost": 89,
                "edge_status": "s",
                "edge_id": 4444184259857,
                "pred_edge_id": 4049617693969
            }
        }
    ],
    "properties": {
        "algorithm": "dijkstras"
    }
}
```
Tokens:
Raw