Evitando o limite de geocódigo do Google Maps?

Estou criando um mapa do Google personalizado com 125 marcadores plotados por meio de um cms. Ao carregar o mapa, recebo esta mensagem:

O geocódigo não foi bem-sucedido pelo seguinte motivo: OVER_QUERY_LIMIT

Tenho certeza de que foi a maneira como geocodifiquei os marcadores.

Como posso evitar esses avisos e existe uma maneira mais eficiente de codificar geograficamente os resultados?

ATUALIZAÇÃO: Esta é a minha tentativa de resposta de Casey, estou apenas recebendo uma página em branco no momento.

<script type="text/javascript"> 
(function() { 

window.onload = function() { 
 var mc;
// Creating an object literal containing the properties we want to pass to the map 
var options = { 
zoom: 10, 
center: new google.maps.LatLng(52.40, -3.61), 
mapTypeId: google.maps.MapTypeId.ROADMAP 
}; 

// Creating the map 
var map = new google.maps.Map(document.getElementById('map'), options); 

// Creating a LatLngBounds object 
var bounds = new google.maps.LatLngBounds(); 

// Creating an array that will contain the addresses 
var places = []; 

// Creating a variable that will hold the InfoWindow object 
var infowindow; 
mc = new MarkerClusterer(map);
<?php
$pages = get_pages(array('child_of' => $post->ID, 'sort_column' => 'menu_order'));
$popup_content = array();
foreach($pages as $post)
    {
    setup_postdata($post);
    $fields = get_fields(); 
    $popup_content[] = '<p>'.$fields->company_name.'</p><img src="'.$fields->company_logo.'" /><br /><br /><a href="'.get_page_link($post->ID).'">View profile</a>';
    $comma = ", ";
    $full_address = "{$fields->address_line_1}{$comma}{$fields->address_line_2}{$comma}{$fields->address_line_3}{$comma}{$fields->post_code}";
    $address[] = $full_address;
    }
wp_reset_query();
echo 'var popup_content = ' . json_encode($popup_content) . ';';
echo 'var address = ' . json_encode($address) . ';';
?>

var geocoder = new google.maps.Geocoder(); 

var markers = [];

// Adding a LatLng object for each city  
for (var i = 0; i < address.length; i++) { 
    (function(i) { 
        geocoder.geocode( {'address': address[i]}, function(results, status) {
            if (status == google.maps.GeocoderStatus.OK) {
                places[i] = results[0].geometry.location;

                // Adding the markers 
                var marker = new google.maps.Marker({position: places[i], map: map});
                markers.push(marker);
                mc.addMarker(marker);

                // Creating the event listener. It now has access to the values of i and marker as they were during its creation
                google.maps.event.addListener(marker, 'click', function() {
                    // Check to see if we already have an InfoWindow
                    if (!infowindow) {
                        infowindow = new google.maps.InfoWindow();
                    }

                    // Setting the content of the InfoWindow
                    infowindow.setContent(popup_content[i]);

                    // Tying the InfoWindow to the marker 
                    infowindow.open(map, marker);
                });

                // Extending the bounds object with each LatLng 
                bounds.extend(places[i]); 

                // Adjusting the map to new bounding box 
                map.fitBounds(bounds) 
            } else { 
            alert("Geocode was not successful for the following reason: " + status); 
            }

        });

    })(i);

} 
var markerCluster = new MarkerClusterer(map, markers); 
} 
})
(); 
</script> 

Realmente não importa qual é a solução, contanto que os marcadores sejam carregados instantaneamente e não quebre os termos e condições.

Como todo mundo, eu poderia lhe dar uma resposta com código, mas não acho que alguém lhe tenha explicado que você está fazendo algo fundamentalmente errado .

Por que você está atingindo esse erro? Porque você está chamando geocode toda vez que alguém visualiza sua página e não está armazenando seus resultados em cache em nenhum lugar do banco de dados!

A razão pela qual esse limite existe é impedir o abuso dos recursos do Google (seja voluntária ou não) - que é exatamente o que você está fazendo :)

Embora o geocódigo do google seja rápido, se todo mundo o usasse assim, os servidores seriam desativados. A razão pela qual o Google Fusion Tables existe é fazer muito trabalho pesado do lado do servidor para você. O geocoding e o cache do bloco são feitos em seus servidores. Se você não quiser usá-lo, deverá armazená-los em cache no servidor.

Se ainda assim, 2500 solicitações por dia forem muito pequenas, será necessário examinar a licença (paga) do Google Maps Premier que fornece 100.000 solicitações de geocodificação por dia por algo em torno de 10 mil por ano (isso é muito - com o cache no servidor, você deve não esteja atingindo esse limite, a menos que você seja site enorme ou esteja processando pesado dados). Sem o cache do lado do servidor e usando sua abordagem atual, você seria capaz de fazer apenas 800 visualizações de página por dia!

Depois que você perceber que outros provedores cobram por geocódigo , você entenderá que deve armazenar em cache os resultados no banco de dados. Com essa abordagem, custaria cerca de 10 centavos de dólar por visualização de página!

Sua pergunta é: você pode contornar o limite de aceleração que o Google fornece? Certo. Basta fazer uma solicitação de diferentes endereços IP. Caramba, você poderia fazer proxy das chamadas através do ips elástico da amazon e sempre teria novas 2500 novas chamadas alocadas. Mas é claro que, além de ser ilegal (você está efetivamente contornando a restrição dada a você pelos termos de serviço do Google Maps), você estaria fazendo um hack para cobrir a falha de design inerente que você tem no seu sistema.

Então, qual é o caminho certo para esse caso de uso? Antes de ligar para a API do geocode do Google, envie-a para o servidor e consulte se está em seu cache. Caso contrário, chame o geocódigo, armazene-o no cache e retorne o resultado.

Existem outras abordagens, mas isso deve ajudá-lo a começar na direção certa.

Atualização: pelos seus comentários abaixo, ele disse que você está usando PHP, então aqui está um exemplo de código sobre como fazê-lo corretamente (recomendação da própria equipe do Google) https://developers.google.com/maps/articles/phpsqlsearch_v3

Eu acho que Sasa está certa, nos dois aspectos.

Em termos de envio de todos os seus endereços de uma só vez, uma opção é enviar as solicitações em intervalos. No passado, ao usar JavaScript, optei por atrasar pedidos em 0,25 (parece funcionar!) Segundos usando o comando

setTimeout( [FUNCTION CALL] , 250 )

método.

No .NET, optei por:

System.Threading.Thread.Sleep(250);

Parece funcionar.

EDIT: Não posso realmente testá-lo, mas isso deve / pode funcionar!

Exemplo de Javascript. O addressArray contém strings que são endereços ...

for (var i = 0; i < addressArray.length; i++0 
{

setTimeout('googleGeocodingFunction(' + addressArray[i] + ')' , 250);

}

EDITAR:

for (var i = 0; i < address.length; i++) {
    function(i) {
        setTimeout(geocoder.geocode({ 'address': address[i] }, function(results, status) {
            if (status == google.maps.GeocoderStatus.OK) {
                places[i] = results[0].geometry.location;

                var marker = new google.maps.Marker({ position: places[i], map: map });
                markers.push(marker);
                mc.addMarker(marker);
                google.maps.event.addListener(marker, 'click', function() {
                    if (!infowindow) {
                        infowindow = new google.maps.InfoWindow();
                    }

                    // Setting the content of the InfoWindow
                    infowindow.setContent(popup_content[i]);

                    // Tying the InfoWindow to the marker 
                    infowindow.open(map, marker);
                });

                // Extending the bounds object with all coordinates 
                bounds.extend(places[i]);

                // Adjusting the map to new bounding box 
                map.fitBounds(bounds)
            } else {
                alert("Geocode was not successful for the following reason: " + status);
            }
        }), 250);// End of setTimeOut Function - 250 being a quarter of a second. 
    } 
}

Parece que você está atingindo o limite de solicitações simultâneas imposto pelo Google (embora eu não consiga encontrar uma referência ao limite real). Você precisará espaçar suas solicitações para não enviar 125 solicitações de uma só vez. Observe que também há uma solicitação de 2500 códigos geográficos por dia.

Consulte o documento Estratégias de geocodificação do Google para obter mais informações.

Atualização: como uma solução adicional inspirada graças a uma postagem do Mapperz, você pode pensar em criar uma nova tabela do Google Fusion , armazenar seu endereço e quaisquer dados relacionados na tabela e geocodificar a tabela por meio de sua interface da web. Há um limite para o número de solicitações de geocódigo que uma tabela do Fusion fará, no entanto, o limite é bastante grande. Depois de atingir o limite, você precisará reenviar a solicitação de geocódigo, e o Fusion Tables continuará de onde parou. O bônus dessa abordagem é uma enorme melhoria de velocidade, pois você só precisará geocodificar ONCE, onde, com sua solução atual, precisará geocodificar cada carga, atingindo rapidamente os limites diários.

Aqui está como eu estrangulo minhas solicitações de geocódigo em javascript, os endereços sendo uma matriz que contém cada endereço para o geocódigo:

for (i=0;i<=addresses.length;i++) {
    setTimeout( function () {
            geocoder.geocode( { 'address': addresses[i]}, function(results, status) {

                if (status == google.maps.GeocoderStatus.OK) { 

                    //create and add marker to map based off geocode result
                    var marker = new google.maps.Marker({  
                        map: map,
                        title: results[0].formatted_address,
                        position: results[0].geometry.location
                    });

                 } //EDIT, was missing the closing bracket here
            });

    }, i * 1500);
}

Isso basicamente adiciona um segundo e meio entre cada solicitação de geocodificação.

Eu tentei a página agora e parece estar funcionando agora .

Embora eu ache que a abordagem do timer que você está usando no momento está correta e, até onde eu sei, a única que funcione sem a necessidade de suporte do servidor, sugiro as seguintes alterações (tomei a liberdade de reescrever suas funções de geocodificação) tirar proveito do localStorage .

LocalStorage é uma tecnologia relativamente nova incorporada na maioria dos navegadores que permite que a página da Web armazene dados no cliente. É um pouco semelhante aos cookies, mas é muito mais poderoso e nem sempre é reenviado ao servidor (ao contrário dos cookies).

Meu objetivo é salvar o endereço geocodificado no cliente para que, se um usuário atualize a página, não seja necessário invocar novamente as funções de geocodificador do Google. A implementação abaixo é grosseira (devemos adicionar código para verificar registros obsoletos e provavelmente precisar de uma chave de armazenamento em cache melhor que o índice), mas deve ser suficiente para você começar. Espero que ajude.

(function() { 

window.onload = function() { 
 var mc;
// Creating an object literal containing the properties we want to pass to the map 
var options = { 
zoom: 0, maxZoom: 0, 
center: new google.maps.LatLng(52.40, -3.61), 
mapTypeId: google.maps.MapTypeId.ROADMAP 
}; 

// Creating the map 
var map = new google.maps.Map(document.getElementById('map'), options); 

// Creating a LatLngBounds object 
var bounds = new google.maps.LatLngBounds(); 

// Creating an array that will contain the addresses 
var places = []; 

// Creating a variable that will hold the InfoWindow object 
var infowindow; 
mc = new MarkerClusterer(map);
var popup_content = [..redacted..];

var geocoder = new google.maps.Geocoder(); 

var markers = [];

// Adding a LatLng object for each city 
function geocodeAddress(i) {
     // check if localStorage is available (it is now available on most modern browsers)
     // http://html5tutorial.net/tutorials/working-with-html5-localstorage.html
     // NB: this *must* be improved to handle quota limits, age/freshness, etc
     if(localStorage && localStorage['address_'+i]) {
        places[i]=JSON.parse(localStorage['address_'+i]);
        addPlace(i);
     } else {
      geocoder.geocode( {'address': address[i]}, function(results, status) {
        if (status == google.maps.GeocoderStatus.OK) {
            places[i] = results[0].geometry.location;
            if(localStorage) {
               // cache result locally on the browser, this will help reducing the number of requests
               // to the google geocoder in case the user refreshes the page
               // remember: the more he will refresh, the more he's likely to hit the limit
               // (this is one case where refreshing or closing the browser does not work)
               localStorage['address_'+i]=JSON.stringify(results[0].geometry.location);
            }

            addPlace(i);
        } else { 
            console.log("Geocoding of address "+address[i]+" failed");
        }
    })
}

function addPlace(i) {
    // Adding the markers 
    var marker = new google.maps.Marker({position: places[i], map: map});
    markers.push(marker);
    mc.addMarker(marker);

    // Creating the event listener. It now has access to the values of i and marker as they were during its creation
    google.maps.event.addListener(marker, 'click', function() {
        // Check to see if we already have an InfoWindow
        if (!infowindow) {
            infowindow = new google.maps.InfoWindow();
        }

        // Setting the content of the InfoWindow
        infowindow.setContent(popup_content[i]);

        // Tying the InfoWindow to the marker 
        infowindow.open(map, marker);
    });

    // Extending the bounds object with each LatLng 
    bounds.extend(places[i]); 

    // Adjusting the map to new bounding box 
    map.fitBounds(bounds);
}

function geocode() {
    if (geoIndex < address.length) {
        geocodeAddress(geoIndex);
        ++geoIndex;
    }
    else {
        clearInterval(geoTimer);
    }
}
var geoIndex = 0;
var geoTimer = setInterval(geocode, 600);  // 200 milliseconds (to try out)

var markerCluster = new MarkerClusterer(map, markers); 
} 
})
(); 

usando geocodificadores geopy , sou capaz de um grande número de endereços sem problemas (não tenho certeza da configuração dos pôsteres ou se ele pode incluir uma dependência de python em seu projeto)

aqui está o meu teste:

from geopy import geocoders

g = geocoders.GoogleV3()  #https://geopy.readthedocs.io/en/latest/#geopy.geocoders.GoogleV3

for x in xrange(1,10000):
    print x
    a = g.geocode("AV JOAO NAVES DE AVILA " + str(x) + " UBERLANDIA MG BRASIL")
    print a

snippet de resultado

7595 (u. Av. Joao Naves de \ xc1vila, 7595 - Segismundo Pereira, Uberl \ xe2ndia - Minas Gerais, 38408-288, Brazil ', (-18.9388154, -48.2220562))

7596 (av. Joao Naves de \ xc1vila, 7596 - Segismundo Pereira, Uberl \ xe2ndia - Minas Gerais, 38408-680, Brasil ', (-18.938814, -48.2217423))

7597 (av. Jo \ x3o Naves de \ xc1vila, 7597 - Segismundo Pereira, Uberl \ xe2ndia - Minas Gerais, 38408-288, Brasil ', (-18.9388128, -48.2220381))

7598 (av. Jo \ x3o Naves de \ xc1vila, 7598 - Segismundo Pereira, Uberl \ xe2ndia - Minas Gerais, 38408-680, Brasil ', (-18.9388114, -48.2217242))

7599 (Av. Jo \ xo3 Naves de \ xc1vila, 7599 - Segismundo Pereira, Uberl \ xe2ndia - Minas Gerais, 38408-288, Brasil ', (-18.9388102, -48.2220201))

7600 (av. Jo \ x3o Naves de \ xc1vila, 7600 - Segismundo Pereira, Uberl \ xe2ndia - Minas Gerais, 38408-680, Brasil ', (-18.9388088, -48.2217062))

Isso ainda está em execução e estou com 7 mil resultados.

EDIT: Depois de um tempo, cheguei ao fim da rua e o Google começou a me dar os mesmos pontos, mas parece que ele ainda está fazendo solicitações e respostas precisas.

Esta função php (eu não sei em qual idioma você está trabalhando, mas você pode escolher com certeza) usa a API do google geolocator. Dado um endereço, ele retornará o endereço normalizado e depois. HTH.

// GEOLOCATEBYADDRESS
// @arg (string)address
// @return (array) ((int)flag,(array)address,array(rawresponse))

function geolocatebyaddress($lookupaddress){

    $lookupaddress=trim("$lookupaddress New Zealand");
    $lookupaddress=urlencode($lookupaddress);

    //send off google api lookup request
    $apiurl="http://maps.google.com/maps/api/geocode/json";
    $apiurl.="?address=$lookupaddress";
    $apiurl.="&region=NZ";
    $apiurl.="&sensor=false";

    if (function_exists("curl_init")) {
        $ch = curl_init();
        curl_setopt($ch, CURLOPT_URL, $apiurl);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
        $json = curl_exec($ch);
        curl_close($ch);
    }
    else     $json= file_get_contents($apiurl);

    //process response
    $response= json_decode($json,true);
    $approxflag=0;
    if ($response['status']=='OK' and count($response['results'])) {

        $aa= array();
        foreach($response['results'] as $cc=>$result) {
            //set keys
            foreach(array('street_number','road','suburb','city','postcode','region','lat','long') as $t){
                $aa[$cc][$t]='';
            }
            if ($result['geometry']){
                $aa[$cc]['lat']= $result['geometry']['location']['lat'];
                $aa[$cc]['long']=$result['geometry']['location']['lng'];
         }

            if (count($result['address_components'])){
                foreach ($result['address_components'] as $acs){
                    if ($acs['types'][0]=='street_number')               $aa[$cc]['street_number']= $acs['long_name']; 
                    if ($acs['types'][0]=='route')                       $aa[$cc]['road']=      $acs['long_name']; 
                    if ($acs['types'][0]=='sublocality')                 $aa[$cc]['suburb']=   $acs['long_name']; 
                    if ($acs['types'][0]=='locality')                    $aa[$cc]['city']=    $acs['long_name']; 
                    if ($acs['types'][0]=='postal_code')                 $aa[$cc]['postcode']= $acs['long_name']; 
                    if ($acs['types'][0]=='administrative_area_level_1') $aa[$cc]['region']=   $acs['long_name']; 
                }    
            }
            //successful?
            if ($result['geometry']['location_type']=='APPROXIMATE') $approxflag++;
            if (isset($result['partial_match']))  $approxflag++;
            if (!$aa[$cc]['street_number'])         $approxflag++;
        }
        if ($approxflag) return (array(1,$aa,$response));
        else return (array(2,$aa,$response));
    }
    else return (array(0,array(),$response));
}    

Só agora vi sua consulta. Você pode tentar seguir o código. Na parte de verificação de status do geocódigo, chame recursivamente a mesma função com um intervalo de tempo para os endereços perdidos.

function spotPosition(address) {
        geocoder.geocode({ 'address': address }, function (results, status) {
            if (status == google.maps.GeocoderStatus.OK) {
                var lat = results[0].geometry.location.lat();
                var lang = results[0].geometry.location.lng();
                setMarker(lat, lang);
            }
            else if (status == google.maps.GeocoderStatus.OVER_QUERY_LIMIT) {
                setTimeout(function () {
                    //Recursively calling spotPosition method for lost addresses
                    spotPosition(address);
                }, 1000);
            }
        });
    }

Aqui está a minha solução:

dependências: Gmaps.js, jQuery

var Maps = function($) {
   var lost_addresses = [],
       geocode_count  = 0;

   var addMarker = function() { console.log('Marker Added!') };

   return {
     getGecodeFor: function(addresses) {
        var latlng;
        lost_addresses = [];
        for(i=0;i<addresses.length;i++) {
          GMaps.geocode({
            address: addresses[i],
            callback: function(response, status) {
              if(status == google.maps.GeocoderStatus.OK) {
                addMarker();
              } else if(status == google.maps.GeocoderStatus.OVER_QUERY_LIMIT) {
                lost_addresses.push(addresses[i]);
              }

               geocode_count++;
               // notify listeners when the geocode is done
               if(geocode_count == addresses.length) {
                 $.event.trigger({ type: 'done:geocoder' });
               }
            }
          });
        }
     },
     processLostAddresses: function() {
       if(lost_addresses.length > 0) {
         this.getGeocodeFor(lost_addresses);
       }
     }
   };
}(jQuery);

Maps.getGeocodeFor(address);

// listen to done:geocode event and process the lost addresses after 1.5s
$(document).on('done:geocode', function() {
  setTimeout(function() {
    Maps.processLostAddresses();
  }, 1500);
});

Você não pode evitar o limite de geocódigo do google map: você deve obter e armazenar informações sobre o LatLng .

Se você possui várias cidades e não deseja obter o LatLng manualmente, pode usar um tempo limite para chamar progressivamente geocoder.geocode e salvar informações dentro de um objeto javascript e, em seguida, usar console.log(JSON.stringify(object, null, 4));para obter no console um objeto bem impresso, portanto, para exemplo

            var locationsPosition = {
                    "Johannesburg - ZA": {
                        "lat": -26.2041028,
                        "lng": 28.047305100000017
                    },
                    "Chennai - IN": {
                        "lat": 13.0826802,
                        "lng": 80.27071840000008
                    }
             }

então agora você pode adicionar marcador usando locationsPosition["Johannesburg - ZA"].late.lng

Parece que você precisa fazer uma de duas coisas:

1. altere seu processo para armazenar em cache os resultados, se você não obtiver tantos por dia; ou
2. atualizar para um serviço que permite processar mais por dia

Como as pessoas mencionaram várias vezes, mas não tenho experiência pessoal, parece que uma licença do Google por 100 mil por dia é de cerca de US $ 10 mil por ano.

Se você deseja o mesmo nível de precisão ou melhor (e não precisa pagar esse preço), pode experimentar nosso serviço. Por muito menos que o Google (quase um décimo do custo), você pode obter um limite muito maior que 2500 (nosso limite mais baixo é 25k / dia).

Obviamente, usar nossa API de geocodificação paga não é a solução que eu recomendaria para ser 100% honesto, mesmo que seja um mau senso comercial admitir isso. Em vez disso, sugiro que, com a opção 1, otimize seu serviço para armazenar em cache. A menos que você precise de mais de 2500 geocódigos UNIQUE por dia.

Isenção de responsabilidade : trabalho no Geocode Farm (o serviço que estou recomendando).