Google Maps JavaScript API v3

Autocomplete for Addresses and Search Terms

  1. Introduction
  2. Video: How to use Autocomplete
  3. Example: Autocomplete for address forms
  4. Example: Autocomplete for map controls
  5. Add Autocomplete for places and addresses
    1. Set biases and search-area boundaries for Autocomplete
    2. Customize the placeholder text for Autocomplete
    3. Get place information from Autocomplete
  6. Add SearchBox for autocompleting search terms
    1. Change the search area for SearchBox
    2. Get SearchBox information
  7. Style the Autocomplete and SearchBox widgets
  8. Retrieve predictions from the autocomplete service

Introduction

Autocomplete is a feature of the Places library in the Google Maps JavaScript API. You can use autocomplete to give your applications the type-ahead-search behavior of the Google Maps search field. When a user starts typing an address, autocomplete will fill in the rest.

In order to use autocomplete, you will need to load the Google Places library using the libraries parameter in the bootstrap URL for the Google Maps JavaScript API.

<script type="text/javascript" src="http://maps.googleapis.com/maps/api/js?libraries=places&sensor=true_or_false"></script>

See the Libraries Overview for more information.

The API offers two types of autocomplete widgets, which you can add via the Autocomplete and SearchBox classes respectively. In addition, you can use the AutocompleteService class to retrieve autocomplete results programmatically.

Below is a summary of the classes available:

  • Autocomplete adds a text input field to your web page, and monitors that field for character entries. As the user enters text, autocomplete returns place predictions in the form of a dropdown pick list. When the user selects a place from the list, information about the place is returned to the autocomplete object, and can be retrieved by your application. See the details below.
  • SearchBox adds a text input field to your web page, in much the same way as Autocomplete. The differences are as follows:
    • The main difference lies in the results that appear in the pick list. SearchBox supplies an extended list of predictions, which can include places (as defined by the Places API) plus suggested search terms. For example, if the user enters 'pizza in new', the pick list may include the phrase 'pizza in New York, NY' as well as the names of various pizza outlets.
    • SearchBox offers fewer options than Autocomplete for restricting the search. In the former, you can bias the search towards a given LatLngBounds. In the latter, you can restrict the search to a particular country and particular place types, as well as setting the bounds.
    See the details below.
  • You can create an AutocompleteService object to retrieve predictions programmatically. Call getPlacePredictions() to retrieve matching places, or call getQueryPredictions() to retrieve matching places plus suggested search terms. Note: AutocompleteService does not add any UI controls. Instead, the above methods return an array of prediction objects. Each prediction object contains the text of the prediction, as well as reference information and details of how the result matches the user input. See the details below.

The rest of this page provides example use cases, and details on using the above classes.

Video: How to use Autocomplete

This video shows you how to use Autocomplete, including demos and code samples:

Example: Autocomplete for address forms

Does your application include an address form, such as the shipping address for an online order, a credit card billing address, or a taxi booking form? Autocomplete can help users supply the details.

Figure 1 shows an autocomplete text field, and the pick list of place predictions supplied as the user enters the search query:

An autocomplete text field, and the pick list of place
    predictions supplied as the user enters the search query.
Figure 1: Autocomplete text field and pick list

When the user selects an address from the pick list, your application can populate the address form:

A completed address form.
Figure 2: Completed address form

See an address form in action: View example (places-autocomplete-addressform.html).

Read on to see how to add autocomplete to your web page.

Example: Autocomplete for map controls

Autocomplete is useful for prompting users for information as part of a map application, as shown in figure 3:

An autocomplete text field showing a partial city search query
    and matching places.
Figure 3: Autocomplete text field and pick list

See it in action: View example (places-autocomplete-hotelsearch.html).

Read on to see how to add autocomplete to your web page.

Add Autocomplete for places and addresses

Autocomplete creates a text input field on your web page, supplies predictions of places in a UI pick list, and returns place details in response to a getPlace() request. Each entry in the pick list corresponds to a single place (as defined by the Places API).

The Autocomplete constructor takes two arguments:

  • An HTML input element of type text. This is the input field that the autocomplete service will monitor and attach its results to.
  • An options argument, which can contain the following properties:
    • An array of types specifies an explicit type or a type collection, as listed in the supported types below. If nothing is specified, all types are returned. In general only a single type is allowed. The exception is that you can safely mix the geocode and establishment types, but note that this will have the same effect as specifying no types. The supported types are:
      • geocode instructs the Places service to return only geocoding (address) results.
      • establishment instructs the Places service to return only business results.
      • the (regions) type collection instructs the Places service to return any result matching the following types:
        • locality
        • sublocality
        • postal_code
        • country
        • administrative_area1
        • administrative_area2
      • the (cities) type collection instructs the Places service to return results that match either locality or administrative_area3.
    • bounds is a google.maps.LatLngBounds object specifying the area in which to search for places. The results are biased towards, but not restricted to, places contained within these bounds.
    • componentRestrictions can be used to restrict results to specific groups. Currently, you can use componentRestrictions to filter by country. The country must be passed as as a two-character, ISO 3166-1 Alpha-2 compatible country code.

Set biases and search-area boundaries for Autocomplete

You can bias the autocomplete results to favor an approximate location or area, in the following ways:

  • Set the bounds on creation of the Autocomplete object.
  • Change the bounds on an existing Autocomplete.
  • Set the bounds to the map's viewport.
  • Restrict the search to a specific country.

Details are in the sections below.

Set the bounds on creation of the Autocomplete object

The example below uses the bounds and types options to request businesses of type 'establishment,' favoring those within the specified geographic area.

var defaultBounds = new google.maps.LatLngBounds(
  new google.maps.LatLng(-33.8902, 151.1759),
  new google.maps.LatLng(-33.8474, 151.2631));

var input = document.getElementById('searchTextField');
var options = {
  bounds: defaultBounds,
  types: ['establishment']
};

autocomplete = new google.maps.places.Autocomplete(input, options);

Change the bounds of an existing Autocomplete

Call setBounds() to change the search area on an existing Autocomplete.

// Bias the autocomplete object to the user's geographical location,
// as supplied by the browser's 'navigator.geolocation' object.
function geolocate() {
  if (navigator.geolocation) {
    navigator.geolocation.getCurrentPosition(function(position) {
      var geolocation = new google.maps.LatLng(
          position.coords.latitude, position.coords.longitude);
      autocomplete.setBounds(new google.maps.LatLngBounds(geolocation,
          geolocation));
    });
  }
}

View example (places-autocomplete-addressform.html).

Set the bounds to the map's viewport

Use bindTo() to bias the results to the map's viewport, even while that viewport changes.

autocomplete.bindTo('bounds', map);

View example (places-autocomplete.html).

Restrict the search to a specific country

Use the componentRestrictions option to restrict the autocomplete search to a particular country. The following code restricts the results to cities within France.

var input = document.getElementById('searchTextField');
var options = {
  types: ['(cities)'],
  componentRestrictions: {country: 'fr'}
};

autocomplete = new google.maps.places.Autocomplete(input, options);

The following example allows the user to choose a country, then restricts the autocomplete results to that country.

// Set the country restriction based on user input.
// Also center and zoom the map on the given country.
function setAutocompleteCountry() {
  var country = document.getElementById('country').value;
  if (country == 'all') {
    autocomplete.setComponentRestrictions([]);
    map.setCenter(new google.maps.LatLng(15, 0));
    map.setZoom(2);
  } else {
    autocomplete.setComponentRestrictions({ 'country': country });
    map.setCenter(countries[country].center);
    map.setZoom(countries[country].zoom);
  }
  clearResults();
  clearMarkers();
}

View example (places-autocomplete-hotelsearch.html).

Customize the placeholder text for Autocomplete

By default, the text field created by the autocomplete service contains standard placeholder text. To modify the text, set the placeholder attribute on the input element:

<input id="searchTextField" type="text" size="50" placeholder="Anything you want!">

Note: The default placeholder text is localized automatically. If you specify your own placeholder value, you must handle the localization of that value in your application. For information on how the Google Maps JavaScript API chooses the language to use, please read the documentation on localization.

Get place information from Autocomplete

When a user selects a place from the predictions attached to the autocomplete text field, the service fires a place_changed event. You can call getPlace() on the Autocomplete object, to retrieve a PlaceResult object.

By default, autocomplete will give you the full address as a single line of text. For an address form, it is useful to get the address in structured format. You can use Autocomplete.getPlace() to retrieve the full details for each autocomplete prediction, including the structured address.

For more information about the PlaceResult object, refer to the documentation on place detail results.

The following example uses autocomplete to fill the fields in an address form.

function fillInAddress() {
  // Get the place details from the autocomplete object.
  var place = autocomplete.getPlace();

  for (var component in componentForm) {
    document.getElementById(component).value = '';
    document.getElementById(component).disabled = false;
  }

  // Get each component of the address from the place details
  // and fill the corresponding field on the form.
  for (var i = 0; i < place.address_components.length; i++) {
    var addressType = place.address_components[i].types[0];
    if (componentForm[addressType]) {
      var val = place.address_components[i][componentForm[addressType]];
      document.getElementById(addressType).value = val;
    }
  }
}

View example (places-autocomplete-addressform.html).

The SearchBox allows users to perform a text-based geographic search, such as 'pizza in New York' or 'shoe stores near robson street'. You can attach the SearchBox to a text field and, as text is entered, the service will return predictions in the form of a drop-down pick list.

SearchBox supplies an extended list of predictions, which can include places (as defined by the Places API) plus suggested search terms. For example, if the user enters 'pizza in new', the pick list may include the phrase 'pizza in New York, NY' as well as the names of various pizza outlets. When a user selects a place from the list, information about that place is returned to the SearchBox object, and can be retrieved by your application.

The SearchBox constructor takes two arguments:

  • An HTML input element of type text. This is the input field that the SearchBox service will monitor and attach its results to.
  • An options argument, which can contain the bounds property: bounds is a google.maps.LatLngBounds object specifying the area in which to search for places. The results are biased towards, but not restricted to, places contained within these bounds.

The following code uses the bounds parameter to bias the results towards places within a particular geographic area, specified via laitude/longitude coordinates.

var defaultBounds = new google.maps.LatLngBounds(
  new google.maps.LatLng(-33.8902, 151.1759),
  new google.maps.LatLng(-33.8474, 151.2631));

var input = document.getElementById('searchTextField');

var searchBox = new google.maps.places.SearchBox(input, {
  bounds: defaultBounds
});

Change the search area for SearchBox

To change the search area for an existing SearchBox, call setBounds() on the SearchBox object and pass the relevant LatLngBounds object.

View example (places-searchbox.html).

Get SearchBox information

When the user selects an item from the predictions attached to the search box, the service fires a places_changed event. You can call getPlaces() on the SearchBox object, to retrieve an array containing several predictions, each of which is a PlaceResult object.

For more information about the PlaceResult object, refer to the documentation on place detail results.

  // Listen for the event fired when the user selects an item from the
  // pick list. Retrieve the matching places for that item.
  google.maps.event.addListener(searchBox, 'places_changed', function() {
    var places = searchBox.getPlaces();

    for (var i = 0, marker; marker = markers[i]; i++) {
      marker.setMap(null);
    }

    // For each place, get the icon, place name, and location.
    markers = [];
    var bounds = new google.maps.LatLngBounds();
    for (var i = 0, place; place = places[i]; i++) {
      var image = {
        url: place.icon,
        size: new google.maps.Size(71, 71),
        origin: new google.maps.Point(0, 0),
        anchor: new google.maps.Point(17, 34),
        scaledSize: new google.maps.Size(25, 25)
      };

      // Create a marker for each place.
      var marker = new google.maps.Marker({
        map: map,
        icon: image,
        title: place.name,
        position: place.geometry.location
      });

      markers.push(marker);

      bounds.extend(place.geometry.location);
    }

    map.fitBounds(bounds);
  });

View example (places-searchbox.html).

Style the Autocomplete and SearchBox widgets

By default, the UI elements provided by Autocomplete and SearchBox are styled for inclusion on a Google map. You may want to adjust the styling to suit your own site. The following CSS classes are available. All classes listed below apply to both the Autocomplete and the SearchBox widgets.

A graphical illustration of the CSS classes for the Autocomplete and
      SearchBox widgets
CSS classes for Autocomplete and SearchBox widgets
CSS class Description
pac-container The visual element containing the list of predictions returned by the Place Autocomplete service. This list appears as a dropdown list below the Autocomplete or SearchBox widget.
pac-icon The icon displayed to the left of each item in the list of predictions.
pac-item An item in the list of predictions supplied by the Autocomplete or SearchBox widget.
pac-item:hover The item when the user hovers their mouse pointer over it.
pac-item-selected The item when the user selects it via the keyboard. Note: Selected items will be a member of this class and of the pac-item class.
pac-item-query A span inside a pac-item that is the main part of the prediction. For geographic locations, this contains a place name, like 'Sydney', or a street name and number, like '10 King Street'. For text-based searches such as 'pizza in New York', it contains the full text of the query. By default, the pac-item-query is colored black. If there is any additional text in the pac-item, it is outside pac-item-query and inherits its styling from pac-item. It is colored gray by default. The additional text is typically an address.
pac-matched The part of the returned prediction that matches the user’s input. By default, this matched text is highlighted in bold text. Note that the matched text may be anywhere within pac-item. It is not necessarily part of pac-item-query, and it could be partly within pac-item-query as well as partly in the remaining text in pac-item.

Retrieve predictions from the autocomplete service

To retrieve predictions programmatically, use the AutocompleteService class. AutocompleteService does not add any UI controls. Instead, it returns an array of prediction objects, each containing the text of the prediction, reference information, and details of how the result matches the user input. This is useful if you want more control over the user interface than is offered by the Autocomplete and SearchBox described above.

AutocompleteService exposes the following methods:

  • getPlacePredictions() returns place predictions. Note: A 'place' can be an establishment, geographic location, or prominent point of interest, as defined by the Places API.
  • getQueryPredictions() returns an extended list of predictions, which can include places (as defined by the Places API) plus suggested search terms. For example, if the user enters 'pizza in new', the pick list may include the phrase 'pizza in New York, NY' as well as the names of various pizza outlets.

Both of the above methods return an array of five prediction objects of the following form:

  • description is the matched prediction.
  • matched_substrings contains a set of substrings in the place's description that match elements in the user's input. This is useful for highlighting those substrings in your application. In many cases, the query will appear as a substring of the description field.
    • length is the length of the substring.
    • offset is the character offset, measured from the beginning of the description string, at which the matched substring appears.
  • terms is an array containing elements of the query. For a place, each element will typically make up a portion of the address.
    • offset is the character offset, measured from the beginning of the description string, at which the matched substring appears.
    • value is the matching term.

The example below executes a query prediction request for the phrase 'pizza near' and displays the result in a list.

// This example retrieves autocomplete predictions programmatically
// from the autocomplete service, and displays them as an HTML list.
// The predictions will include a mix of places (as defined by the
// Google Places API) and suggested search terms.

function initialize() {
  var service = new google.maps.places.AutocompleteService();
  service.getQueryPredictions({ input: 'pizza near' }, callback);
}

function callback(predictions, status) {
  if (status != google.maps.places.PlacesServiceStatus.OK) {
    alert(status);
    return;
  }

  var results = document.getElementById('results');

  for (var i = 0, prediction; prediction = predictions[i]; i++) {
    results.innerHTML += '<li>' + prediction.description + '</li>';
  }
}

google.maps.event.addDomListener(window, 'load', initialize);

View example (places-queryprediction.html).

Authentication required

You need to be signed in with Google+ to do that.

Signing you in...

Google Developers needs your permission to do that.