> **Building with AI coding agents?** Install the authstack plugin with one command. This equips your agent with accurate Scalekit implementation patterns. > > **Recommended** (the `-y` flags skip prompts, so the command runs without an interactive terminal): > ```bash > npx -y @scalekit-inc/cli setup -y > ``` > > Global: > ```bash > npm install -g @scalekit-inc/cli > scalekit setup -y > ``` > > Supports Claude Code, Cursor, GitHub Copilot, Codex + skills for other Agent Skills-compatible agents in `~/.agents/skills`. > Skills: integrate-agentkit, implement-saaskit, add-mcp-oauth, implement-sso, implement-scim. > [Full setup guide](https://docs.scalekit.com/dev-kit/build-with-ai/) --- # Connect AI agents to Google Maps The Google Maps connector lets your AI agent act in each user's Google Maps account. Each user connects their own Google Maps API key once, and Scalekit sends it with every call, so your agent never handles credentials. It comes with 14 tools. **Authentication:** API Key **Categories:** Productivity, Search **Tools:** 14: 14 read, 0 write, 0 destructive **Users sign in with:** API key **Built by:** Scalekit connector **Try it:** [Playground in the Scalekit dashboard](https://app.scalekit.com/ws/signup?sk_intent=playground&provider=GOOGLEMAPS) ## Setup 1. ### Install the SDK **Node.js** ```bash npm install @scalekit-sdk/node dotenv ``` **Python** ```bash pip install scalekit-sdk-python python-dotenv ``` 2. ### Set your credentials Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**. ```sh title=".env" SCALEKIT_ENVIRONMENT_URL= SCALEKIT_CLIENT_ID= SCALEKIT_CLIENT_SECRET= ``` 3. ### Create the Google Maps connection In **AgentKit > Connections**, create a Google Maps connection. The name you give it is the `connection_name` your code passes. See [Configure connections](/agentkit/connections/). 4. ### Authorize a user and make your first call **Node.js** (`quickstart.mts`) ```typescript import { ScalekitClient } from '@scalekit-sdk/node' import 'dotenv/config' import { createInterface } from 'node:readline/promises' const scalekit = new ScalekitClient( process.env.SCALEKIT_ENVIRONMENT_URL, process.env.SCALEKIT_CLIENT_ID, process.env.SCALEKIT_CLIENT_SECRET, ) const actions = scalekit.actions const connector = 'googlemaps' const identifier = 'user_123' // Generate an authorization link for the user const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier }) console.log('Authorize Google Maps:', link) const rl = createInterface({ input: process.stdin, output: process.stdout }) await rl.question('Press Enter after authorizing...') rl.close() // Make your first call const result = await actions.executeTool({ connector, identifier, toolName: 'googlemaps_geolocate', toolInput: {}, }) console.log(result) ``` ```bash npx tsx quickstart.mts ``` **Python** (`quickstart.py`) ```python import os from scalekit import ScalekitClient from dotenv import load_dotenv load_dotenv() scalekit_client = ScalekitClient( env_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"), client_id=os.getenv("SCALEKIT_CLIENT_ID"), client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"), ) actions = scalekit_client.actions connection_name = "googlemaps" identifier = "user_123" # Generate an authorization link for the user link_response = actions.get_authorization_link( connection_name=connection_name, identifier=identifier, ) print("Authorize Google Maps:", link_response.link) input("Press Enter after authorizing...") # Make your first call result = actions.execute_tool( tool_input={}, tool_name="googlemaps_geolocate", connection_name=connection_name, identifier=identifier, ) print(result) ``` ```bash python quickstart.py ``` Each user opens the link once and enters their Google Maps credentials there. See [Authorize a user](/agentkit/tools/authorize/) for the full flow and statuses. ## Tools Pass the exact name to `execute_tool`, with an input like each tool's example. To ask for a tool that's missing, use the [request form](https://scalekitsupport.portal.usepylon.com/forms/request-a-connector-tool). **Node.js** ```typescript const result = await actions.executeTool({ toolName: 'googlemaps_address_validate', toolInput: { address_lines: [], }, connector: 'googlemaps', identifier: 'user_123', }) ``` **Python** ```python result = actions.execute_tool( tool_name="googlemaps_address_validate", tool_input={ "address_lines": [], }, connection_name="googlemaps", identifier="user_123", ) ``` `result.data` is the app's response as JSON, and `result.execution_id` (`executionId` in Node.js) is the ID of the call. ### `googlemaps_address_validate` Validate Address · Read-only Check and standardise a postal address, filling in missing parts and flagging components that look wrong. Returns a verdict (validation granularity, whether it's complete and whether parts were inferred or replaced), the corrected address, geocode, and USPS data for US addresses when requested, plus a responseId. Use this to verify a mailing or delivery address. Use geocode_address when you only need coordinates. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `address_lines` (`array`, required): The unstructured address lines, for example ["1600 Amphitheatre Pkwy", "Mountain View, CA 94043"]. You can put the whole address in one line. All address inputs together must be at most 280 characters. - `administrative_area` (`string`, optional): State, province or region, if not already in address_lines. Example: CA. - `enable_usps_cass` (`boolean`, optional): If true, also run USPS CASS validation (US and Puerto Rico addresses only); region_code must be US or PR. Defaults to false. - `locality` (`string`, optional): City or town, if not already in address_lines. Example: Mountain View. - `postal_code` (`string`, optional): Postal or ZIP code, if not already in address_lines. Example: 94043. - `previous_response_id` (`string`, optional): The responseId from a previous validation of the same address, when re-validating after the user edits it. Leave empty for a new address. - `region_code` (`string`, optional): Two-letter CLDR region code of the address, such as US or GB. Strongly recommended; if omitted Google infers it from the address lines. - `session_token` (`string`, optional): Autocomplete session token to end an autocomplete session with this validation for billing. URL-safe base64, at most 36 characters. Example input: `{"address_lines":[]}` ### `googlemaps_geocode_address` Geocode Address · Read-only Convert a street address or place description into latitude and longitude. Returns matching results with location, formatted address, place ID, address components, granularity, viewport and types. Use this for address to coordinates. Use geocode_location for coordinates to address. Use places_search_text to find businesses. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `address_query` (`string`, required): The address to geocode, as unstructured text. Include city and country when you can. Example: "1600 Amphitheatre Parkway, Mountain View, CA". - `field_mask` (`string`, optional): Comma-separated list of response fields to return, sent as the X-Goog-FieldMask header. Optional. Leave empty to get every field. Google bills by the most expensive field requested. Optional; leave empty to get every field. Example: results.location,results.formattedAddress,results.placeId. Use "*" only for testing. - `language_code` (`string`, optional): Preferred language for formatted addresses in the response, as a BCP-47 code such as en, fr or ja. - `region_code` (`string`, optional): Two-letter ccTLD region code that biases (but does not restrict) results, such as us or gb. Useful for ambiguous names like "Toledo". Example input: `{"address_query":"1600 Amphitheatre Parkway, Mountain View, CA"}` ### `googlemaps_geocode_location` Reverse Geocode Location · Read-only Convert a latitude and longitude into human-readable addresses (reverse geocoding). Returns results from most to least specific, each with formatted address, place ID, address components, granularity and types. Use this for coordinates to address. Use geocode_address for address to coordinates. Use places_search_nearby to find businesses near a point. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `latitude` (`number`, required): Latitude in decimal degrees. Example: 40.714224. - `longitude` (`number`, required): Longitude in decimal degrees. Example: -73.961452. - `field_mask` (`string`, optional): Comma-separated list of response fields to return, sent as the X-Goog-FieldMask header. Optional. Leave empty to get every field. Google bills by the most expensive field requested. Optional; leave empty to get every field. Example: results.location,results.formattedAddress,results.placeId. Use "*" only for testing. - `granularity` (`array`, optional): Keep only results with these location precisions: ROOFTOP (exact plot), RANGE_INTERPOLATED (estimated along a street), GEOMETRIC_CENTER (centre of an area), APPROXIMATE. - `language_code` (`string`, optional): Preferred language for formatted addresses in the response, as a BCP-47 code such as en, fr or ja. - `region_code` (`string`, optional): Two-letter CLDR/ccTLD region code that sets regional formatting and preferences, such as us, gb or in. - `types` (`array`, optional): Keep only results with at least one of these place types, for example ["street_address"] or ["locality", "postal_code"]. Example input: `{"latitude":40.714224,"longitude":-73.961452}` ### `googlemaps_geocode_place` Geocode Place ID · Read-only Look up the address and coordinates for a Google place ID. Returns a geocode result with location, formatted address, address components, viewport, bounds and types. Use this to turn a place ID into an address and coordinates. Use places_get for richer business details such as hours and ratings. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `place_id` (`string`, required): The Google place ID to geocode. Example: ChIJj61dQgK6j4AR4GeTYWZsKWw. - `field_mask` (`string`, optional): Comma-separated list of response fields to return, sent as the X-Goog-FieldMask header. Optional. Leave empty to get every field. Google bills by the most expensive field requested. Optional; leave empty to get every field. Example: location,formattedAddress. Use "*" only for testing. - `language_code` (`string`, optional): Preferred language for formatted addresses in the response, as a BCP-47 code such as en, fr or ja. - `region_code` (`string`, optional): Two-letter CLDR/ccTLD region code that sets regional formatting and preferences, such as us, gb or in. Example input: `{"place_id":""}` ### `googlemaps_geolocate` Geolocate Device · Read-only Estimate a device's location from nearby cell towers and Wi-Fi access points, falling back to the caller's IP address. Returns location (lat, lng) and accuracy in meters. Use this when you have radio signal data instead of coordinates. Note that without towers or access points the result is the location of the server calling Google, not the end user. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `carrier` (`string`, optional): Name of the mobile carrier. - `cell_towers` (`array`, optional): Cell towers the device can see. Each tower needs its cellId, locationAreaCode, mobileCountryCode and mobileNetworkCode (NR towers use newRadioCellId instead of cellId); signal strength and age are optional. Example: [{"cellId": 170402199, "locationAreaCode": 35632, "mobileCountryCode": 310, "mobileNetworkCode": 410}]. - `consider_ip` (`boolean`, optional): If true (default), fall back to the IP address of the request when tower and Wi-Fi data are missing or insufficient. Since Scalekit sends the request, that IP is not the end user's; set false to get a not-found error instead of a misleading location. - `home_mobile_country_code` (`integer`, optional): Mobile country code (MCC) of the device's home network, 0 to 999. - `home_mobile_network_code` (`integer`, optional): Mobile network code (MNC) of the device's home network, or SID for CDMA. - `radio_type` (`string`, optional): Mobile radio type of the cell towers: gsm (default), cdma, wcdma, lte or nr. One of: `gsm`, `cdma`, `wcdma`, `lte`, `nr`. - `wifi_access_points` (`array`, optional): Wi-Fi access points the device can see; give at least two. Each needs a macAddress and can include signalStrength (dBm), channel and age. Example: [{"macAddress": "3c:37:86:5d:75:d4", "signalStrength": -35}, {"macAddress": "30:86:2d:c4:29:d0", "signalStrength": -35}]. Example input: `{}` ### `googlemaps_places_autocomplete` Autocomplete Places · Read-only Get place and query suggestions for partial text as a user types, such as "pizza in new y". Returns up to five suggestions, each a place prediction (place ID, text, types, and distance if an origin is given) or a query prediction. Use this for type-ahead input. Use places_search_text for full search results. Pass a chosen place ID to places_get with the same session_token. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `input` (`string`, required): The partial text to complete, as typed so far. Example: "pizza in new y". - `field_mask` (`string`, optional): Comma-separated list of response fields to return, sent as the X-Goog-FieldMask header. Optional. Leave empty to get every field. Google bills by the most expensive field requested. Example: suggestions.placePrediction.placeId,suggestions.placePrediction.text. Use "*" only for testing. - `include_query_predictions` (`boolean`, optional): If true, the response can include query predictions (suggested search strings) as well as place predictions. Defaults to false. - `included_primary_types` (`array`, optional): Up to five primary place types to restrict suggestions to, for example ["restaurant"], or one of the collections (regions) or (cities). - `included_region_codes` (`array`, optional): Up to 15 two-letter region codes to restrict results to, for example ["us", "ca"]. - `input_offset` (`integer`, optional): Zero-based Unicode character offset of the cursor in input. Defaults to the length of input. - `language_code` (`string`, optional): Preferred language for suggestions in the response, as a BCP-47 code such as en, fr or ja. - `location_bias_latitude` (`number`, optional): Latitude in decimal degrees of the centre of a circle that results should favour. Set together with location_bias_longitude; results outside the circle can still appear. - `location_bias_longitude` (`number`, optional): Longitude in decimal degrees of the centre of the bias circle. Set together with location_bias_latitude. - `location_bias_radius_meters` (`number`, optional): Radius in meters of the bias circle, from 0 to 50000. Used only when location_bias_latitude and location_bias_longitude are set. - `origin_latitude` (`number`, optional): Latitude of the origin used to calculate distanceMeters for each prediction. Set together with origin_longitude. - `origin_longitude` (`number`, optional): Longitude of the origin used to calculate distanceMeters for each prediction. Set together with origin_latitude. - `region_code` (`string`, optional): Two-letter CLDR/ccTLD region code that sets regional formatting and preferences, such as us, gb or in. - `session_token` (`string`, optional): Session token that groups autocomplete calls and the final places_get call into one billing session. Use a URL-safe base64 string of at most 36 characters, such as a UUID, and reuse it until a place is selected. Example input: `{"input":"pizza in new y"}` ### `googlemaps_places_get` Get Place Details · Read-only Get details for one place by its Google place ID, such as address, phone, website, opening hours, rating, price level and photos. Returns a place object with the fields named in field_mask. Use this when you already have a place ID. Use places_search_text or places_search_nearby to find place IDs. Use geocode_place for just the address and coordinates. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `place_id` (`string`, required): The Google place ID, as returned in the id field of a search or autocomplete result. Example: ChIJj61dQgK6j4AR4GeTYWZsKWw. - `field_mask` (`string`, optional): Comma-separated list of response fields to return, sent as the X-Goog-FieldMask header. Google requires a field mask for this method and bills by the most expensive field requested. Use top-level place field names without a prefix, e.g. id,displayName,formattedAddress,regularOpeningHours. Add photos to get photo names for places_photo_get. Use "*" only for testing. Default: `id,displayName,formattedAddress,location,types,primaryType,rating,userRatingCount,priceLevel,businessStatus,googleMapsUri,websiteUri,nationalPhoneNumber,internationalPhoneNumber,regularOpeningHours,editorialSummary,photos`. - `language_code` (`string`, optional): Preferred language for names and addresses in the response, as a BCP-47 code such as en, fr or ja. - `region_code` (`string`, optional): Two-letter CLDR/ccTLD region code that sets regional formatting and preferences, such as us, gb or in. - `session_token` (`string`, optional): Autocomplete session token. Pass the same token used in the places_autocomplete calls that led to this place to close the session for billing. Must be URL- and filename-safe base64, at most 36 characters. Example input: `{"place_id":""}` ### `googlemaps_places_photo_get` Get Place Photo URL · Read-only Get a short-lived image URL for one photo of a place, scaled to a maximum width or height. Returns the photo resource name and photoUri, a direct link to the image. Use this after places_get or a search with photos in field_mask. Each photo's name has the form places/PLACE_ID/photos/PHOTO_ID. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `photo_id` (`string`, required): The photo ID part of the photo's resource name places/PLACE_ID/photos/PHOTO_ID, taken from the photos[].name field of a place. It's a long opaque string. - `place_id` (`string`, required): The place ID part of the photo's resource name places/PLACE_ID/photos/PHOTO_ID. Example: ChIJj61dQgK6j4AR4GeTYWZsKWw. - `max_height_px` (`integer`, optional): Maximum image height in pixels, from 1 to 4800. The image is scaled down to fit, keeping its aspect ratio. - `max_width_px` (`integer`, optional): Maximum image width in pixels, from 1 to 4800. The image is scaled down to fit, keeping its aspect ratio. Defaults to 800. Default: `800`. Example input: `{"photo_id":"","place_id":""}` ### `googlemaps_places_search_nearby` Search Nearby Places · Read-only Find places of given types inside a circle around a latitude and longitude, such as cafes within 500 meters of a point. Returns up to 20 places with the fields named in field_mask (by default id, name, address, location, types, rating and Maps link). There is no pagination. Use this when you have a coordinate and want places by type. Use places_search_text for a query in words. Use places_get for one known place. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `latitude` (`number`, required): Latitude in decimal degrees of the centre of the search circle. Example: 37.7937. - `longitude` (`number`, required): Longitude in decimal degrees of the centre of the search circle. Example: -122.3965. - `radius_meters` (`number`, required): Radius of the search circle in meters, greater than 0 and at most 50000. Only places inside the circle are returned. - `excluded_primary_types` (`array`, optional): Primary place types to exclude (up to 50). Example: ["gas_station"]. - `excluded_types` (`array`, optional): Place types to exclude (up to 50), for example ["fast_food_restaurant"]. - `field_mask` (`string`, optional): Comma-separated list of response fields to return, sent as the X-Goog-FieldMask header. Google requires a field mask for this method and bills by the most expensive field requested. Prefix place fields with "places.", e.g. places.id,places.displayName,places.formattedAddress. Use "*" only for testing. Default: `places.id,places.displayName,places.formattedAddress,places.location,places.types,places.primaryType,places.rating,places.userRatingCount,places.googleMapsUri`. - `included_primary_types` (`array`, optional): Primary place types to include (up to 50). Unlike included_types, a place matches only if its primary type is one of these. Example: ["italian_restaurant"]. - `included_types` (`array`, optional): Place types to include, from Google's Places (New) type table (up to 50), for example ["restaurant", "cafe"]. A place matches if it has any of these types. - `language_code` (`string`, optional): Preferred language for names and addresses in the response, as a BCP-47 code such as en, fr or ja. - `max_result_count` (`integer`, optional): Maximum number of places to return, from 1 to 20. Defaults to 20. - `rank_preference` (`string`, optional): How to order results: POPULARITY (default) or DISTANCE (nearest first). One of: `POPULARITY`, `DISTANCE`. - `region_code` (`string`, optional): Two-letter CLDR/ccTLD region code that sets regional formatting and preferences, such as us, gb or in. Example input: `{"latitude":37.7937,"longitude":-122.3965,"radius_meters":1}` ### `googlemaps_places_search_text` Search Places by Text · Read-only Search Google Maps for places that match a free-text query such as "pizza in New York" or "museums near Golden Gate Park". Returns up to 20 places per page with the fields named in field_mask (by default id, name, address, location, types, rating and Maps link), plus nextPageToken when more results exist. Use this for a query in words. Use places_search_nearby for places of given types around a coordinate. Use places_autocomplete for as-you-type suggestions. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `text_query` (`string`, required): The free-text search, as a person would type it into Google Maps. Can include a business name, category and place. Example: "vegetarian restaurants in Austin, TX". - `field_mask` (`string`, optional): Comma-separated list of response fields to return, sent as the X-Goog-FieldMask header. Google requires a field mask and bills by the most expensive field requested. Prefix place fields with "places." and add nextPageToken to get pagination tokens. Use "*" only for testing. Example: places.id,places.displayName,places.formattedAddress,nextPageToken. Default: `places.id,places.displayName,places.formattedAddress,places.location,places.types,places.primaryType,places.rating,places.userRatingCount,places.googleMapsUri,nextPageToken`. - `include_pure_service_area_businesses` (`boolean`, optional): If true, also return businesses that visit or deliver to customers and have no physical storefront (for example plumbers or cleaners). These results have no address or location fields. Defaults to false. - `included_type` (`string`, optional): Restrict results to one place type from Google's Places (New) type table, for example restaurant, cafe, lodging or gas_station. Only one type is supported. - `language_code` (`string`, optional): Preferred language for names and addresses in the results, as a BCP-47 code such as en, fr or ja. Unsupported codes fall back to English. - `location_bias_latitude` (`number`, optional): Latitude in decimal degrees of the centre of a circle that results should favour. Set together with location_bias_longitude and location_bias_radius_meters; results outside the circle can still appear. - `location_bias_longitude` (`number`, optional): Longitude in decimal degrees of the centre of the bias circle. Set together with location_bias_latitude and location_bias_radius_meters. - `location_bias_radius_meters` (`number`, optional): Radius in meters of the bias circle, from 0 to 50000. Used only when location_bias_latitude and location_bias_longitude are also set. - `min_rating` (`number`, optional): Exclude places whose average user rating is below this value. Valid values are 0 to 5 in steps of 0.5; other values round up to the next 0.5. - `open_now` (`boolean`, optional): If true, return only places that are open at the time of the request. Defaults to false. - `page_size` (`integer`, optional): Maximum number of places to return on this page, from 1 to 20. Defaults to 20. - `page_token` (`string`, optional): The nextPageToken from a previous response, to fetch the next page. Every other input must match the original request. Include nextPageToken in field_mask to receive it. - `price_levels` (`array`, optional): Restrict results to these price levels. Valid values: PRICE_LEVEL_INEXPENSIVE, PRICE_LEVEL_MODERATE, PRICE_LEVEL_EXPENSIVE, PRICE_LEVEL_VERY_EXPENSIVE. Example: ["PRICE_LEVEL_INEXPENSIVE", "PRICE_LEVEL_MODERATE"]. - `rank_preference` (`string`, optional): How to order results: RELEVANCE (default for most queries) or DISTANCE (nearest first, best with a location bias). One of: `RELEVANCE`, `DISTANCE`. - `region_code` (`string`, optional): Two-letter CLDR region code of where the request comes from, such as us or gb. Affects address formatting and region-specific results. - `strict_type_filtering` (`boolean`, optional): If true, return only places whose type matches included_type exactly. Defaults to false, where included_type only biases results. Example input: `{"text_query":"vegetarian restaurants in Austin, TX"}` ### `googlemaps_roads_nearest_roads` Find Nearest Roads · Read-only Find the nearest road segment for each of up to 100 independent GPS points. Returns snappedPoints with the road location, placeId of the road segment and originalIndex of the input point. Use this for unrelated points. Use roads_snap_to_roads for an ordered path along a trip. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `points` (`string`, required): The points to look up, as latitude,longitude pairs separated by |, up to 100. Example: 60.170880,24.942795|60.170879,24.942796. Example input: `{"points":""}` ### `googlemaps_roads_snap_to_roads` Snap Points to Roads · Read-only Snap a GPS trace of up to 100 points to the roads the vehicle most likely travelled. Returns snappedPoints, each with location, placeId of the road segment, and originalIndex of the input point, plus any warningMessage. Use this for an ordered path of points along a trip. Use roads_nearest_roads for independent points that aren't a path. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `path` (`string`, required): The ordered GPS points to snap, as latitude,longitude pairs separated by |, up to 100 points. Consecutive points should be within about 300 meters for good results. Example: -35.27801,149.12958|-35.28032,149.12907|-35.28099,149.12929. - `interpolate` (`boolean`, optional): If true, add extra points so the result follows the road's geometry smoothly. Defaults to false. Example input: `{"path":""}` ### `googlemaps_routes_compute` Compute Route · Read-only Compute directions between an origin and a destination, with optional stops, travel mode, traffic awareness and toll, highway or ferry avoidance. Returns one or more routes with the fields named in field_mask (by default duration, distance, an encoded polyline, and turn-by-turn steps per leg). Use this for one origin and destination. Use routes_compute_matrix for travel times between many origins and destinations. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `destination` (`string`, required): Where the route ends. Same formats as origin. - `origin` (`string`, required): Where the route starts. Each point can be a street address or place name ("1600 Amphitheatre Pkwy, Mountain View, CA"), a "latitude,longitude" pair ("37.4220,-122.0841"), or a Google place ID prefixed with place_id: ("place_id:ChIJj61dQgK6j4AR4GeTYWZsKWw"). - `arrival_time` (`string`, optional): Desired arrival time as an RFC 3339 UTC timestamp, TRANSIT only. Can't be combined with departure_time. - `avoid_ferries` (`boolean`, optional): If true, avoid ferries where reasonable. DRIVE and TWO_WHEELER only. - `avoid_highways` (`boolean`, optional): If true, avoid highways where reasonable. DRIVE and TWO_WHEELER only. - `avoid_tolls` (`boolean`, optional): If true, avoid toll roads where reasonable. DRIVE and TWO_WHEELER only. - `compute_alternative_routes` (`boolean`, optional): If true, also return up to two alternative routes. Not available with intermediate stops. Defaults to false. - `departure_time` (`string`, optional): Departure time as an RFC 3339 UTC timestamp, for example 2026-11-02T15:00:00Z. Must be now or in the future (past times work only for TRANSIT). Defaults to now. - `field_mask` (`string`, optional): Comma-separated list of response fields to return, sent as the X-Goog-FieldMask header. Google requires a field mask for this method and bills by the most expensive field requested. Prefix fields with "routes.", e.g. routes.duration,routes.distanceMeters,routes.polyline.encodedPolyline. Use "*" only for testing. Default: `routes.duration,routes.staticDuration,routes.distanceMeters,routes.description,routes.localizedValues,routes.warnings,routes.polyline.encodedPolyline,routes.legs.duration,routes.legs.distanceMeters,routes.legs.steps.distanceMeters,routes.legs.steps.navigationInstruction,routes.optimizedIntermediateWaypointIndex`. - `intermediates` (`array`, optional): Stops between origin and destination, in order (up to 25). Same formats as origin. Example: ["Palo Alto, CA", "37.5,-122.2"]. - `language_code` (`string`, optional): Preferred language for instructions and localized values in the response, as a BCP-47 code such as en, fr or ja. - `optimize_waypoint_order` (`boolean`, optional): If true, reorder intermediates to minimise total travel time; the new order is in routes.optimizedIntermediateWaypointIndex. Not allowed with TRAFFIC_AWARE_OPTIMAL. Defaults to false. - `region_code` (`string`, optional): Two-letter CLDR/ccTLD region code that sets regional formatting and preferences, such as us, gb or in. - `routing_preference` (`string`, optional): Traffic handling, for DRIVE and TWO_WHEELER only: TRAFFIC_UNAWARE (fastest to compute, default), TRAFFIC_AWARE, or TRAFFIC_AWARE_OPTIMAL (best quality, slowest). Leave empty for other travel modes or the request fails. One of: `TRAFFIC_UNAWARE`, `TRAFFIC_AWARE`, `TRAFFIC_AWARE_OPTIMAL`. - `travel_mode` (`string`, optional): How to travel: DRIVE (default), BICYCLE, WALK, TWO_WHEELER or TRANSIT. One of: `DRIVE`, `BICYCLE`, `WALK`, `TWO_WHEELER`, `TRANSIT`. - `units` (`string`, optional): Units for localized distances in the response: METRIC or IMPERIAL. Defaults from the origin's locale. distanceMeters is always in meters. One of: `METRIC`, `IMPERIAL`. Example input: `{"destination":"","origin":""}` ### `googlemaps_routes_compute_matrix` Compute Route Matrix · Read-only Compute travel time and distance for every pair of origins and destinations, such as from three warehouses to ten customers. Returns one element per origin-destination pair with originIndex, destinationIndex, status, condition, distanceMeters and duration. Use this to compare many trips at once. Use routes_compute for the path and turn-by-turn steps of a single trip. Read only: yes. Destructive: no. Idempotent (safe to retry): yes. Inputs: - `destinations` (`array`, required): End points, in the same formats as origins. - `origins` (`array`, required): Start points. Each point can be a street address or place name ("1600 Amphitheatre Pkwy, Mountain View, CA"), a "latitude,longitude" pair ("37.4220,-122.0841"), or a Google place ID prefixed with place_id: ("place_id:ChIJj61dQgK6j4AR4GeTYWZsKWw"). Origins times destinations must be at most 625 (100 with TRAFFIC_AWARE_OPTIMAL or TRANSIT), and at most 50 points in total may be addresses or place IDs. - `arrival_time` (`string`, optional): Desired arrival time as an RFC 3339 UTC timestamp, TRANSIT only. Can't be combined with departure_time. - `avoid_ferries` (`boolean`, optional): If true, avoid ferries where reasonable. DRIVE and TWO_WHEELER only. - `avoid_highways` (`boolean`, optional): If true, avoid highways where reasonable. DRIVE and TWO_WHEELER only. - `avoid_tolls` (`boolean`, optional): If true, avoid toll roads where reasonable. DRIVE and TWO_WHEELER only. - `departure_time` (`string`, optional): Departure time as an RFC 3339 UTC timestamp, for example 2026-11-02T15:00:00Z. Must be now or in the future (past times work only for TRANSIT). Defaults to now. - `field_mask` (`string`, optional): Comma-separated list of response fields to return, sent as the X-Goog-FieldMask header. Google requires a field mask for this method and bills by the most expensive field requested. Always include status, otherwise failed elements look like successes. Example: originIndex,destinationIndex,status,condition,distanceMeters,duration. Use "*" only for testing. Default: `originIndex,destinationIndex,status,condition,distanceMeters,duration,localizedValues`. - `language_code` (`string`, optional): Preferred language for instructions and localized values in the response, as a BCP-47 code such as en, fr or ja. - `region_code` (`string`, optional): Two-letter CLDR/ccTLD region code that sets regional formatting and preferences, such as us, gb or in. - `routing_preference` (`string`, optional): Traffic handling, for DRIVE and TWO_WHEELER only: TRAFFIC_UNAWARE (fastest to compute, default), TRAFFIC_AWARE, or TRAFFIC_AWARE_OPTIMAL (best quality, slowest). Leave empty for other travel modes or the request fails. One of: `TRAFFIC_UNAWARE`, `TRAFFIC_AWARE`, `TRAFFIC_AWARE_OPTIMAL`. - `travel_mode` (`string`, optional): How to travel: DRIVE (default), BICYCLE, WALK, TWO_WHEELER or TRANSIT. One of: `DRIVE`, `BICYCLE`, `WALK`, `TWO_WHEELER`, `TRANSIT`. - `units` (`string`, optional): Units for localized distances in the response: METRIC or IMPERIAL. Defaults from the origin's locale. distanceMeters is always in meters. One of: `METRIC`, `IMPERIAL`. Example input: `{"destinations":[],"origins":[]}` ## Related Other Productivity connectors ([all 144](/agentkit/connectors/?category=productivity)): - [Slack](/agentkit/connectors/slack/): Scalekit connector, OAuth, 96 tools - [Microsoft 365](/agentkit/connectors/microsoft365/): Scalekit connector, OAuth, 317 tools - [Notion](/agentkit/connectors/notion/): Scalekit connector, OAuth, 51 tools --- ## More Scalekit documentation | Resource | What it contains | When to use it | |----------|-----------------|----------------| | [/llms.txt](/llms.txt) | Structured index with routing hints per product area | Start here — find which documentation set covers your topic before loading full content | | [/llms-full.txt](/llms-full.txt) | Complete documentation for all Scalekit products in one file | Use when you need exhaustive context across multiple products or when the topic spans several areas | | [sitemap-0.xml](https://docs.scalekit.com/sitemap-0.xml) | Full URL list of every documentation page | Use to discover specific page URLs you can fetch for targeted, page-level answers |