OVER_QUERY_LIMIT in Google Geocoding: What It Means and How to Fix It

OVER_QUERY_LIMIT means your Google Cloud project sent more geocoding requests per minute than allowed (3,000 QPM for Geocoding) or hit a quota or billing limit. The first cause clears within seconds once you slow down; the second needs a change in the Cloud Console. To fix it:

• Pace requests so they stay under the per-minute limit.
• Retry with exponential backoff when the status still appears.
• Check quotas and billing in the Cloud Console.

For long address lists, send them as batch jobs instead of one request per address: the Geoapify Geocoding API accepts up to 1,000 addresses per batch job.

What Does OVER_QUERY_LIMIT Mean?

OVER_QUERY_LIMIT is the status Google Maps Platform returns when a request goes over a usage limit of your project. According to the Google Maps Platform FAQ, the service "has switched to returning only status code OVER_QUERY_LIMIT until more usage is allowed again", and "this scenario can happen within a few seconds, if the error was received because your application sent too many requests per minute."

There are two different causes, and they need different fixes:

Sources: Google Maps Platform FAQ and Geocoding API usage and billing, both last updated 8 October 2026 and checked on 14 October 2026.

Two details are easy to miss. First, Google counts QPM as "the sum of client-side and server-side queries", so a browser app with many users shares one per-minute limit across all of them. Second, the FAQ lists a missing or invalid API key as a possible reason for OVER_QUERY_LIMIT or OVER_DAILY_LIMIT too, so check the key before you tune the request rate.

How Do You Fix OVER_QUERY_LIMIT?

Start with the cause. If the error appears after a burst of requests and goes away a few seconds later, it's the per-minute limit: add delays and retries. If every request fails, check billing, the API key and quotas first.

Add delays when geocoding a large number of addresses

Spacing requests evenly is the simplest way to stay under the per-minute limit. The example below geocodes an array of addresses with the Maps JavaScript API Geocoder, sends one request every 100 ms, and puts a marker for each result:

function initMap() {
  const map = new google.maps.Map(document.getElementById('map'), {
    zoom: 8,
    center: {
      lat: 42.508220,
      lng: -71.060125
    }
  });
  const geocoder = new google.maps.Geocoder();
  const bounds = new google.maps.LatLngBounds();

  geocodeAddressesWithDelay(geocoder, map, bounds);
}

const addresses = [... /* your addresses here */];

function geocodeAddress(address, geocoder) {
  return new Promise((resolve, reject) => {
    geocoder.geocode({
      'address': address
    }, (results, status) => {
      if (status === 'OK') {
        resolve(results);
      } else {
        reject(status);
      }
    });
  });
}

function geocodeAddressesWithDelay(geocoder, map, bounds) {
  let i = 0;
  const delay = 100; // 100 ms = 10 requests per second

  const intervalId = setInterval(() => {
    if (i >= addresses.length) {
      clearInterval(intervalId);
      return;
    }
    const address = addresses[i];
    i++;

    geocodeAddress(address, geocoder)
      .then((geocodingResults) => {
        console.log(geocodingResults[0]);

        bounds.extend(geocodingResults[0].geometry.location);

        new google.maps.Marker({
          map: map,
          position: geocodingResults[0].geometry.location
        });
        map.fitBounds(bounds);
      })
      .catch((error) => {
        console.error(`Failed to geocode ${address}: ${error}`);
      });
  }, delay);
}

How the code works:

• geocodeAddress(address, geocoder) wraps one geocoder.geocode() call in a Promise that resolves with the results when the status is OK and rejects with the status otherwise.
• geocodeAddressesWithDelay() uses setInterval to start one request every 100 ms. Each address is stored in a local constant before the request, so the error message names the right address.
• On success, the first result is logged, added to the map bounds and shown as a marker.

A 100 ms interval means 10 requests per second, or 600 per minute, well under the 3,000 QPM limit. The theoretical ceiling is one request every 20 ms (50 per second), but that leaves no room for other users or servers in the same project, since they all count towards one limit. For more on client-side pacing, see our tutorial on how to call the Geocoding API while respecting rate limits and the general guide to avoiding 429 Too Many Requests errors.

Retry with backoff

Even with pacing, a request can still hit the limit when other clients share the project. Retrying with exponential backoff means waiting longer after each failed attempt (here 1, 2, 4, 8 and 16 seconds), so retries don't add to the burst that caused the error:

const addresses = [... /* your addresses here */];

const geocoder = new google.maps.Geocoder();
const baseDelay = 1000; // first retry after 1 s
const maxRetryCount = 5;

geocodeAddresses(addresses, geocoder);

function wait(ms) {
  return new Promise((resolve) => setTimeout(resolve, ms));
}

function geocodeAddress(address, geocoder, attempt = 0) {
  return new Promise((resolve, reject) => {
    geocoder.geocode({ address: address }, (results, status) => {
      if (status === 'OK') {
        resolve(results[0]);
      } else if (status === 'OVER_QUERY_LIMIT' && attempt < maxRetryCount) {
        // Exponential backoff: 1 s, 2 s, 4 s, 8 s, 16 s
        const delay = baseDelay * 2 ** attempt;
        wait(delay)
          .then(() => geocodeAddress(address, geocoder, attempt + 1))
          .then(resolve)
          .catch(reject);
      } else if (status === 'OVER_QUERY_LIMIT') {
        reject(new Error(`Geocoding failed after ${maxRetryCount} retries: ${address}`));
      } else {
        reject(new Error(`Geocoding failed: ${address} (${status})`));
      }
    });
  });
}

async function geocodeAddresses(addresses, geocoder) {
  const results = [];
  for (const address of addresses) {
    try {
      const result = await geocodeAddress(address, geocoder);
      results.push(result);
    } catch (error) {
      console.error(error.message);
    }
  }
  console.log(results);
}

The geocodeAddress function takes one address, the Geocoder instance and the attempt number, and returns a Promise:

• If the status is OK, it resolves with the first result.
• If the status is OVER_QUERY_LIMIT, it waits baseDelay * 2 ** attempt milliseconds and tries again, up to maxRetryCount retries.
• Any other status (for example ZERO_RESULTS or REQUEST_DENIED) rejects immediately, because retrying won't help.

geocodeAddresses processes addresses one at a time, so only one request is in flight. Retries handle short spikes well; if the error persists after all retries, the cause is more likely a quota or billing limit than the per-minute rate.

Check quotas and billing

If requests fail consistently, open the Google Cloud Console and check usage and quotas:

1. Select the project that contains the API you want to review.
2. From the Dashboard's list of APIs, click the name of the API you want to monitor.
3. Near the top of the page, open the Metrics or Quotas tab to see detailed usage.

Google recommends setting a daily usage cap to avoid unexpected costs; Geocoding daily quotas refresh at midnight Pacific time. Budgets and alerts are different: in Google's words, "setting a budget does not cap API usage", and alerts "don't prevent the use of your services when the budget is met or exceeded". A hard cap needs a quota limit.

For notifications before you reach a limit, use Cloud Monitoring alerts. Keep in mind that a quota you set yourself is also a source of OVER_QUERY_LIMIT once it's reached.

Caching: what Google allows

Caching results avoids repeat requests for the same address, but the Google Maps Service Specific Terms (section 6.3, checked on 14 October 2026) set clear limits for Geocoding API content:

• Temporary cache: latitude and longitude values may be cached for up to 30 consecutive calendar days, after which they must be deleted.
• Per-user cache: latitude, longitude, formatted_address and structured address values may be cached indefinitely only to support the end-user-facing functionality of the app that made the request, not as a replacement for an additional call, and logically isolated per end user.

So a shared, long-term address database built from Google geocoding results isn't covered by these terms. A cache keyed per user, or one that expires within 30 days, can still reduce repeat requests within those rules.

What Should You Do When You Geocode in Bulk?

Sending addresses one by one hits per-minute limits with any provider: at 10 requests per second, 100,000 addresses take almost 3 hours, and any retry slows the whole run. For lists like customer databases, store locators or CRM exports, a batch geocoding API is a better fit: you submit many addresses in one job and download the results when the job is done.

Batch geocoding with Geoapify

The Geoapify Batch Geocoding API accepts up to 1,000 addresses per job as a JSON array in a POST request. REST request:

curl -X POST -H "Content-Type: application/json" \
  -d '["10 Downing Street, London SW1A 2AA, United Kingdom", "Champ de Mars, 5 Avenue Anatole France, 75007 Paris, France"]' \
  "https://api.geoapify.com/v1/batch/geocode/search?apiKey=YOUR_API_KEY"

The API returns a job ID and a result URL right away:

{
  "id": "8e17dd0f68864eeb82e871cafa615043",
  "status": "pending",
  "url": "https://api.geoapify.com/v1/batch/geocode/search?id=8e17dd0f68864eeb82e871cafa615043&apiKey=YOUR_API_KEY"
}

Request the result URL until the job is complete; while it's running you get "status": "pending". Add &format=csv to get CSV instead of JSON. Simplified response (JSON, trimmed to key fields):

[
  {
    "query": { "text": "10 Downing Street, London SW1A 2AA, United Kingdom" },
    "formatted": "10 Downing Street, London, SW1A 2AA, United Kingdom",
    "lat": 51.5034878,
    "lon": -0.1276965,
    "result_type": "amenity",
    "rank": { "confidence": 1 }
  },
  {
    "query": { "text": "Champ de Mars, 5 Avenue Anatole France, 75007 Paris, France" },
    "formatted": "Eiffel Tower, 5 Avenue Anatole France, 75007 Paris, France",
    "lat": 48.8582599,
    "lon": 2.2945006,
    "result_type": "amenity",
    "rank": { "confidence": 1 }
  }
]

Each result keeps the original query.text, so you can match it to your input rows, and rank.confidence helps you flag uncertain matches for review. Batch calls are counted with a 0.5 coefficient: a job with 1,000 addresses counts as 1,000 inputs + 1 job call + 1 result call = 1,002 API calls, billed at half the regular rate.

For millions of rows, see how to geocode millions of records efficiently. If you prefer to keep single requests with client-side pacing, the batch geocoding with rate limits tutorial shows how.

How Much Does Geocoding Cost at Higher Volume?

Once the rate limit is under control, volume decides the bill. Google bills Geocoding (Essentials) per monthly event: the first 10,000 events a month are free, then $5.00 per 1,000 from 10,001 to 100,000 and $4.00 per 1,000 from 100,001 to 500,000. Geoapify plans are daily credit quotas: one geocoding request is one credit, and the Free plan includes 3,000 credits a day.

Google: Google Maps Platform pricing, list prices on 14 October 2026, before discounts and taxes. Geoapify: pricing on 14 October 2026, monthly billing.

Because Geoapify quotas are per day, the plan depends on your busiest day, not the monthly total. 100,000 requests spread evenly is about 3,300 a day, just over the Free plan; if they come in a few large runs (for example, 250,000 requests over 10 working days, or 25,000 a day), API 25 at €89 / $109 a month covers up to 25,000 a day. Batch geocoding at the 0.5 coefficient roughly halves the credits per address, which can move a workload down a plan.

Is the Geoapify Geocoding API an Alternative?

The Geoapify Geocoding API is a Google Maps API alternative built on open data, including OpenStreetMap. Three properties matter for the problems in this article:

• Rate limits per plan: Free allows up to 5 requests per second, API 10 up to 12, and API 25 up to 15.
• Soft daily limits: if usage constantly goes over the quota, Geoapify contacts you and asks for an upgrade; the account can be blocked if those emails are ignored.
• Storage with attribution: you can cache, store and redistribute geocoding results, including in commercial products, as long as you keep the data attribution.

The Free plan needs no credit card and covers 3,000 geocoding requests a day. To try requests before writing code, open the Geocoding API Playground, and see the Geocoding API documentation for parameters, filters and batch options.

Frequently Asked Questions

Conclusion

OVER_QUERY_LIMIT is usually a pacing problem: keep requests under 3,000 per minute, retry with backoff, and check quotas and billing when every request fails. For large address lists, batch geocoding with the Geoapify Geocoding API replaces thousands of single requests with a few jobs and counts each address at half the regular rate.