Google Maps Timezone & Local Time Lookup: 14 Data Fields per Record

Each record from this Actor carries 14 output fields, including the IANA timezone, current local time, UTC offset, and daylight-saving information for any given coordinate. It is designed to complement existing geospatial datasets, allowing you to add critical time-based context where it's needed. You can provide either a single {lat, lng} coordinate via the 'location' input or an array of them using 'locations'. The actor calls TimeAPI's public documented v1 coordinate endpoint, and can be tried on Apify's free plan. This is for engineers and analysts needing to normalise time-sensitive data, schedule geographically distributed tasks, or enrich location-based reporting. It is not for anyone who needs country codes or full address components for a coordinate, which the records do not include.

Try it: open Google Maps Timezone & Local Time Lookup on Apify, sign in on the free plan and run the prefilled example.

Can you try Google Maps Timezone & Local Time Lookup before paying?

Yes. Apify's free plan includes $5.00 of prepaid usage every month and asks for no credit card. At $0.005 per result, that covers up to 1,000 results of Google Maps Timezone & Local Time Lookup a month, before run-start charges and platform usage.

Google Maps Timezone & Local Time Lookup was last updated on 2026-09-27. It is one of 1,729 Actors CrawlerBros publishes on Apify, which together have 754,756 lifetime public runs and an average rating of 4.63 out of 5 across 416 reviews.

What does it cost to run Google Maps Timezone & Local Time Lookup?

Each result costs $0.005 on Apify's free plan, which is $5.00 per 1,000 results. Starting a run is charged separately at $0.005 per GB of Actor memory. Apify also bills the platform usage each run consumes, at the rates of your Apify plan, on top of these charges.

On Apify's free plan, the charge is $5.00 per 1,000 results. The number of locations provided to the Actor via the 'locations' or 'location' input controls has the largest effect on your bill, as each successfully resolved coordinate counts as one result. To determine if this Actor meets your needs before incurring significant costs, start with a small batch of locations and review the output, leveraging the free tier's usage to understand its functionality.

How do you run Google Maps Timezone & Local Time Lookup from the API?

None of its 3 controls is strictly required, so the defaults below produce a valid run on their own. Every value in the payload below comes from the published schema's own prefills, which means you can paste it, swap the token, and get a real result.

Call the synchronous endpoint to start a run and receive dataset items in one request:

curl -X POST "https://api.apify.com/v2/acts/crawlerbros~google-maps-timezone/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"location":{"lat":40.7128,"lng":-74.006},"locations":[{"lat":40.7128,"lng":-74.006},{"lat":51.5074,"lng":-0.1278},{"lat":35.6762,"lng":139.6503},{"lat":-33.8688,"lng":151.2093}],"proxyConfiguration":{"useApifyProxy":false}}'

The same run from Python, using the official client:

from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")

run_input = {
  "location": {
    "lat": 40.7128,
    "lng": -74.006
  },
  "locations": [
    {
      "lat": 40.7128,
      "lng": -74.006
    },
    {
      "lat": 51.5074,
      "lng": -0.1278
    },
    {
      "lat": 35.6762,
      "lng": 139.6503
    },
    {
      "lat": -33.8688,
      "lng": 151.2093
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": False
  }
}

run = client.actor("crawlerbros~google-maps-timezone").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

And from Node.js:

import { ApifyClient } from 'apify-client'

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' })

const input = {
  "location": {
    "lat": 40.7128,
    "lng": -74.006
  },
  "locations": [
    {
      "lat": 40.7128,
      "lng": -74.006
    },
    {
      "lat": 51.5074,
      "lng": -0.1278
    },
    {
      "lat": 35.6762,
      "lng": 139.6503
    },
    {
      "lat": -33.8688,
      "lng": 151.2093
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}

const run = await client.actor('crawlerbros~google-maps-timezone').call(input)
const { items } = await client.dataset(run.defaultDatasetId).listItems()
console.log(items)

That endpoint blocks until the run completes. Fine while you are testing a handful of records, risky once a run takes minutes: a dropped connection loses the response even though the run itself finished. Switch to an asynchronous start with polling or a webhook before you schedule anything.

Which Google Maps Timezone & Local Time Lookup inputs matter, and which can you skip?

The Actor exposes three controls, none of which are required because it offers two ways to specify coordinates. The primary controls are 'location' for a single {lat, lng} pair, and 'locations' for an array of multiple coordinates. For a first run, most users should leave 'proxyConfiguration' at its default. Focus on providing valid 'lat' and 'lng' values within the appropriate ranges, as these directly determine the data you receive.

• location (object): A single {lat, lng} coordinate to resolve. Use either this or 'locations'.
• locations (array): Multiple {lat, lng} coordinates to resolve in one run.
• proxyConfiguration (object): Optional proxy. Not normally required; timeapi.io accepts direct datacenter requests.

What does Google Maps Timezone & Local Time Lookup return?

The returned records provide precise IANA timezone identifiers, current local wall-clock times, and UTC offsets, along with detailed daylight-saving information. This data is highly suitable for applications that require accurate time normalisation across different geographies. However, it conspicuously does not contain country codes or administrative divisions, which means you cannot directly use its output to sort events by country without combining it with another geocoding service.

• inputLocation - the original {lat, lng} you provided
• timezone - IANA zone name (e.g. America/New_York, Asia/Tokyo, Australia/Sydney)
• timezoneAbbreviation - short code when DST is in effect (e.g. EDT, BST)
• utcOffset - current offset formatted as +HH:MM / -HH:MM
• utcOffsetSeconds - current offset in seconds (positive east of UTC)
• currentLocalTime - wall-clock time at the coordinate, ISO 8601 (second resolution)
• currentUtcTime - equivalent UTC time, ISO 8601 with Z
• dayOfWeek - provider's ISO weekday enum when present
• unixTimestamp - provider's Unix timestamp in seconds when present
• isDaylightSavingTime - true when DST is currently active
• daylightSavings - an object containing inEffect and observed, and, when available, nextTransition, dstName, standardUtcOffset, standardUtcOffsetSeconds, dstOffsetSeconds, dstUtcOffsetSeconds, startsAt, and endsAt; optional values are omitted when the provider does not return valid data
• sourceUrl - the exact public timeapi.io coordinate endpoint used for this row
• scrapedAt - UTC timestamp of when the lookup was performed
• recordType - actor record discriminator (timezone)

These are the documented fields. Optional ones can be empty on a given record, so measure how often each field your deliverable depends on is populated across a real sample before automating the handoff.

How do you build the workflow end to end?

Open Google Maps Timezone & Local Time Lookup and work through these in order. Each step ends with something to check, so a bad configuration surfaces on a small run rather than a scheduled one.

1. Begin by identifying whether you need to resolve a single coordinate or a batch of locations. If it's a single coordinate, set the 'location' control with 'lat' and 'lng' values. For multiple, prepare an array of {lat, lng} objects for the 'locations' control.
2. Perform an initial run with a small, representative set of coordinates. Check the output for expected fields like 'timezone', 'currentLocalTime', and 'utcOffset' to ensure data quality and format meet your requirements.
3. Examine the 'isDaylightSavingTime' and 'daylightSavings' fields. These are crucial for accurate time-sensitive applications. Confirm they are populated as expected for your test coordinates.
4. If the initial run's output is satisfactory, scale up your input by adding more coordinates to the 'locations' array. For very large datasets, split them into multiple runs to manage potential provider rate limits.
5. Configure a schedule for your Actor if you need to monitor timezone information or local times for dynamic locations. For static locations, a single batch run is sufficient.
6. Implement post-processing logic to handle omitted fields. The Actor will omit fields when the provider does not return valid data, so your downstream systems should account for their absence rather than assuming null values.

How do you apply it? Three worked playbooks

These are Google Maps Timezone & Local Time Lookup's own documented use cases, each worked through as an operating pattern rather than a description.

Use case 1: Normalise business hours

Outcome: Combine with a places scraper to convert "9 AM - 5 PM" into UTC ranges.

Configure: Set the 'locations' control with the lat/lng coordinates of your target businesses. Ensure the input includes all relevant geographical points for which business hours need normalisation.

Working method: First, use a Google Maps places scraper to get business coordinates and their stated operating hours (e.g., '9 AM - 5 PM'). Then, pass these coordinates to this Actor. For each business, take the 'currentLocalTime' and 'utcOffsetSeconds' to calculate the start and end times in UTC, accounting for DST.

Deliverable: A dataset of business records, each enriched with currentLocalTime and utcOffsetSeconds data, allowing for consistent UTC-based scheduling and analysis.

Stop condition: Any output record where 'timezone' or 'utcOffset' is missing, indicating a failure to resolve the timezone for a critical business location.

Use case 2: Schedule outreach

Outcome: Only send notifications during local business hours per recipient.

Configure: Input a list of 'locations' corresponding to your recipients' geographical positions. Make sure each location has accurate 'lat' and 'lng' values.

Working method: For each recipient, run this Actor to obtain their 'currentLocalTime' and 'utcOffsetSeconds'. Use this information to determine their local business hours. Implement a scheduling logic that triggers notifications only when the recipient's local time falls within acceptable business hours.

Deliverable: A notification queue where each scheduled message is timestamped with the intended recipient's local delivery time, preventing out-of-hours outreach.

Stop condition: More than a small percentage of recipient locations fail to return a 'currentLocalTime' or 'utcOffset', preventing accurate local time determination.

Use case 3: Compliance & reporting

Outcome: Stamp events with the correct local time and DST flag.

Configure: Provide the 'locations' control with the coordinates where your events occur. This ensures each event can be accurately attributed to its specific timezone.

Working method: Whenever an event occurs at a specific lat/lng, pass that coordinate to this Actor. Use the returned 'currentLocalTime', 'timezone', and 'isDaylightSavingTime' to stamp the event. This ensures all compliance and reporting reflects the precise local context of the event, including DST adjustments.

Deliverable: An event log or database where each entry includes 'currentLocalTime', 'timezone', and 'isDaylightSavingTime', enabling geographically accurate auditing and reporting.

Stop condition: Event records are missing 'timezone' or 'isDaylightSavingTime', leading to non-compliant or ambiguous time reporting for critical events.

What breaks, and how do you design around it?

When running large batches, splitting inputs into smaller arrays is a good practice to manage provider rate limits, allowing you to run several hundred coordinates in a single run, then pause and resume. If you need country context, you must pair this Actor with another, such as the Google Maps Geocoding Scraper, which can provide country and address components for the same coordinates. Be aware that 'timezoneAbbreviation' might be missing if the upstream service does not provide it, so avoid making this field mission-critical in your data pipeline.

When should you not use Google Maps Timezone & Local Time Lookup?

This Actor is an excellent choice for resolving timezone information and local times from coordinates. However, it's not the right tool if your primary need is to obtain country codes, administrative regions, or full address components from latitude/longitude pairs. The output records do not include these fields; attempting to infer them would be unreliable. In such cases, a dedicated geocoding service like our Google Maps Geocoding Scraper would be more appropriate, as it is designed for bidirectional address-to-coordinate and coordinate-to-address conversions with detailed address components. Additionally, if you need to gather detailed business hours or popular times for physical locations, rather than just their timezone, you should consider Actors like the Google Maps Business Hours Scraper or the Google Maps Popular Times Scraper. Do not use this Actor if you expect an unlimited quota or an SLA for the underlying timeapi.io service, as it relies on a public, provider-controlled endpoint.

What should you check before trusting the output?

• Validate that 'timezone' is a non-empty string in the IANA format (e.g., 'America/New_York') for all expected records.
• Confirm that 'currentLocalTime' and 'currentUtcTime' are present and in ISO 8601 format, and that 'currentLocalTime' accurately reflects the 'utcOffset'.
• Check the 'utcOffsetSeconds' field for numeric consistency, particularly for fractional offsets (e.g., +05:45 should correctly translate to seconds).
• Monitor 'isDaylightSavingTime' and the nested 'daylightSavings' object to ensure DST status is correctly reported, especially for coordinates near DST transition dates.
• If 'timezoneAbbreviation' is critical for your use case, verify its presence. It may be omitted if the provider does not return a DST name when DST is active.
• For any missing or null daylightSavings sub-fields (like nextTransition), ensure your downstream application handles these gracefully, as they are omitted when not available from the provider.

None of this proves a record is correct. It gives a scheduled Google Maps Timezone & Local Time Lookup run defined points where it should stop instead of quietly passing bad data downstream.

Frequently asked questions

What is the cost to resolve a coordinate?

Each successfully resolved coordinate costs $0.005, or $5.00 per 1,000 results on the free plan. Apify's free plan offers $5.00 of monthly usage credit, which covers up to 1,000 results from this Actor before any run-start charges. This allows you to test the Actor and integrate it into your workflow with no upfront cost.

How many coordinates can I process in a single run?

The Actor accepts both a single 'location' or an array of 'locations' for batch processing. While there's no hard limit imposed by the Actor itself, processing very large batches (thousands of coordinates) in one go might be affected by provider rate limits. It is advisable to split extremely large datasets into multiple, smaller runs to ensure optimal throughput and reliability.

Does this Actor require an API key or proxies?

No, this Actor does not require a Google Maps API key or any other third-party credentials. It queries the public timeapi.io service directly over HTTP. While a 'proxyConfiguration' control is available, it is not typically needed; the Actor will attempt direct HTTP requests first and fall back to a hardcoded Apify US RESIDENTIAL proxy if the direct request fails.

Can I get country codes for my coordinates?

No, the output of this Actor specifically focuses on timezone and local time information. It does not include country codes, administrative regions, or other address components. If your use case requires country context for coordinates, you should use a dedicated geocoding Actor like the Google Maps Geocoding Scraper in conjunction with this Actor.

What happens if a coordinate is invalid or out of range?

The Actor performs input validation before making any network calls. If you provide out-of-range or non-numeric latitude/longitude values, the run will terminate with a clear error message. This prevents unnecessary network requests and helps ensure the integrity of your input data before processing.

Where to go next

When you are ready to run it, open Google Maps Timezone & Local Time Lookup on Apify; the free plan covers up to 1,000 results a month.

Start with the Google Maps Timezone & Local Time Lookup Actor page for the current input schema, pricing tier, and run history.

It is part of the Google Maps Scraping Suite, which puts every related Actor on one page with its price and run history.

Other Actors we maintain for related data:

• Google Maps Nearby Places: Find places near a coordinate.
• Google Maps Popular Times Scraper: Extract popular times busy-hours histograms and live busyness data from Google Maps places - all 7 days with hourly percentages, current busyness, and typical time spent.
• Google Maps Geocoding Scraper: Bidirectional geocoding via Google Maps: convert addresses to coordinates (forward) or coordinates to addresses (reverse).
• Google Maps Business Hours Scraper: Extract structured opening hours for all 7 days plus live open/closed status from any Google Maps place page.
• Google Maps Photos Scraper: Extract photos from any Google Maps place - carousel scraping with max-resolution URLs, contributor info, and category metadata.
• Google Maps Area Scanner: Comprehensive geographic area scanner that bypasses Google Maps' 120-place limit using grid-based systematic coverage.
• Google Maps MCP: Unified Apify MCP server for Google Maps.
• Google Maps Place List Scraper: Extract ranked places from Google's curated Top lists ('Top hotels in Paris', 'Best coffee in Brooklyn', 'Things to do in Tokyo') or any Google Maps list URL.

Related guides:

• Google Maps Nearby Places: Up to 1,000 Free Results a Month (2026)
• Google Maps Popular Times Scraper: Up to 1,000 Free Results a Month
• Google Maps Geocoding Scraper: 16 Data Fields per Record (2026)
• Google Maps Scraper: 49 Data Fields, Up to 1,000 Free Results/Month

Resources

• Actor documentation, input schema, and pricing: verified against the published Actor on 2026-10-07.

• Actor last updated by its maintainers on 2026-09-27.

• Run outcome figures cover the 30 day public window ending 2026-10-07.

• Google Maps Timezone & Local Time Lookup on Apify