Google Maps SDK — what it is, Google Maps and API for development

What is Google Maps SDK?

Google Maps SDK is a comprehensive platform for developers providing tools for working with geographic data in applications. The platform includes several APIs: Maps SDK (map display), Routes API (routes), Places API (place search and geodata), and Geocoding API (address-to-coordinate conversion). Each SDK integrates separately and has its own billing model.

Unlike Apple MapKit, Google Maps SDK offers a broader set of data: information about 250 million places, real-time traffic, Street View panoramas, and Indoor Maps for buildings. According to Statista (2025), Google Maps Platform holds 75% of the mapping SDK market in mobile applications. The key advantage is a single API key for all Google Maps services and cross-platform integration (Android, iOS, web).

API Key and Security Setup

API key is a mandatory element for working with Google Maps SDK. The key is created in Google Cloud Console and tied to a specific project. For Android, you additionally need to specify the app SHA-1 certificate, for iOS — the Bundle Identifier. Google recommends restricting API key usage by IP addresses, HTTP referrers, or app packages to prevent unauthorized access.

Maps SDK for Android: Integration and Features

Maps SDK for Android is a library that displays interactive Google Maps inside an Android application via MapView or SupportMapFragment. The SDK supports: custom map styles, markers with info windows, polygons and polylines, traffic and transit layers, as well as touch events and gestures (zoom, rotation, tilt). Maps use OpenGL for rendering, delivering 60 FPS on modern devices.

Integration starts with adding the dependency in build.gradle and configuring the API key through AndroidManifest.xml. Google Maps SDK for Android requires Google Play Services on the device. If Google Play Services is missing (e.g., on Huawei devices without Google services), maps will not display. For such cases, Google recommends using alternative solutions or WebView with JavaScript Maps API.

// AndroidManifest.xml — API key metadata
// 
//     android:value="YOUR_API_KEY"/>

// Map fragment in Activity
class MapActivity : AppCompatActivity(),
    OnMapReadyCallback {

    private lateinit var map: GoogleMap

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_map)
        val mapFragment = supportFragmentManager
            .findFragmentById(R.id.map) as SupportMapFragment
        mapFragment.getMapAsync(this)
    }

    override fun onMapReady(googleMap: GoogleMap) {
        map = googleMap
        val sydney = LatLng(-33.8688, 151.2093)
        map.addMarker(MarkerOptions().position(sydney)
            .title("Sydney"))
        map.moveCamera(CameraUpdateFactory
            .newLatLngZoom(sydney, 12f))
    }
}

Google Maps SDK on Android supports Indoor Maps — displaying building floor plans (airports, shopping malls). Simply set map.isIndoorEnabled = true to enable it. The Traffic Layer shows real-time road congestion — data updates every 2-5 minutes. The Transit Layer displays public transport routes in supported cities.

Maps SDK for iOS: Setup and Usage

Maps SDK for iOS provides the same features as the Android version but adapted for the Apple platform. Integration is done via Swift Package Manager or CocoaPods. Maps SDK for iOS uses Google servers for map rendering but can work alongside Apple MapKit for native navigation. The SDK supports iOS 15 and above, as well as SwiftUI via UIViewRepresentable.

A specific feature of the iOS version is the mandatory Info.plist configuration with the API key and adding the URL scheme for Google Maps. Unlike Android, the iOS SDK does not require Google Play Services but does require the Google Maps app for some features (e.g., opening maps in navigation). For cross-platform projects, Google recommends a single API key per project, activated for both platforms.

import GoogleMaps

class MapViewController: UIViewController {

    override func viewDidLoad() {
        super.viewDidLoad()
        let camera = GMSCameraPosition.camera(
            withLatitude: 55.7558,
            longitude: 37.6173,
            zoom: 10
        )
        let mapView = GMSMapView.map(
            withFrame: view.frame,
            camera: camera
        )
        self.view = mapView

        let marker = GMSMarker()
        marker.position = CLLocationCoordinate2D(
            latitude: 55.7558,
            longitude: 37.6173
        )
        marker.title = "Moscow"
        marker.map = mapView
    }
}

On iOS, Google Maps SDK supports custom styles via a JSON file in Google Maps Styling format. Styles allow changing the colors of roads, water, parks, and buildings according to the app design. Also supported are Heatmap Layer for data density visualization, KML and GeoJSON for importing geographic data from external sources.

Places API: Place Search and Geocoding

Places API is a Google Maps Platform service for obtaining information about geographic places: addresses, coordinates, ratings, opening hours, photos, and reviews. Places API operates in two modes: Place Search (search by text or radius) and Place Details (detailed information about a specific place by Place ID). The SDK is available for Android, iOS, and as a REST API.

Places SDK for Android and iOS allows embedding address autocomplete (Place Autocomplete) directly into the app text fields. This is a key feature for delivery, taxi, and logistics apps — the user starts typing an address, and the SDK suggests options from the Google Maps database. Place Autocomplete reduces address input errors by 80% compared to manual entry. Places API billing: $2.83 per 1000 Place Details requests, Place Search — $4.71 per 1000.

// Search place by text on Android
val placesClient = Places.createClient(context)
val request = FindCurrentPlaceRequest.builder(
    listOf(Place.Field.NAME, Place.Field.ADDRESS)
).build()

placesClient.findCurrentPlace(request)
    .addOnSuccessListener { response ->
        for (placeLikelihood in response.placeLikelihoods) {
            Log.d("Places", "${placeLikelihood.place.name} - ${placeLikelihood.likelihood}")
        }
    }

Place Autocomplete

Geocoding API — reverse geocoding (coordinates to address) and forward geocoding (address to coordinates). Used to convert a user-entered address into coordinates for display on the map. Geocoding API is billed separately: $4.71 per 1000 requests. Google provides 200 free requests per day per account for testing.

Directions API: Route Building

Directions API is a service for calculating routes between two or more points considering the transport mode (car, walking, cycling, public transit). The API returns multiple alternative routes with distance, travel time, step-by-step instructions, and a polyline for drawing the route on the map. Directions API is available as a REST API and through client SDKs.

Extended functionality — Routes API (new API recommended by Google since 2024). Routes API offers improved routing with real-time traffic, eco-friendly routing, and predictive arrival time analysis. According to Google, Routes API calculates travel time 20% more accurately in urban conditions compared to the classic Directions API. Routes API is billed at $5.00 per 1000 requests.

// Route request via Routes API
val client = OkHttpClient()
val requestBody = """
    {
        "origin": {"location": {"latLng": {"latitude": 55.75, "longitude": 37.61}}},
        "destination": {"location": {"latLng": {"latitude": 55.79, "longitude": 37.79}}},
        "travelMode": "DRIVE",
        "routingPreference": "TRAFFIC_AWARE"
    }
""".trimIndent()

val request = Request.Builder()
    .url("https://routes.googleapis.com/directions/v2:computeRoutes")
    .header("X-Goog-Api-Key", apiKey)
    .header("Content-Type", "application/json")
    .post(requestBody.toRequestBody())
    .build()

client.newCall(request).enqueue(object : Callback {
    override fun onResponse(call: Call, response: Response) {
        Log.d("Route", response.body?.string() ?: "")
    }
})

Directions API supports up to 25 waypoints for a single route. Waypoints can be specified as coordinates or Place IDs. To optimize the order of points (traveling salesman problem), use the optimize:true parameter. Pricing: Directions API — $4.71 per 1000 requests (up to 10 points), each additional point adds 50% to the request cost.

Map Customization: Styles, Markers, and Info Windows

Google Maps SDK provides extensive customization options: changing the map color scheme via JSON styles, adding custom markers (including animated ones), info windows (InfoWindow) with custom content, and overlaying graphic layers (GroundOverlay, Circle, Polygon). Customization allows adapting the map to the app brand and improving user experience.

Map Styling is done via Google Maps Styling Wizard or a JSON file in Map Style format. You can change colors of roads (featureType: road), water (water), parks (poi.park), buildings (building), and other elements. For maps in dark theme apps, use a night style with dark background and muted colors. Google Maps supports up to 100 style rules in a single JSON file.

Clustering for Performance

Clustering — combining markers into clusters when there are a large number of points on the map. Google Maps SDK for Android and iOS includes a built-in clustering utility (com.google.maps.android:android-maps-utils). Clustering prevents map overcrowding with markers at zoom levels below a certain threshold. On zoom, the cluster automatically splits into individual markers. According to Google, clustering improves map performance by 40% with 1000+ markers.

Code Example: Map with Markers in Kotlin

A complete example of displaying a map with a custom marker, route polyline, and info window. The app shows a map of Moscow with a point of interest and a route to it from the city center. The code demonstrates the main Google Maps SDK features: adding a marker, drawing a polyline, moving the camera, and handling clicks.

class MapDemoActivity : AppCompatActivity(), OnMapReadyCallback {

    override fun onMapReady(map: GoogleMap) {
        val kremlin = LatLng(55.7513, 37.6189)
        val gorkyPark = LatLng(55.7311, 37.6116)

        map.addMarker(MarkerOptions()
            .position(kremlin)
            .title("Kremlin")
            .icon(BitmapDescriptorFactory.defaultMarker(
                BitmapDescriptorFactory.HUE_RED)))

        map.addPolyline(PolylineOptions()
            .add(kremlin, gorkyPark)
            .width(5f)
            .color(Color.parseColor("#2196F3")))

        map.moveCamera(CameraUpdateFactory
            .newLatLngZoom(kremlin, 13f))

        map.setOnInfoWindowClickListener { marker ->
            Toast.makeText(this,
                "${marker.title} clicked",
                Toast.LENGTH_SHORT).show()
        }
    }
}

Performance recommendations: use async marker loading via ClusterManager when there are more than 200 points, limit the number of visible polylines (Google recommends no more than 100 simultaneously), use Lite Mode for maps that do not require full functionality (scrolling without zoom changes). Lite Mode reduces memory consumption by 50% and speeds up map loading by 2 times.

Google Maps Platform Pricing and Limits

Google Maps Platform uses a pay-as-you-go model with a monthly free limit of $200 credit. Each API is billed separately: Maps SDK — $2.83 per 1000 map loads, Places API — $4.71 per 1000 requests, Directions API — $4.71 per 1000 routes. Routes API (recommended) — $5.00 per 1000 requests. The free $200 limit typically covers up to 70,000 map loads per month.

For high-traffic projects, Google offers discounts for volumes of 500,000+ requests per month. Google Maps SDK is not charged for displaying a basic map without interaction — the fee is only for map load. Each time a user opens a screen with a map, it counts as one load. Optimization: map tile caching reduces the number of loads on repeat openings.

Limits: 300 requests per minute for Places API (can be increased to 3000 via quota in Cloud Console). For Directions API — 100 requests per minute. Exceeding the limit returns the OVER_QUERY_LIMIT error. Google recommends using exponential backoff for retry requests. Usage monitoring is available in Google Cloud Console with up to 5 minutes delay.