Sorry, you need to enable JavaScript to visit this website.

Search examples

Have a look at our functional examples to see how easy it is to implement search features with the Maps SDK. Speed up development by using our sample code snippets in your app. Try all of this out with the Maps SDK Examples app!

Allow your users to easily search for addresses and POIs in a single step. Implement global search or near-me search in your mobile app so that it returns the best search results for your needs. Global search uses the search functionality’s default settings. It doesn’t use the user’s position or other search parameters.

Sample use case: You use an app to search for a place. This search should not be limited in any way. Use the following code snippet in your app to list general search results or display them on the map.

_

return FuzzySearchQueryBuilder.create(text).build();
FuzzySearchQueryBuilder.create(text).build()

 

Add the following code snippet to your app to get search results that are geo-biased for a given location in a range specified by a radius.

_

return FuzzySearchQueryBuilder.create(text).withPreciseness(new LatLngAcc(position, STANDARD_RADIUS)).build();
FuzzySearchQueryBuilder.create(query)
        .withPreciseness(addPreciseness())
        .build()

 

image

Global address search functional example from Sample App

image

Near me address search functional example from Sample App

POI Category tree

The Point of Interest (POI) Categories service endpoint provides the full list of POI categories and subcategories together with their translations and synonyms available in Search API, see POI Categories (https://developer.tomtom.com/search-api/search-api-documentation-poi-categories/poi-categories) for more information.
Thanks to that list, you do not have to hardcode categories in your app, as they change dynamically. Once you have the POI category ID, you can use them as a filter (categorySet) in search quires.

Sample use case: You want to display a dynamic list of all available categories and subcategories that can be used for search combined with appropriate filters.

Use the following code snippet to try this in your app:

_

PoiCategoriesQuery poiCategoriesQuery = PoiCategoriesQueryBuilder.create()
        .withLanguage("en-GB")
        .build();
searchAPI.poiCategoriesSearch(poiCategoriesQuery);
val poiCategoriesQuery = PoiCategoriesQueryBuilder.create()
    .withLanguage("en-GB")
    .build()
searchApi.poiCategoriesSearch(poiCategoriesQuery)

 

The following is an example application view utilizing POI Category Search.

image

List of categories.

Help your users search for specific types of places with Category Search.

Sample use case: You are preparing for a long drive and would like to find nearby gas stations. Use the following code snippet to try this in your app.

_

FuzzySearchQueryBuilder.create(text)
        .withPreciseness(new LatLngAcc(position, STANDARD_RADIUS))
        .withTypeAhead(true)
        .withCategory(true).build();
val categorySearchQuery = FuzzySearchQueryBuilder.create(query)
        .withPreciseness(addPreciseness())
        .withCategory(true)
        .build()

 

The following is an exemplary application view utilizing Category Search.

image

Address search with category: Parking

image

Address search with category: Gas

image

Address search with category: ATM

Develop an international app that can be used in different languages. Enhance the search functionality with the language parameter so that the search returns results in a specific language.

Sample use case: If your mobile device is set to a particular language, you will see it in your app as well. Use the following code snippet to try this in your app.

_

return FuzzySearchQueryBuilder.create(text).withLanguage(lang).build();
val searchQuery = FuzzySearchQueryBuilder.create(query)
        .withLanguage(languageSelector.code)
        .withPosition(addPosition())
        .build()

 

Offer your users search suggestions while they type with the "typeahead" flag.

Sample use case: You were recommended a place to visit, but you can’t remember its name. You start searching in your app. After a few letters you see the place you’re looking for! Use the following code snippet to try this in your app.

_

FuzzySearchQueryBuilder.create(text)
        .withPosition(position)
        .withTypeAhead(true).build();
val searchQuery = FuzzySearchQueryBuilder.create(query)
        .withPosition(addPosition())
        .withTypeAhead(true)
        .build()

 

Autocomplete

Autocomplete enables you to make a more meaningful search by recognizing entities inside your input and offering them as query terms. Autocomplete will fill in the rest with 3 different types of results: brands, categories, and plaintext. The autocomplete complements the ‘typeahead’ parameter in a fuzzy search by providing related categories and brands that the user might be looking for. Suggestions could appear after typing the 1st character, however we recommend using it at least after the 3rd character to improve the user experience.

Sample use case 1: You would like to buy some wine, but you do not know where the closest wine shop is. Thanks to 'Categories' suggestions you would be able to find the POIs of an appropriate category. You type 'win' in your app, and at the 3rd character the service provides some suggestions like 'wine shop' or 'winery'.

Sample use case 2: You use an app to efficiently search for a POI of a specific brand, e.g., you want to find a TomTom office. Search Autocomplete will return suggested branded POIs based on only a few characters that you type in. So, when typing 'Tom' you can expect 'TomTom' as the suggested brand which will make your search result more meaningful.

The Autocomplete endpoint information is available in the Search API.
Have a look at the detailed documentation for more information related to the Autocomplete endpoint.

Use the following code snippets to try this in your app:

_

AutocompleteSearchQuery autocompleteQuery = AutocompleteSearchQueryBuilder.create(query, "en-GB")
        .withRadius(10_000)
        .withPosition(Locations.AMSTERDAM_LOCATION)
        .withCountry("NL")
        .withLimit(10)
        .build();
searchAPI.autocompleteSearch(autocompleteQuery);
val autocompleteQuery = AutocompleteSearchQueryBuilder.create(query, "en-GB")
    .withRadius(10_000)
    .withPosition(Locations.AMSTERDAM)
    .withCountry("NL")
    .withLimit(10)
    .build()
    searchApi.autocompleteSearch(autocompleteQuery)

 

Screenshots presenting how the autocomplete functionality works:

image

Suggestions

image

Results on the map

Help your users even more with Fuzzy Search. Use the right fuzziness levels in your app to make it less sensitive to typos.

Sample use case: You occasionally make mistakes when typing. Your app still returns the desired search results. Use the following code snippet to try this in your app.

  • Level 1: Uses no spell checking.

  • Level 2: Uses normal n-gram spell checking. For example, a query "restrant" can be matched to "restaurant".

  • Level 3: Uses sound-like spell checking and shingle spell checking. Sound-like spell checking is for "rstrnt" to "restaurant" matching. Shingle spell checking is for "mountainview" to "mountain view" matching.

  • Level 4: Doesn’t add any more spell checking functionality.

The search engine will start looking for a match on the level defined by minFuzzyLevel and will stop searching at the level specified by maxFuzzyLevel.

_

FuzzySearchQueryBuilder.create(query)
.withPosition(position)
.withMinFuzzyLevel(1)
.withMaxFuzzyLevel(maxLevel).build();
val fuzzyQuery = FuzzySearchQueryBuilder.create(query)
        .withPosition(addPosition())
        .withMinFuzzyLevel(1)
        .withMaxFuzzyLevel(maxFuzzyLevel)
        .build()

 

Reverse geocoding

Sometimes you need to translate a coordinate into a human-readable street address. This is often used in tracking applications that receive a GPS feed from a device or asset and need to obtain the corresponding address. The reverse geocoding endpoint returns the address information described in the Reverse Geocoding API documentation on the Developer Portal.

Sample use case: You want to know the address of a place on the map. You press your finger on the map display and address information appears in a balloon on the screen. Use the following code to try this in your app:

_

SearchApi searchAPI = createSearchAPI();
ReverseGeocoderSearchQuery reverseGeocoderQuery =
        createReverseGeocoderQuery(latLng);

searchAPI.reverseGeocoding(reverseGeocoderQuery, revGeoSearchCallback);
val revGeoQuery = ReverseGeocoderSearchQueryBuilder(latLng.latitude, latLng.longitude).build()
    searchApi.reverseGeocoding(revGeoQuery)

Polygons for reverse geocoding

Combine Additional Data Provider queries with Reverse Geocoding queries to obtain extra data about specific entityType like:

  • Country

  • CountrySubdivision

  • CountrySecondarySubdivision

  • CountryTertiarySubdivision

  • Municipality

  • MunicipalitySubdivision

  • Neighbourhood

  • PostalCodeArea

Sample use case: You want to display Country or Municipality boundaries.

Use the following code to try this in your app:

_

ReverseGeocoderSearchQuery reverseGeocoderQuery =
        createReverseGeocoderQuery(latLng.getLatitude(), latLng.getLongitude());

Observable<RevGeoWithAdpResponse> revGeoWithAdpResponseObservable =
        revGeoWithAdpRequester.rawReverseGeocoding(reverseGeocoderQuery)
                .subscribeOn(getWorkerScheduler())
                .filter(revGeoWithAdpResponse -> !revGeoWithAdpResponse.getRevGeoResponse().getAddresses().isEmpty())
                .doOnNext(this::updateUiWithResponse);
val queryBuilder = ReverseGeocoderSearchQueryBuilder(latLng.latitude, latLng.longitude)
entityType.value?.let {
    queryBuilder.withEntityType(it)
}

val adpSearchRequester = AdpSearchRequester(getApplication(), getGeometriesZoomForEntityType())
adpSearchRequester.revGeoWithAdp(queryBuilder.build(), revGeoWithAdpResult)

 

_

revGeoWithAdpRequester.toPolygonObservable(revGeoWithAdpResponseObservable)
        .observeOn(getObserverScheduler())
        .subscribe(polygon -> {
            tomtomMap.getOverlaySettings().addOverlay(polygon);
            getProgressDisplayable().hideInProgressDialog();
        }, error -> getProgressDisplayable().hideInProgressDialog())
FuncUtils.apply<Geometry>(feature.geometry) { input ->
    input.accept(object : GeoJsonObjectVisitorAdapter() {
        override fun visit(polygon: Polygon?) {
            polygon?.let { item ->
                displayPolygon(item)
                tomtomMap.setCurrentBounds(parsePolygonLatLngs(item))
            }
        }

        override fun visit(multiPolygon: MultiPolygon?) {
            val coordinates = ArrayList<LatLng>()
            multiPolygon?.polygons?.forEach { polygon ->
                coordinates.addAll(parsePolygonLatLngs(polygon))
                displayPolygon(polygon)
            }
            tomtomMap.setCurrentBounds(coordinates)
        }
    })
}

 

The class RevGeoWithAdpRequester serves as a helper to create complex queries:

_

class RevGeoWithAdpRequester {

    private final static int DEFAULT_GEOMETRIES_ZOOM = 4;
    private final PolygonAdapter polygonAdapter = new PolygonAdapter();
    private final SearchApi searchApi;

    private int geometriesZoom = DEFAULT_GEOMETRIES_ZOOM;

    RevGeoWithAdpRequester(SearchApi searchApi) {
        this.searchApi = searchApi;
    }

    Observable<Polygon> toPolygonObservable(Observable<RevGeoWithAdpResponse> revGeoWithAdpResponseObservable) {
        return revGeoWithAdpResponseObservable
                .flatMap((Function<RevGeoWithAdpResponse, ObservableSource<Polygon>>) revGeoWithAdpResponse -> {
                    AdditionalDataSearchResult adpResult =
                            FuncUtils.first(revGeoWithAdpResponse.getAdpResponse().getResults()).get();

                    return createSpecificPolygonObservable(parseGeometryResult(adpResult));
                });
    }

    @NonNull
    @VisibleForTesting
    protected GeometryResult parseGeometryResult(AdditionalDataSearchResult adpResult) {
        final AtomicReference<GeometryResult> gr = new AtomicReference<>();
        adpResult.accept(result -> gr.set(result));
        return gr.get();
    }

    Observable<RevGeoWithAdpResponse> rawReverseGeocoding(ReverseGeocoderSearchQuery reverseGeocoderQuery) {
        return searchApi.reverseGeocoding(reverseGeocoderQuery)
                .toObservable()
                .filter(response -> !response.getAddresses().isEmpty()
                        && FuncUtils.first(response.getAddresses()).get()
                        .getAdditionalDataSources().getGeometryDataSource().isPresent())
                .flatMap(response -> {
                    final GeometryDataSource geometryDataSource =
                            FuncUtils.first(response.getAddresses()).get()
                                    .getAdditionalDataSources().getGeometryDataSource().get();
                    return searchApi.additionalDataSearch(createAdditionalDataSearchQuery(geometryDataSource))
                            .toObservable().flatMap(adpResponse ->
                                    Observable.just(new RevGeoWithAdpResponse(response, adpResponse)));
                })
                .filter(response -> response.isValid())
                .filter(response -> response.getRevGeoResponse().hasResults())
                .filter(response -> !response.getAdpResponse().getResults().isEmpty());
    }

    void setGeometriesZoom(int geometriesZoom) {
        this.geometriesZoom = geometriesZoom;
    }

    private AdditionalDataSearchQuery createAdditionalDataSearchQuery(GeometryDataSource geometryDataSource) {
        return AdditionalDataSearchQueryBuilder.create()
                .withGeometryDataSource(geometryDataSource)
                .withGeometriesZoom(geometriesZoom)
                .build();
    }

    private Observable<Geometry> createGeometryObservable(GeometryResult result) {
        return Observable.just(result)
                .filter(geometryResult -> geometryResult.getGeometryData().isPresent())
                .map(geometryResult -> geometryResult.getGeometryData().get())
                .filter(geoJsonObject -> geoJsonObject instanceof FeatureCollection)
                .map(geoJsonObject -> ((FeatureCollection) geoJsonObject).getFeatures())
                .filter(features -> !features.isEmpty())
                .map(features -> FuncUtils.first(features).get())
                .filter(feature -> feature.getGeometry().isPresent())
                .map(feature -> feature.getGeometry().get());
    }

    private Observable<Polygon> createPolygonsObservable(Geometry geometry) {
        return Observable.just(geometry)
                .filter(geo -> geo instanceof MultiPolygon)
                .map(geo -> (MultiPolygon) geo)
                .flatMap((Function<MultiPolygon, ObservableSource<com.tomtom.online.sdk.common.geojson.geometry.Polygon>>)
                        multiPolygon -> Observable.fromIterable(multiPolygon.getPolygons()))
                .map(polygon -> getPolygonAdapter().convertToMapPolygon(polygon));
    }

    private Observable<Polygon> createSinglePolygonObservable(Geometry geometry) {
        return Observable.just(geometry)
                .filter(geo -> geo instanceof com.tomtom.online.sdk.common.geojson.geometry.Polygon)
                .map(geo -> (com.tomtom.online.sdk.common.geojson.geometry.Polygon) geo)
                .map(polygon -> getPolygonAdapter().convertToMapPolygon(polygon));
    }

    @VisibleForTesting
    protected PolygonAdapter getPolygonAdapter() {
        return polygonAdapter;
    }

    private Observable<Polygon> createSpecificPolygonObservable(GeometryResult result) {
        Geometry geometry = createGeometryObservable(result).blockingFirst();
        return (geometry instanceof MultiPolygon) ?
                createPolygonsObservable(geometry) :
                createSinglePolygonObservable(geometry);
    }
}
class AdpSearchRequester(context: Context, private val geometriesZoom: Int) : RxContext {

    private val disposable = SerialDisposable()
    private val searchApi = OnlineSearchApi.create(context)!!

    fun fuzzyWithAdp(searchQuery: FuzzySearchQuery, resource: ResourceLiveData<AdditionalDataSearchResult>) {
        resource.value = Resource.loading(null)
        disposable.set(searchApi.search(searchQuery)
            .subscribeOn(workingScheduler)
            .filter { nonEmptySearchResults(it) }
            .map { firstSearchResultWithGeometryDataSource(it) }
            .filter { presentSearchResult(it) }
            .map { firstDataSourceForSearchResult(it) }
            .flatMap { performAdp(it) }
            .observeOn(resultScheduler)
            .subscribe(
                { response -> resource.value = Resource.success(response.results.first()) },
                { error -> resource.value = Resource.error(null, Error(error.message)) }
            ))
    }

    private fun firstDataSourceForSearchResult(searchResult: Optional<FuzzySearchResult>) =
        searchResult.get().additionalDataSources.geometryDataSource.get()

    private fun presentSearchResult(searchResult: Optional<FuzzySearchResult>) =
        searchResult.isPresent

    private fun nonEmptySearchResults(searchResponse: FuzzySearchResponse) =
        searchResponse.results.isEmpty().not()

    private fun firstSearchResultWithGeometryDataSource(searchResponse: FuzzySearchResponse): Optional<FuzzySearchResult> {
        return Optional.fromNullable(searchResponse.results.find { item ->
            item.additionalDataSources?.geometryDataSource!!.isPresent
        })
    }

    fun revGeoWithAdp(revGeoQuery: ReverseGeocoderSearchQuery, resource: ResourceLiveData<RevGeoWithAdpResponse>) {
        val result = RevGeoWithAdpResponse()
        resource.value = Resource.loading(null)

        disposable.set(searchApi.reverseGeocoding(revGeoQuery)
            .subscribeOn(workingScheduler)
            .filter { nonEmptyRevGeoResults(it) }
            .map { firstRevGeoResultWithGeometryDataSource(it) }
            .map {
                result.revGeoResult = it.orNull()
                firstDataSourceForRevGeoResult(it)
            }
            .filter { nonEmptyGeometryDataSource(it) }
            .map { it.get() }
            .flatMap { performAdp(it) }
            .observeOn(resultScheduler)
            .subscribe(
                { response ->
                    result.adpResult = response.results
                    resource.value = Resource.success(result)
                },
                { error -> resource.value = Resource.error(null, Error(error.message)) }
            )
        )
    }

    private fun nonEmptyGeometryDataSource(dataSource: Optional<GeometryDataSource>) =
        dataSource.isPresent

    private fun nonEmptyRevGeoResults(response: ReverseGeocoderSearchResponse) =
        response.hasResults()

    private fun firstRevGeoResultWithGeometryDataSource(revGeoResponse: ReverseGeocoderSearchResponse): Optional<ReverseGeocoderFullAddress> =
        Optional.fromNullable(revGeoResponse.addresses.find { item ->
            item.additionalDataSources?.geometryDataSource!!.isPresent
        })

    private fun firstDataSourceForRevGeoResult(it: Optional<ReverseGeocoderFullAddress>): Optional<GeometryDataSource> {
        it.orNull()?.let {
            return it.additionalDataSources!!.geometryDataSource!!
        } ?: run {
            return Optional.absent<GeometryDataSource>()
        }
    }

    private fun performAdp(dataSource: GeometryDataSource): Maybe<AdditionalDataSearchResponse> {
        val adpQuery = AdditionalDataSearchQueryBuilder.create()
            .withGeometryDataSource(dataSource)
            .withGeometriesZoom(geometriesZoom)
        val request = searchApi.additionalDataSearch(adpQuery.build())
        return request.toMaybe()
    }

    override fun getWorkingScheduler() = Schedulers.newThread()

    override fun getResultScheduler() = AndroidSchedulers.mainThread()!!

}

 

Sample views utilizing entities retrieved by combining both services:

image

Boundaries for a selected country

image

Boundaries for a selected municipality

To cancel a pending search request in the Maps SDK, call:

searchService.cancelSearchIfRunning();

 

Search along the route

Allow your users to search for POIs (Points of Interest) along a planned route so they can optimally add places to their rides. This search is constrained by specifying the detour time and limiting the number of results. The minimum number of route points is 2.

Sample use case 1: You are driving from Amsterdam to Haarlem and you would like to find a gas station or an EV station to fuel or charge your car during your drive.

Sample use case 2: When planning your next trip, you would like to add a car repair station so you can fix and safely drive your vehicle.

Use the following code to try this in your app:

_

AlongRouteSearchQueryBuilder query = new AlongRouteSearchQueryBuilder(
        term,
        route.getCoordinates(),
        SEARCH_MAX_DETOUR_TIME);

query.withLimit(SEARCH_MAX_LIMIT);

SearchApi searchAPI = OnlineSearchApi.create(context);
searchAPI.alongRouteSearch(query.build(), alongRouteSearchCallback);
val query = AlongRouteSearchQueryBuilder(term,
        route.coordinates,
        SEARCH_MAX_DETOUR_TIME)
        .withLimit(SEARCH_MAX_LIMIT)
        .build()
searchApi.alongRouteSearch(query)

 

Sample views utilizing Search Along Route:

image

With term "PETROL_STATION"

image

With term "ELECTRIC_VEHICLE_STATION"

Allow your users to perform a free text search inside geometries specified by circles and/or polygons.

Sample use case: You are planing to visit the area of Amsterdam. You need find a parking spot, an ATM, and a grocery store in the city centre in Amsterdam and/or in the west part of the city.

Use the following code to try this in your app:

_

List<Geometry> geometries = new ArrayList<>();
geometries.add(new Geometry(new PolygonGeometry(DefaultGeometries.POLYGON_POINTS)));
geometries.add(new Geometry(new CircleGeometry(DefaultGeometries.CIRCLE_CENTER, DefaultGeometries.CIRCLE_RADIUS)));
val circleGeometry = createDefaultCircleGeometry()
val polygonGeometry = createDefaultPolygonGeometry()
val geometriesList = listOf(Geometry(circleGeometry), Geometry(polygonGeometry))

val query = GeometrySearchQueryBuilder.create(term, geometriesList)
    .withLimit(SEARCH_RESULTS_LIMIT)
    .build()

_

GeometrySearchQuery query = new GeometrySearchQueryBuilder(term, geometries)
        .withLimit(SEARCH_RESULTS_LIMIT).build();

SearchApi searchAPI = OnlineSearchApi.create(context);
searchAPI.geometrySearch(query, geometrySearchCallback);
searchApi.geometrySearch(geometryQuery)

 

Sample views utilizing Geometry Search:

image

Geometry search with term: Parking

image

Geometry search with term: ATM

Entry points

Allow your users to display entry points using Fuzzy Search results.

Sample use case: A taxi driver wants to pick up a passenger from the specific entry point at the airport.

Use the following code to try this in your app:

_

for (EntryPoint entryPoint : fuzzySearchResult.getEntryPoints()) {
    SimpleMarkerBalloon markerBalloon = new SimpleMarkerBalloon(
            String.format(markerBalloonText, entryPoint.getType()));

    addMarkerWithIcon(entryPoint, markerBalloon, icon);
}
fuzzySearchResult.entryPoints.forEach { entryPoint ->
    val markerBalloon = SimpleMarkerBalloon(
            String.format(markerBalloonText, entryPoint.type))

    addMarkerWithIcon(entryPoint, markerBalloon, icon)
}

_

private void addMarkerWithIcon(EntryPoint entryPoint, SimpleMarkerBalloon balloon, Icon icon) {
    tomtomMap.addMarker(new MarkerBuilder(entryPoint.getPosition())
            .markerBalloon(balloon)
            .icon(icon));
}
private fun addMarkerWithIcon(entryPoint: EntryPoint, balloon: SimpleMarkerBalloon, icon: Icon) {
    tomtomMap.addMarker(MarkerBuilder(entryPoint.position)
            .markerBalloon(balloon)
            .icon(icon))
}

 

Sample views utilizing entry points:

image

Entry points for the Amsterdam airport

image

Entry points for the Kalvertoren mall

Additional data

Allow your users to request extra data like polygons representing administrative borders, for a set of entities previously retrieved from an Search API. For more information, refer to the Additional Data service documentation.

Sample use case: You want to apply colors to geographic-boundary areas such as countries, cities, or districts.

Use the following code to try this in your app:

_

FuzzySearchQuery fuzzySearchQuery = FuzzySearchQueryBuilder.create(term).build();

searchRequester.performAdpSearch(fuzzySearchQuery, responseConsumer);
val searchQuery = FuzzySearchQueryBuilder.create(term).build()
val requester = AdpSearchRequester(getApplication(), geometriesZoom)

requester.fuzzyWithAdp(searchQuery, adpResult)

 

Sample views utilizing entities retrieved from the Additional Data service:

image

Boundaries for Amsterdam

image

Boundaries for Poland

Allow your users to process synchronous batch search calls with the Batch Search service integrated. When the service receives a request, it will respond as soon as the batch items are calculated and there will be no possibility to retrieve the results later on.

Supported types of requests

  1. Geometry Search

  2. Fuzzy Search

  3. Reverse Geocode

Different types of requests can be mixed in one batch request. The information about the limit of queries, request processing time, and other details are described in the Batch Search service documentation. An error in one of the batch requests causes the whole batch to fail.

Sample use case: You want to simultaneously search for different categories within different locations.

Use the following code to try this in your app:

_

//Using batch, it is possible to execute different search types:
//fuzzy, geometry or reverse geocoding. The order of responses
//is the same as the order in which the queries are added.
BatchSearchQueryBuilder batchQuery = new BatchSearchQueryBuilder();
batchQuery.withFuzzySearchQuery(createAmsterdamQuery(category));
batchQuery.withFuzzySearchQuery(createHaarlemQuery(category));
batchQuery.withGeometrySearchQuery(createHoofddropQuery(category));

final SearchApi searchApi = OnlineSearchApi.create(context);
searchApi.batchSearch(batchQuery.build(), batchSearchResultListener);
//Using batch, it is possible to execute different search types:
//fuzzy, geometry or reverse geocoding. The order of responses
//is the same as the order in which the queries are added.
val batchQuery = BatchSearchQueryBuilder()
        .withFuzzySearchQuery(createAmsterdamQuery(category))
        .withFuzzySearchQuery(createHaarlemQuery(category))
        .withGeometrySearchQuery(createHoofddropQuery(category))
        .build()

    searchApi.batchSearch(batchSearchQuery)

 

Sample views utilizing data retrieved using the Batch Search service:

image

Search results for different locations