Bulk Geocoding¶

import { GeocodingApi, Configuration } 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 GeocodingApi(config);
const api = new GeocodingApi();

const res = await api.searchBulk({
  bulkRequest: [
    { endpoint: "/v1/search", query: { text: "Põhja pst 27" } },
    {
      endpoint: "/v1/search/structured",
      query: {
        address: "Kursi tänav 3",
        country: "EE",
        layers: ["coarse", "address"],
      },
    },
  ],
});

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.GeocodingApi(api_client)

    try:
        res = api_instance.search_bulk([
            stadiamaps.BulkRequest(endpoint="/v1/search",
                                   query=stadiamaps.BulkRequestQuery(stadiamaps.SearchQuery(text="Põhja pst 27"))),
            stadiamaps.BulkRequest(endpoint="/v1/search/structured",
                                   query=stadiamaps.BulkRequestQuery(stadiamaps.SearchStructuredQuery(
                                       address="Kursi tänav 3",
                                       country="EE",
                                       layers=[
                                           stadiamaps.PeliasLayer.COARSE,
                                           stadiamaps.PeliasLayer.ADDRESS]))),
        ])
    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(GeocodingApi::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 reqs = listOf(
    BulkRequestFactory.searchRequest(SearchQuery(text = "Põhja pst 27")),
    BulkRequestFactory.searchStructuredRequest(SearchStructuredQuery(address = "Kursi tänav 3", country = "Estonia"))
)
val res = service.searchBulk(reqs).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 res = try await GeocodingAPI.searchBulk(bulkRequest: [
        BulkRequest(endpoint: .search, query: .typeSearchQuery(SearchQuery(text: "Põhja pst 27"))),
        BulkRequest(endpoint: .searchSlashStructured, query: .typeSearchStructuredQuery(SearchStructuredQuery(address: "Kursi tänav 3", country: "EE", layers: [.address, .coarse]))),
    ])

    // 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\GeocodingApi(
    new GuzzleHttp\Client(),
    $config
);

try {
    $requests = array(
        new BulkRequest(array(
            "endpoint" => "/v1/search",
            "query" => new SearchQuery(array("text" => "Põhja pst 27")))),
        new BulkRequest(array(
            "endpoint" => "/v1/search/structured",
            "query" => new SearchStructuredQuery(array("address" => "Kursi tänav 3", "country" => "EE", "layers" => ["coarse", "address"]))))
    );
    $result = $apiInstance->searchBulk($requests);
} catch (Exception $e) {
    // Add your error handling here
    echo 'Exception when calling the Stadia Maps API: ', $e->getMessage(), PHP_EOL;
}

curl -X 'POST' \
  'https://api.stadiamaps.com/geocoding/v1/search/bulk?api_key=YOUR-API-KEY' \
  -H 'accept: application/json' \
  -H 'Content-Type: application/json' \
  -d '[
  {
    "endpoint": "/v1/search",
    "query": {
      "text": "Põhja pst 27"
    }
  },
  {
    "endpoint": "/v1/search/structured",
    "query": {
      "address": "Kursi tänav 3",
      "country": "EE",
      "layers": ["coarse", "address"]
    }
  }
]'