mapboxapi

https://walker-data.com/mapboxapi/
Admin
mapboxapi is an R package that interfaces with Mapbox web services APIs to help users incorporate...
Tokens:39,245
Snippets:291
Trust Score:9.3
Update:5 months ago
Show doc for...
Tokens:
Raw
### Example: Get Static Tiles and Use with tmap

Source: https://walker-data.com/mapboxapi/reference/get_static_tiles.html

Demonstrates how to fetch static tiles for a given location and use them as a basemap within a tmap visualization. Requires the mapboxapi, tigris, and tmap packages.

```R
library(mapboxapi)
library(tigris)
library(tmap)
library(ggspatial)
library(ggplot2)

ny_tracts <- tracts("NY", "New York", cb = TRUE)

ny_tiles <- get_static_tiles(
  location = ny_tracts,
  zoom = 10,
  style_id = "light-v9",
  username = "mapbox"
)

# tmap usage:
tm_shape(ny_tiles) +
  tm_rgb() +
  tm_shape(ny_tracts) +
  tm_polygons(alpha = 0.5, col = "navy") +
  tm_credits("Basemap (c) Mapbox, (c) OpenStreetMap",
    position = c("RIGHT", "BOTTOM")
  )
```

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

### Install Mapbox Access Token

Source: https://walker-data.com/mapboxapi/reference/mb_access_token.html

Installs a Mapbox access token into your `.Renviron` file for future use. Ensure you replace '...' with your actual token.

```r
if (FALSE) { # \dontrun{
my_token <- "..." # The token generated from your Mapbox account
mb_access_token(my_token, install = TRUE)
Sys.getenv("MAPBOX_PUBLIC_TOKEN")
}

```

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

### Example: Get Static Tiles and Use with ggplot2

Source: https://walker-data.com/mapboxapi/reference/get_static_tiles.html

Illustrates fetching static tiles and integrating them into a ggplot2 plot using ggspatial's layer_spatial. Requires mapboxapi, tigris, and ggplot2 packages.

```R
library(mapboxapi)
library(tigris)
library(tmap)
library(ggspatial)
library(ggplot2)

ny_tracts <- tracts("NY", "New York", cb = TRUE)

ny_tiles <- get_static_tiles(
  location = ny_tracts,
  zoom = 10,
  style_id = "light-v9",
  username = "mapbox"
)

# ggplot2 usage:
ggplot() +
  layer_spatial(ny_tiles) +
  geom_sf(data = ny_tracts, fill = "navy", alpha = 0.5) +
  theme_void() +
  labs(caption = "Basemap (c) Mapbox, (c) OpenStreetMap")
```

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

### R Example: List Tileset Sources

Source: https://walker-data.com/mapboxapi/reference/mts_list_sources.html

Demonstrates how to call the `mts_list_sources` function to retrieve a list of tileset sources for a given Mapbox username. This example is non-executable and requires a valid username.

```R
source_list <- mts_list_sources(username = "your_mapbox_username")
```

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

### Example Usage of mts_list_tilesets

Source: https://walker-data.com/mapboxapi/reference/mts_list_tilesets.html

Demonstrates how to call the mts_list_tilesets function with a username to retrieve a list of tilesets. This example is conditional and will not run by default.

```R
if (FALSE) { # \dontrun{

tileset_list <- mts_list_tilesets(username = "your_mapbox_username")

} # }
```

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

### Install mapboxapi Package

Source: https://walker-data.com/mapboxapi/index.html

Install the mapboxapi package from CRAN.

```r
install.packages("mapboxapi")
```

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

### R Example: Full MTS Tileset Workflow

Source: https://walker-data.com/mapboxapi/reference/mts_get_recipe.html

This example demonstrates a complete workflow for creating and managing Mapbox Tiling Service (MTS) tilesets using the `mapboxapi` R package. It covers data preparation, source creation, recipe building, validation, tileset creation, and publishing. Ensure you replace placeholder values like 'your_mapbox_username' with your actual Mapbox credentials.

```R
if (FALSE) { # \dontrun{
library(tidycensus)
library(mapboxapi)
options(tigris_use_cache = TRUE)

# Get the national data on median age
us_median_age_tract <- get_acs(
  geography = "tract",
  variables = "B01002_001",
  state = c(state.abb, "DC"),
  year = 2020,
  geometry = TRUE
)

# Get it for counties as well
us_median_age_county <- get_acs(
  geography = "county",
  variables = "B01002_001",
  year = 2020,
  geometry = TRUE
)

# Create a source from the datasets
mts_create_source(data = us_median_age_tract,
                  tileset_id = "us_median_age_tract",
                  username = "your_mapbox_username")

mts_create_source(data = us_median_age_county,
                  tileset_id = "us_median_age_county",
                  username = "your_mapbox_username")

# Build out the recipe.  First, create a recipe layer with
# appropriate options.  We'll want a larger tile size and to restrict the minzoom
# to 4; a maxzoom of 12 will be fine as we can overzoom beyond that
#
# Your source ID will be returned by `mts_create_source()`, so use that value
tract_layer <- recipe_layer(
  source = "mapbox://tileset-source/your_mapbox_username/us_median_age_tract",
  minzoom = 4,
  maxzoom = 12,
  tiles = tile_options(layer_size = 2500)
)

county_layer <- recipe_layer(
  source = "mapbox://tileset-source/your_mapbox_username/us_median_age_county",
  minzoom = 2,
  maxzoom = 5
)

recipe <- mts_make_recipe(tracts = tract_layer, counties = county_layer)

# Validate the recipe
mts_validate_recipe(recipe)

# Create a tileset from the recipe
mts_create_tileset(tileset_name = "median_age_acs",
                   username = "your_mapbox_username",
                   recipe = recipe)

# Publish the tileset
mts_publish_tileset(tileset_name = "median_age_acs",
                    username = "your_mapbox_username")

# If necessary, update the recipe
mts_update_recipe(tileset_name = "median_age_acs",
                  username = "your_mapbox_username",
                  recipe = new_recipe)

# Publish the tileset again after you've updated the recipe
mts_publish_tileset(tileset_name = "median_age_acs",
                    username = "your_mapbox_username")
} # } 

```

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

### mb_access_token

Source: https://walker-data.com/mapboxapi/reference/mb_access_token.html

Installs or retrieves a Mapbox access token, with options to overwrite existing tokens and install for future use in .Renviron.

```APIDOC
## mb_access_token

### Description
Installs or retrieves a Mapbox access token. Allows for overwriting existing tokens and installing the token in the `.Renviron` file for persistent use across sessions.

### Arguments
- **token** (string) - A Mapbox access token (public 'pk' or secret 'sk').
- **overwrite** (boolean) - Whether to overwrite an existing Mapbox access token. Defaults to `FALSE`.
- **install** (boolean) - If `TRUE`, installs the key in your `.Renviron` file for use in future sessions. Defaults to `FALSE`.

### Examples
```R
# Install a token and set it for future use
my_token <- "..." # Replace with your actual token
mb_access_token(my_token, install = TRUE)

# Verify the token is set
Sys.getenv("MAPBOX_PUBLIC_TOKEN")
```
```

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

### Add Mapbox Tiles to Leaflet Map Example

Source: https://walker-data.com/mapboxapi/reference/addMapboxTiles.html

An example demonstrating how to initialize a Leaflet map and add Mapbox tiles using a specified style and username. This snippet requires the 'leaflet' and 'mapboxapi' R packages.

```R
library(leaflet)
library(mapboxapi)

leaflet() %>%
  addMapboxTiles(
    style_id = "light-v9",
    username = "mapbox"
  ) %>%
  setView(
    lng = -74.0051,
    lat = 40.7251,
    zoom = 13
  )
```

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

### Example: Extracting and Visualizing Vector Tiles

Source: https://walker-data.com/mapboxapi/reference/get_vector_tiles.html

This example demonstrates how to retrieve vector tiles for a specific location and zoom level, then visualize the building layer using ggplot2. Ensure Mapbox access token is set.

```r
if (FALSE) { # \dontrun{

library(mapboxapi)
library(ggplot2)

vector_extract <- get_vector_tiles(
  tileset_id = "mapbox.mapbox-streets-v8",
  location = c(-73.99405, 40.72033),
  zoom = 15
)

ggplot(vector_extract$building$polygons) +
  geom_sf() +
  theme_void()
} # }
```

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

### Generate .mbtiles for Dot-Density Mapping

Source: https://walker-data.com/mapboxapi/reference/tippecanoe.html

This example demonstrates a full workflow: fetching population data, converting it to representative dots, generating an .mbtiles file using tippecanoe, and uploading the tileset to Mapbox. Ensure your Mapbox secret access token is set.

```R
if (FALSE) { # \dontrun{ 

# Workflow: create a dynamic tileset for dot-density mapping
library(tidycensus)
library(sf)
library(mapboxapi)

# Get population data for Census tracts in Vermont
vt_population <- get_decennial(
  geography = "tract",
  variables = "P001001",
  state = "Vermont",
  year = 2010,
  geometry = TRUE
)

# Convert to representative dots - 1 per person
vt_dots <- st_sample(
  vt_population,
  size = vt_population$value
)

# Use tippecanoe to create dynamic tiles
tippecanoe(
  input = vt_dots,
  output = "vt_population.mbtiles",
  layer_name = "vermont_population",
  max_zoom = 18,
  drop_rate = 1.5
)

# Upload to your Mapbox account for visualization
# A Mapbox secret access token must be set with mb_access_token() 
# to upload data to your account
upload_tiles(
  input = "vt_population.mbtiles",
  username = "kwalkertcu",
  tileset_id = "vt_population_dots",
  multipart = TRUE
)
} # } 

```

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

### MTS Tileset Creation and Management Example

Source: https://walker-data.com/mapboxapi/reference/feature_options.html

Demonstrates a complete workflow for creating, validating, updating, and publishing Mapbox Tiling Service (MTS) tilesets using R, including data retrieval, source creation, recipe layer configuration, and tileset management.

```R
if (FALSE) { # \dontrun{
library(tidycensus)
library(mapboxapi)
options(tigris_use_cache = TRUE)

# Get the national data on median age
us_median_age_tract <- get_acs(
  geography = "tract",
  variables = "B01002_001",
  state = c(state.abb, "DC"),
  year = 2020,
  geometry = TRUE
)

# Get it for counties as well
us_median_age_county <- get_acs(
  geography = "county",
  variables = "B01002_001",
  year = 2020,
  geometry = TRUE
)

# Create a source from the datasets
mts_create_source(data = us_median_age_tract,
                  tileset_id = "us_median_age_tract",
                  username = "your_mapbox_username")

mts_create_source(data = us_median_age_county,
                  tileset_id = "us_median_age_county",
                  username = "your_mapbox_username")

# Build out the recipe.  First, create a recipe layer with
# appropriate options.  We'll want a larger tile size and to restrict the minzoom
# to 4; a maxzoom of 12 will be fine as we can overzoom beyond that
#
# Your source ID will be returned by `mts_create_source()`, so use that value
tract_layer <- recipe_layer(
  source = "mapbox://tileset-source/your_mapbox_username/us_median_age_tract",
  minzoom = 4,
  maxzoom = 12,
  tiles = tile_options(layer_size = 2500)
)

county_layer <- recipe_layer(
  source = "mapbox://tileset-source/your_mapbox_username/us_median_age_county",
  minzoom = 2,
  maxzoom = 5
)

recipe <- mts_make_recipe(tracts = tract_layer, counties = county_layer)

# Validate the recipe
mts_validate_recipe(recipe)

# Create a tileset from the recipe
mts_create_tileset(tileset_name = "median_age_acs",
                   username = "your_mapbox_username",
                   recipe = recipe)

# Publish the tileset
mts_publish_tileset(tileset_name = "median_age_acs",
                    username = "your_mapbox_username")

# If necessary, update the recipe
mts_update_recipe(tileset_name = "median_age_acs",
                  username = "your_mapbox_username",
                  recipe = new_recipe)

# Publish the tileset again after you've updated the recipe
mts_publish_tileset(tileset_name = "median_age_acs",
                    username = "your_mapbox_username")
} # } 
```

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

### Example Usage of query_tiles

Source: https://walker-data.com/mapboxapi/reference/query_tiles.html

Demonstrates how to use the query_tiles function to find elevation data for a specific location and tileset. Ensure you have a Mapbox access token configured.

```r
library(mapboxapi)

elevation <- query_tiles(
  location = "Breckenridge, Colorado",
  tileset_id = "mapbox.mapbox-terrain-v2",
  layer = "contour",
  limit = 50
)

max(elevation$features$properties$ele)
```

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

### Example: Uploading Median Age Data to Mapbox

Source: https://walker-data.com/mapboxapi/reference/upload_tiles.html

This example demonstrates how to upload median age data for US Census tracts to Mapbox as a tileset. It requires the mapboxapi and tidycensus packages and setting a Mapbox secret access token as an environment variable.

```R
if (FALSE) { # \dontrun{

# Example: create a tileset of median age for all United States Census tracts
# Requires setting a Mapbox secret access token as an environment variable

library(mapboxapi)
library(tidycensus)
options(tigris_use_cache = TRUE)

median_age <- get_acs(
  geography = "tract",
  variables = "B01002_001",
  state = c(state.abb, "DC"),
  geometry = TRUE
)

upload_tiles(
  input = median_age,
  username = "kwalkertcu", # Your username goes here
  tileset_id = "median_age",
  tileset_name = "us_median_age_2014_to_2018"
)
} # } 

```

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

### Set Mapbox Access Token

Source: https://walker-data.com/mapboxapi/index.html

Load the mapboxapi library and set your Mapbox access token for package use. Set install = TRUE to store the token for future sessions.

```r
library(mapboxapi)
mb_access_token("pk.eyas...", install = TRUE)
```

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

### API Token Management

Source: https://walker-data.com/mapboxapi/reference/index.html

Functions for installing, retrieving, and listing Mapbox access tokens.

```APIDOC
## API Token Management

### Description
Functions for installing, retrieving, and listing Mapbox access tokens.

### Functions
- `mb_access_token()`: Install or retrieve a Mapbox access token.
- `get_mb_access_token()`: Retrieve a Mapbox access token.
- `list_tokens()`: List available Mapbox access tokens.
```

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

### Load mapboxapi Package

Source: https://walker-data.com/mapboxapi/articles/geocoding.html

Load the mapboxapi package to access its geocoding functionalities. Ensure the package is installed before loading.

```r
library(mapboxapi)
```

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

### Generate and Upload Mapbox Tileset

Source: https://walker-data.com/mapboxapi/articles/creating-tiles.html

This snippet demonstrates downloading building data, using tippecanoe to generate an .mbtiles file, and then uploading this tileset to a Mapbox account. It requires tippecanoe to be installed separately and a Mapbox secret access token to be set as an environment variable.

```R
library(mapboxapi)
library(mapdeck)
library(httr)

# Get the Microsoft buildings data for Texas and unzip
GET("https://usbuildingdata.blob.core.windows.net/usbuildings-v1-1/Texas.zip",
    write_disk("Texas.zip", overwrite = TRUE), progress())

unzip("Texas.zip")

# Use tippecanoe to make a dynamic .mbtiles file that visualizes large data appropriately
# at any zoom level.  sf objects can also be used as input!
# (requires installing tippecanoe on your machine separately first)
tippecanoe(input = "Texas.geojson",
           output = "Texas.mbtiles",
           layer_name = "texas_buildings")

# Upload the generated tileset to your Mapbox account (requires a Mapbox secret access token
# to be set as an environment variable)
upload_tiles(input = "Texas.mbtiles", username = "kwalkertcu",
             tileset_id = "TX_buildings",
             multipart = TRUE)


# Head over to Mapbox Studio when the upload is done (check the status with
# `check_upload_status()`) and add it to a style.  When you've styled it, bring it back
# into R with mapdeck by referencing the style ID:
mapdeck(token = Sys.getenv("MAPBOX_PUBLIC_TOKEN"),
        style = "mapbox://styles/kwalkertcu/ckaf9qxim1pyk1io7r2e8exj2/draft",
        zoom = 6,
        location = c(-98.7382803, 31.7678448))
```

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

### Get Static Tiles Function Signature

Source: https://walker-data.com/mapboxapi/reference/get_static_tiles.html

This is the function signature for get_static_tiles, outlining its arguments and their default values.

```R
get_static_tiles(
  location,
  zoom,
  style_id,
  username,
  style_url = NULL,
  scaling_factor = c("1x", "2x"),
  buffer_dist = 5000,
  units = "m",
  crop = TRUE,
  access_token = NULL
)
```

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

### Calculate and visualize travel times to downtown Philadelphia

Source: https://walker-data.com/mapboxapi/reference/mb_matrix.html

This example demonstrates how to use `mb_matrix` to calculate travel times from census tracts to a specific destination. The results are then used to color-code polygons on a map.

```R
if (FALSE) { # \dontrun{ 

library(mapboxapi)
library(tigris)
library(mapdeck)

philly_tracts <- tracts("PA", "Philadelphia", cb = TRUE, class = "sf")
downtown_philly <- mb_geocode("Philadelphia City Hall, Philadelphia PA")

time_to_downtown <- mb_matrix(philly_tracts, downtown_philly)

philly_tracts$time <- time_to_downtown

mapdeck(style = mapdeck_style("light")) %>%
  add_polygon(
    data = philly_tracts,
    fill_colour = "time",
    fill_opacity = 0.6,
    legend = TRUE
  )
} # } 

```

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

### mts_list_sources

Source: https://walker-data.com/mapboxapi/reference/mts_list_sources.html

Lists tileset sources in your Mapbox account. You can specify the username, sorting preference, limit of results, and a starting point for the list. An access token is required for authentication.

```APIDOC
## Function: mts_list_sources

### Description
Lists tileset sources in your Mapbox account. Allows for sorting, limiting results, and specifying a starting point. Requires a Mapbox username and optionally an access token.

### Arguments

* **username** (string) - Required - Your Mapbox username.
* **sortby** (string) - Optional - One of "created" or "modified"; the returned data frame will be sorted by one of these two options. Defaults to "created".
* **limit** (integer) - Optional - The number of tileset sources to return. Defaults to 100. The maximum number of tileset sources returned by this endpoint is 2000.
* **start** (string) - Optional - The source ID at which to start the list of sources. Defaults to NULL.
* **access_token** (string) - Optional - Your Mapbox access token with secret scope.

### Value
A data frame containing information on your tileset sources.

### Examples

```R
# Example of listing tileset sources
if (FALSE) { # \dontrun{
source_list <- mts_list_sources(username = "your_mapbox_username")
}
```
```

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

### Make a Mapbox Tileset Recipe

Source: https://walker-data.com/mapboxapi/articles/dynamic-maps.html

Construct a tileset recipe using `mts_make_recipe()` by defining recipe layers with source IDs, minimum, and maximum zoom levels. Options for feature and tile configurations can be specified using `recipe_layer()`, `feature_options()`, and `tile_options()`.

```r
broadband_recipe <- mts_make_recipe(
  counties = recipe_layer(
    source = county_source$id,
    minzoom = 2,
    maxzoom = 7
  ),
  tracts = recipe_layer(
    source = tract_source$id,
    minzoom = 7,
    maxzoom = 12,
    tiles = tile_options(
      layer_size = 2500
    )
  )
)
```

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

### Get Vector Tiles Function Signature

Source: https://walker-data.com/mapboxapi/reference/get_vector_tiles.html

This is the function signature for retrieving vector tiles. It requires a tileset ID, location, and zoom level, with an optional access token.

```r
get_vector_tiles(tileset_id, location, zoom, access_token = NULL)
```

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

### Generate Static Map with Overlay Markers

Source: https://walker-data.com/mapboxapi/articles/mapping.html

Create a static map using a custom Mapbox style and overlay markers. The output is a magick object for further customization.

```r
points_of_interest <- tibble::tibble(
  longitude = c(-73.99405, -74.00616, -73.99577, -74.00761),
  latitude = c(40.72033, 40.72182, 40.71590, 40.71428)
  )

prepped_pois <- prep_overlay_markers(
  data = points_of_interest,
  marker_type = "pin-l",
  label = 1:4,
  color = "#fff"
)

map <- static_mapbox(
  style_id = "ckb83x2ur02oa1hpiq9zdt1i2",
  username = "kwalkertcu",
  overlay_markers = prepped_pois, 
  width = 1200,
  height = 800
)

map
```

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

### Create an Empty Mapbox Tileset

Source: https://walker-data.com/mapboxapi/articles/dynamic-maps.html

Initialize an empty tileset in your Mapbox account using `mts_create_tileset()`. This function requires the desired tileset name, your username, and the validated recipe.

```r
mts_create_tileset(
  tileset_name = "us_broadband",
  username = "kwalkertcu",
  recipe = broadband_recipe
)
```

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

### prep_overlay_markers Function Signature

Source: https://walker-data.com/mapboxapi/reference/prep_overlay_markers.html

This is the function signature for `prep_overlay_markers`. It outlines the available arguments and their default values.

```R
prep_overlay_markers(
  data = NULL,
  marker_type = c("pin-s", "pin-l", "url"),
  label = NA,
  color = NA,
  longitude = NULL,
  latitude = NULL,
  url = NA
)
```

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

### Calculate and Visualize a Cycling Route

Source: https://walker-data.com/mapboxapi/reference/mb_directions.html

This snippet shows how to calculate a cycling route between two points in Paris and display it on a Leaflet map. Ensure you have the mapboxapi and leaflet libraries installed and loaded.

```r
if (FALSE) { # \dontrun{
library(mapboxapi)
library(leaflet)

my_route <- mb_directions(
  origin = "10 Avenue de Wagram, 75008 Paris France",
  destination = "59 Rue de Tocqueville, 75017 Paris France",
  profile = "cycling",
  steps = TRUE,
  language = "fr"
)

leaflet(my_route) %>%
  addMapboxTiles(
    style_id = "light-v9",
    username = "mapbox"
  ) %>%
  addPolylines()
} # }
```

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

### Generate Walking Isochrones and Visualize

Source: https://walker-data.com/mapboxapi/reference/mb_isochrone.html

Generates walking isochrones for a specified location and visualizes them on a mapdeck map. Ensure the mapboxapi and mapdeck libraries are loaded.

```R
if (FALSE) { # \dontrun{

library(mapboxapi)
library(mapdeck)
isochrones <- mb_isochrone("The Kremlin, Moscow Russia",
  time = c(4, 8, 12),
  profile = "walking"
)

mapdeck(style = mapdeck_style("light")) %>%
  add_polygon(
    data = isochrones,
    fill_colour = "time",
    fill_opacity = 0.5,
    legend = TRUE
  )
} # } 

```

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

### R Function Signatures for Styles API

Source: https://walker-data.com/mapboxapi/reference/get_style.html

These are the R function signatures for retrieving a specific style by its ID and for listing all styles within a Mapbox account. Ensure you have the 'mapboxapi' package installed and configured with your access token.

```r
get_style(style_id, username, style_url = NULL, access_token = NULL)

list_styles(username, access_token = NULL)
```

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

### Publish a Mapbox Tileset

Source: https://walker-data.com/mapboxapi/articles/dynamic-maps.html

Populate the created empty tileset with data by publishing it using `mts_publish_tileset()`. This function requires the tileset name and your Mapbox username.

```r
mts_publish_tileset(
  tileset_name = "us_broadband",
  username = "kwalkertcu"
)
```

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

### Extract Navigation Instructions

Source: https://walker-data.com/mapboxapi/articles/navigation.html

Extracts and displays the navigation instructions from a previously computed route object.

```r
my_route$instruction
```

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

### prep_overlay_markers

Source: https://walker-data.com/mapboxapi/reference/prep_overlay_markers.html

Prepares overlay markers for use in a Mapbox static map. This function is designed to create a list of marker specifications that can be directly passed to the static_mapbox function.

```APIDOC
## Function: prep_overlay_markers

### Description
Prepares overlay markers for use in a Mapbox static map, matching the GeoJSON marker-spec.

### Arguments

* **data** (data frame or sf object) - An input data frame with longitude and latitude columns (X and Y or lon and lat as names are also acceptable) or an `sf` object with geometry type POINT.
* **marker_type** (character vector) - The marker type; one of `"pin-s"`, `"pin-l"`, and `"url"`. If marker_type is the same length as the rows in data, a mix of different marker types are allowed.
* **label** (character or NA) - The marker label (optional). Can be a letter, number (0 through 99), or a valid Maki icon.
* **color** (character or NA) - The marker color (optional). Can be specified as a color name or as a three or six-digit hexadecimal code.
* **longitude** (numeric vector) - A vector of longitudes; inferred from the input dataset if `data` is provided.
* **latitude** (numeric vector) - A vector of latitudes; inferred from the input dataset if `data` is provided.
* **url** (character vector) - The URL of the image to be used for the icon if `marker_type = "url"`.

### Value
A formatted list of marker specifications that can be passed to the static_mapbox function.
```

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

### Define a recipe layer for Mapbox Tiling Service

Source: https://walker-data.com/mapboxapi/reference/recipe_layer.html

Use `recipe_layer` to configure a data source for a Mapbox Tiling Service recipe. Specify zoom levels and tile options for custom data preparation.

```R
tract_layer <- recipe_layer(
  source = "mapbox://tileset-source/your_mapbox_username/us_median_age_tract",
  minzoom = 4,
  maxzoom = 12,
  tiles = tile_options(layer_size = 2500)
)

county_layer <- recipe_layer(
  source = "mapbox://tileset-source/your_mapbox_username/us_median_age_county",
  minzoom = 2,
  maxzoom = 5
)
```

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

### List Mapbox Account Tokens

Source: https://walker-data.com/mapboxapi/reference/mb_access_token.html

Lists Mapbox access tokens for a given username, with options to limit the number of results and sort them by creation or modification date. Replace 'kwalkertcu' with your Mapbox username.

```r
token_list <- list_tokens(
  username = "kwalkertcu", # You would use your own username here
  limit = 10,
  sortby = "modified" #' 
)

```

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

### recipe_layer

Source: https://walker-data.com/mapboxapi/reference/recipe_layer.html

Prepares a formatted recipe layer for use in a Mapbox Tiling Service recipe. This function defines the configuration for a single layer within a larger recipe, including its data source, zoom level constraints, and specific tiling options.

```APIDOC
## Function: recipe_layer

### Description
Prepares a formatted recipe layer for use in a Mapbox Tiling Service recipe. This function defines the configuration for a single layer within a larger recipe, including its data source, zoom level constraints, and specific tiling options.

### Usage
```R
recipe_layer(
  source,
  minzoom,
  maxzoom,
  features = feature_options(),
  tiles = tile_options()
)
```

### Arguments

*   **source** (string) - Required - The tileset source ID. This is returned by `mts_create_source()` or can be retrieved from your Mapbox account with `mts_list_sources()`.
*   **minzoom** (numeric) - Required - The minimum zoom level at which a layer can be viewed.
*   **maxzoom** (numeric) - Required - The maximum zoom level at which a layer is rendered; the layer will still be visible past the maximum zoom level due to overzooming.
*   **features** (list) - Optional - A list of feature options, possibly generated with `feature_options()`.
*   **tiles** (list) - Optional - A list of tile options, possibly generated with `tile_options()`

### Value
A recipe layer list to be used in `mts_make_recipe()`.
```

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

### Display Navigation Instructions

Source: https://walker-data.com/mapboxapi/articles/navigation.html

Shows the detailed navigation instructions for a route, presented as a character vector.

```r
##  [1] "Se diriger vers le nord-est"                         
##  [2] "Tourner à gauche"                                    
##  [3] "Tourner à droite sur l’avenue de Wagram"             
##  [4] "Tourner à droite sur la rue du Faubourg Saint-Honoré" 
##  [5] "Tourner à gauche sur la place des Ternes"            
##  [6] "Tourner à droite sur la place des Ternes"            
##  [7] "Tourner à droite sur l’avenue de Wagram"             
##  [8] "Tourner légèrement à droite sur la rue Cardinet"     
##  [9] "Tourner à gauche sur la rue de Tocqueville"          
## [10] "Tourner à gauche sur l’impasse Léger"                
## [11] "Tourner à droite"                                    
## [12] "Vous êtes arrivé à votre destination"
```

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

### Usage of mb_matrix function

Source: https://walker-data.com/mapboxapi/reference/mb_matrix.html

This snippet shows the function signature and available arguments for `mb_matrix`. It outlines options for origins, destinations, travel profiles, output formats, and access tokens.

```R
mb_matrix(
  origins,
  destinations = NULL,
  profile = "driving",
  fallback_speed = NULL,
  output = c("duration", "distance"),
  duration_output = c("minutes", "seconds"),
  access_token = NULL,
  depart_at = NULL,
  allow_large_matrix = FALSE
)
```

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

### list_styles

Source: https://walker-data.com/mapboxapi/reference/get_style.html

Lists all styles associated with a given Mapbox username.

```APIDOC
## GET /styles/{username}

### Description
Lists all styles from a Mapbox account.

### Method
GET

### Endpoint
/styles/{username}

### Parameters
#### Path Parameters
- **username** (string) - Required - A Mapbox username.

#### Query Parameters
- **access_token** (string) - Optional - A Mapbox public or secret access token.

### Response
#### Success Response (200)
- Returns a data frame of information about styles from a Mapbox account.
```

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

### Generate Static Map with Custom Markers

Source: https://walker-data.com/mapboxapi/reference/static_mapbox.html

This snippet shows how to create a static map image with custom point markers. It requires the mapboxapi library and a tibble containing longitude and latitude data for the points.

```r
if (FALSE) { # \dontrun{

library(mapboxapi)

points_of_interest <- tibble::tibble(
  longitude = c(-73.99405, -74.00616, -73.99577, -74.00761),
  latitude = c(40.72033, 40.72182, 40.71590, 40.71428)
)

prepped_pois <- prep_overlay_markers(
  data = points_of_interest,
  marker_type = "pin-l",
  label = 1:4,
  color = "fff"
)

map <- static_mapbox(
  style_id = "streets-v11",
  username = "mapbox",
  overlay_markers = prepped_pois,
  width = 1200,
  height = 800
)

map
} # }



```

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

### tile_options Function Signature

Source: https://walker-data.com/mapboxapi/reference/tile_options.html

This is the function signature for `tile_options`. It outlines the available arguments for configuring tile options in an MTS recipe layer.

```R
tile_options(
  bbox = NULL,
  extent = NULL,
  buffer_size = NULL,
  limit = NULL,
  union = list(where = NULL, group_by = NULL, aggregate = NULL, maintain_direction = NULL, simplification = NULL),
  filter = NULL,
  attributes = NULL,
  order = NULL,
  remove_filled = NULL,
  id = NULL,
  layer_size = NULL
)
```

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

### mts_create_tileset

Source: https://walker-data.com/mapboxapi/reference/mts_create_tileset.html

Creates a vector tileset from a given recipe and source. The tileset is hosted in your Mapbox account and can be published for use in Mapbox Studio, Mapbox GL JS, or other compatible tools.

```APIDOC
## mts_create_tileset

### Description
Creates a vector tileset from a given recipe and source. The tileset is hosted in your Mapbox account and can be published for use in Mapbox Studio, Mapbox GL JS, or other compatible tools.

### Method
POST

### Endpoint
/tilesets/v1

### Parameters
#### Path Parameters
- **tileset_name** (string) - Required - The name of the MTS tileset you intend to create.
- **username** (string) - Required - Your Mapbox username.

#### Query Parameters
- **recipe** (object) - Required - An MTS recipe, created with `mts_make_recipe()`.
- **request_name** (string) - Optional - The name of the request; defaults to the tileset name.
- **access_token** (string) - Optional - Your Mapbox access token.

### Request Example
```json
{
  "tileset_name": "your_tileset_name",
  "username": "your_mapbox_username",
  "recipe": { ... },
  "request_name": "optional_request_name",
  "access_token": "your_mapbox_access_token"
}
```

### Response
#### Success Response (200)
- **response** (list) - The response from the API, formatted as an R list.

#### Response Example
```json
{
  "message": "Tileset creation initiated successfully."
}
```
```

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

### Generate and Visualize Isochrones

Source: https://walker-data.com/mapboxapi/articles/navigation.html

Generates walking isochrones around The Kremlin in Moscow for different travel times and visualizes them using mapdeck. The polygons represent areas reachable within the specified times.

```r
library(mapdeck)

isochrones <- mb_isochrone("The Kremlin, Moscow Russia", 
                           time = c(4, 8, 12),
                           profile = "walking") 

mapdeck(style = mapdeck_style("light")) %>%
  add_polygon(data = isochrones, 
              fill_colour = "time",
              fill_opacity = 0.5,
              legend = TRUE)
```

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

### Forward Geocoding with Structured Input

Source: https://walker-data.com/mapboxapi/articles/geocoding.html

Provide structured address components as an R list to `mb_geocode()` for more precise geocoding. This is useful when address components are known separately.

```r
mb_geocode(
  structured_input = list(
    address_line1 = "445 5th Ave",
    place = "New York",
    region = "NY",
    postcode = "10016"
  )
)
```

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

### Create Tileset Sources from R Data

Source: https://walker-data.com/mapboxapi/articles/dynamic-maps.html

Use `mts_create_source()` to upload R data (e.g., GeoJSON) as tileset sources to your Mapbox account. This function requires a Mapbox access token with secret scope and write access. The output contains the tileset source ID needed for recipe creation.

```r
county_source <- mts_create_source(
  data = county_broadband,
  tileset_id = "county_broadband",
  username = "kwalkertcu"
)

tract_source <- mts_create_source(
  data = tract_broadband,
  tileset_id = "tract_broadband",
  username = "kwalkertcu"
)
```

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

### R Function Signature for Listing Tileset Sources

Source: https://walker-data.com/mapboxapi/reference/mts_list_sources.html

Defines the signature for the `mts_list_sources` function, specifying arguments for username, sorting, limiting results, and authentication.

```R
mts_list_sources(
  username,
  sortby = c("created", "modified"),
  limit = 100,
  start = NULL,
  access_token = NULL
)
```

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

### upload_tiles

Source: https://walker-data.com/mapboxapi/reference/upload_tiles.html

Uploads a dataset as a tileset to your Mapbox account. This function can accept an `sf` object or a file path as input. It requires your Mapbox username and optionally accepts an access token, tileset ID, and tileset name.

```APIDOC
## Function: upload_tiles

### Description
Uploads a dataset to your Mapbox account as a tileset. This function can handle input as an `sf` object or a file path.

### Arguments

*   **input** (sf object or character string) - The dataset to upload, either as an `sf` object or a path to the dataset.
*   **username** (character string) - Your Mapbox username.
*   **access_token** (character string, optional) - Your Mapbox access token. Must have secret scope.
*   **tileset_id** (character string, optional) - The ID of the tileset in your Mapbox account.
*   **tileset_name** (character string, optional) - The name of the tileset in your Mapbox account.
*   **keep_geojson** (boolean, optional) - Whether to keep the temporary GeoJSON file used for tile generation if the input is an `sf` object. Defaults to `FALSE`.
*   **multipart** (boolean, optional) - Whether to upload to the temporary AWS staging bucket as a multipart object. Defaults to `FALSE`.

### Example

```r
# Example: create a tileset of median age for all United States Census tracts
# Requires setting a Mapbox secret access token as an environment variable

library(mapboxapi)
library(tidycensus)
options(tigris_use_cache = TRUE)

median_age <- get_acs(
  geography = "tract",
  variables = "B01002_001",
  state = c(state.abb, "DC"),
  geometry = TRUE
)

upload_tiles(
  input = median_age,
  username = "kwalkertcu", # Your username goes here
  tileset_id = "median_age",
  tileset_name = "us_median_age_2014_to_2018"
)
```
```

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

### get_static_tiles

Source: https://walker-data.com/mapboxapi/reference/get_static_tiles.html

Queries the Mapbox Static Tiles API to composite tiles as a raster suitable for use as a basemap. It returns a raster layer corresponding to an input bounding box or a buffered area around an input shape.

```APIDOC
## get_static_tiles

### Description
Queries the Mapbox Static Tiles API and composites the tiles as a raster suitable for use as a basemap in tmap or ggplot2. It returns a raster layer that corresponds either to an input bounding box or a buffered area around an input shape.

### Arguments

*   **location** (vector or sf object) - An input location for which you would like to request tiles. Can be a length-4 vector representing a bounding box, or an `sf` object. If an input `sf` object is supplied, use the `buffer_dist` argument to control how much area you want to capture around the layer. While the input `sf` object can be in an arbitrary coordinate reference system, if a length-4 bounding box vector is supplied instead it must represent WGS84 longitude/latitude coordinates and be in the order `c(xmin, ymin, xmax, ymax)`.
*   **zoom** (numeric) - The zoom level for which you'd like to return tiles.
*   **style_id** (character) - A Mapbox style ID; retrieve yours from your Mapbox account.
*   **username** (character) - A Mapbox username.
*   **style_url** (character, optional) - A Mapbox style URL.
*   **scaling_factor** (character, optional) - The scaling factor to use; one of `"1x"` or `"2x"`. Defaults to `c("1x", "2x")`.
*   **buffer_dist** (numeric, optional) - The distance to buffer around an input `sf` object for determining tile extent, specified in units. Defaults to 5000.
*   **units** (character, optional) - Units of `buffer_dist`; defaults to "m" (meters). If buffer_dist is a units class object, the units argument is ignored.
*   **crop** (logical, optional) - Whether or not to crop the result to the specified bounding box or buffer area. Defaults to `TRUE`; `FALSE` will return the extent of the overlapping tiles.
*   **access_token** (character, optional) - A Mapbox access token. Supply yours here or set globally with the `mb_access_token()` function.

### Value
A raster layer of tiles from the requested Mapbox style representing the area around the input location. The raster layer is projected in the Web Mercator coordinate reference system.

### Examples
```R
if (FALSE) { # \dontrun{

library(mapboxapi)
library(tigris)
library(tmap)
library(ggspatial)
library(ggplot2)

ny_tracts <- tracts("NY", "New York", cb = TRUE)

ny_tiles <- get_static_tiles(
  location = ny_tracts,
  zoom = 10,
  style_id = "light-v9",
  username = "mapbox"
)

# tmap usage:
tm_shape(ny_tiles) + 
  tm_rgb() + 
  tm_shape(ny_tracts) + 
  tm_polygons(alpha = 0.5, col = "navy") + 
  tm_credits("Basemap (c) Mapbox, (c) OpenStreetMap", 
    position = c("RIGHT", "BOTTOM")
  )

# ggplot2 usage:
ggplot() + 
  layer_spatial(ny_tiles) + 
  geom_sf(data = ny_tracts, fill = "navy", alpha = 0.5) + 
  theme_void() + 
  labs(caption = "Basemap (c) Mapbox, (c) OpenStreetMap")
}
```
```
Tokens:
Raw