Google Maps SDKs & Libraries: Reference & Installation (2026)

SDKs overview

Google Maps Platform offers official Software Development Kits (SDKs) designed to facilitate the integration of mapping functionalities across various platforms. These SDKs abstract much of the complexity involved in interacting directly with the Google Maps Platform APIs, providing developers with native components and high-level interfaces to embed maps, manage geographical data, and implement location-based features. The primary official SDKs support web applications via JavaScript, and native mobile applications on Android and iOS devices, ensuring optimized performance and user experience on each respective platform. These SDKs are maintained by Google and receive regular updates, ensuring compatibility with the latest platform features and security standards. Developers can find comprehensive documentation and guides for each SDK on the official Google Maps Platform documentation portal.

The choice of SDK depends on the target application environment:

• Maps JavaScript API: For web-based applications, enabling interactive maps, custom markers, and integration with other web technologies.
• Maps SDK for Android: For native Android applications, providing a customizable map object that can be added to Android fragments or views.
• Maps SDK for iOS: For native iOS applications, offering similar capabilities translated into Objective-C or Swift components for Apple devices.

Each SDK is tailored to its platform's specific design patterns and performance requirements, offering a consistent developer experience while leveraging native capabilities. For instance, the mobile SDKs often provide better performance and features like offline caching compared to web views embedded within mobile apps. The Google Maps Platform pricing model applies across all SDKs and APIs, based on usage beyond a monthly free credit.

Official SDKs by language

Google Maps Platform provides specific SDKs for different development environments, each optimized for its respective platform. These official SDKs simplify the process of embedding and interacting with Google Maps, allowing developers to focus on application-specific logic.

Beyond these primary SDKs, Google also provides client libraries for various server-side languages to interact with the broader Google Maps Platform web services, such as the Geocoding API or Places API. These client libraries abstract HTTP requests and JSON parsing, making it easier to consume these services:

• Java Client for Google Maps Services: Available for server-side Java applications.
• Python Client for Google Maps Services: Useful for Python backend development.
• Go Client for Google Maps Services: For applications written in Go.
• Node.js Client for Google Maps Services: For JavaScript environments outside the browser.

These client libraries can be found on the Google Maps Platform client libraries documentation, and support widely used web service APIs like Geocoding, Directions, and Places. For specific API details, the Geocoding API overview provides an example of a core service.

Installation

Installation methods vary depending on the chosen platform and SDK. Below are common installation approaches for the primary Google Maps SDKs.

Maps JavaScript API

For web applications, the Maps JavaScript API is typically loaded asynchronously. The recommended method is to use the @googlemaps/js-api-loader package or directly include a <script> tag in your HTML.

Using @googlemaps/js-api-loader (recommended for modern web development):

npm install @googlemaps/js-api-loader

import { Loader } from '@googlemaps/js-api-loader';

const loader = new Loader({
  apiKey: "YOUR_API_KEY",
  version: "weekly",
  libraries: ["places"]
});

loader.load().then(() => {
  const map = new google.maps.Map(document.getElementById("map"), {
    center: { lat: -34.397, lng: 150.644 },
    zoom: 8,
  });
}).catch(e => {
  console.error("Error loading Maps JavaScript API: ", e);
});

Direct HTML <script> tag:

<script async
    src="https://maps.googleapis.com/maps/api/js?key=YOUR_API_KEY&callback=initMap"
></script>

Replace YOUR_API_KEY with your actual API key, which can be generated and managed in the Google Cloud Console.

Maps SDK for Android

For Android applications, integrate the SDK using Gradle. Add the following dependencies to your module's build.gradle file:

dependencies {
    implementation 'com.google.android.gms:play-services-maps:18.2.0'
    // Use the latest version available
}

Ensure you also add your API key to your AndroidManifest.xml within the <application> tag:

<manifest ... >
    <application ... >
        <meta-data
            android:name="com.google.android.geo.API_KEY"
            android:value="YOUR_API_KEY" />
        <!-- Other metadata and activities -->
    </application>
</manifest>

For detailed setup instructions, refer to the Maps SDK for Android quickstart guide.

Maps SDK for iOS

For iOS applications, you can install the SDK using CocoaPods or Swift Package Manager.

Using CocoaPods:

Add the following to your Podfile:

pod 'GoogleMaps'
# If you are using the Places SDK as well, add:
pod 'GooglePlaces'

Then run pod install. After installation, add your API key to your AppDelegate.swift:

import GoogleMaps

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
  GMSServices.provideAPIKey("YOUR_API_KEY")
  return true
}

Using Swift Package Manager:

In Xcode, navigate to File > Add Packages... and enter https://github.com/googlemaps/ios-maps-sdk as the package URL. Select the GoogleMaps library. Then, add the API key as described for CocoaPods.

More information on iOS SDK setup is available in the Maps SDK for iOS documentation.

Server-side Client Libraries

For server-side interactions, such as with the Geocoding API or Places API, client library installation typically involves package managers:

• Python: pip install google-maps
• Java: Add as a Maven or Gradle dependency (e.g., com.google.maps:google-maps-services:0.21.0)
• Node.js: npm install @googlemaps/google-maps-services-js

Specific versions and setup details for these client libraries are available in their respective documentation sections.

Quickstart example

This quickstart demonstrates how to display a simple map centered on a specific location using the Maps JavaScript API. This example covers basic initialization and rendering of a map in a web browser.

<!DOCTYPE html>
<html>
  <head>
    <title>Simple Google Map</title>
    <meta name="viewport" content="initial-scale=1.0, user-scalable=no">
    <meta charset="utf-8">
    <style>
      /* Optional: Set the size of the map div. */
      #map {
        height: 100vh;
        width: 100%;
      }
    </style>
  </head>
  <body>
    <!-- The div where the map will be rendered -->
    <div id="map"></div>

    <script>
      // Initialize and add the map
      function initMap() {
        // The location of Sydney
        const sydney = { lat: -33.865, lng: 151.209 };
        // The map, centered at Sydney
        const map = new google.maps.Map(document.getElementById("map"), {
          zoom: 12,
          center: sydney,
        });
        // The marker, positioned at Sydney
        const marker = new google.maps.Marker({
          position: sydney,
          map: map,
        });
      }
    </script>

    <!-- Load the Maps JavaScript API -->
    <script async
        src="https://maps.googleapis.com/maps/api/js?key=YOUR_API_KEY&callback=initMap"
    ></script>
  </body>
</html>

To make this example functional:

1. Replace YOUR_API_KEY with a valid API key obtained from the Google Cloud Console. Ensure that the Maps JavaScript API is enabled for your project.
2. Save the code as an .html file and open it in a web browser.

This code will display a Google Map centered on Sydney, Australia, with a marker placed at its coordinates. This forms the foundational step for more complex map integrations, such as adding custom overlays, drawing shapes, or integrating with other Google Maps Platform services like the Places API. For further examples and advanced functionalities, consult the Maps JavaScript API examples section.

Community libraries

While Google provides robust official SDKs and client libraries, the developer community has also created a variety of open-source libraries that extend or simplify interactions with Google Maps Platform. These community-driven projects can offer specialized tools, UI components, or alternative approaches to common mapping tasks. However, it's important to note that community libraries may not offer the same level of official support, maintenance, or adherence to Google's terms of service as the official SDKs.

Examples of common types of community contributions include:

• React/Vue/Angular wrappers: Libraries that provide declarative components for integrating Google Maps into popular JavaScript frameworks, simplifying map management within single-page applications. Examples include react-google-maps or vue-google-maps.
• Utility libraries: Tools for advanced geometric calculations, clustering markers, or working with GeoJSON data more easily than the direct API.
• Styling tools: Libraries that offer expanded options for map styling and customization beyond what's directly available in the official API.

When considering community libraries, developers should evaluate factors such as:

• Active maintenance: Is the library regularly updated and supported by its creators?
• Community size: A larger community often means more support and contributions.
• Licensing: Ensure the library's license is compatible with your project.
• Documentation: Good documentation is essential for effective use and troubleshooting.

Always consult the official Google Maps Platform Terms of Service and consider the implications of using third-party code in your applications. While useful, community libraries are often best suited for specific use cases where the official SDKs require additional boilerplate or custom logic. For core functionalities, the official SDKs are generally the most reliable and performant choice.