L’errore HTTP con codice 429 (spesso accompagnato dalla dicitura Too Many Requests) è un codice di stato che indica che il client sta effettuando troppe richieste in un periodo di tempo troppo piccolo, causando il blocco della richiesta (request) originale. Too Many Requests indica in sostanza, mediante il codice 429, che ci sono un numero eccessivo di chiamate che il server non è in grado di gestire a monte, per cui il client si rifiuta di inviarne così tante ed il programmatore dovrà pertanto adeguarsi alla velocità indicata dal server stesso.
Come risolvere il problema
In genere in questi casi basta ridurre la frequenza di richieste effettuate in termini di chiamate HTTP, adeguandosi ai requisiti del server stesso.
Per saperne di più in tal senso, del resto, il campo header dal nome Retry-After potrebbe su alcune configurazioni indicare dopo quanto tempo sia lecito effettuare una nuova richiesta. Non si tratta, per queste ragioni, di un vero e proprio errore da risolvere (in senso stretto), ma semplicemente di una notifica in cui si invita a non sovrautilizzare le risorse del server.
Se state lavorando con la libreria requests di Python oppure con chiamate HTTP in PHP, Javascript e via dicendo, questo errore suggerisce di evitare di fare troppe richieste in poco tempo, perchè il vostro client non sarà comunque in grado di gestirle (e andranno in abort tutte le richieste eccessive che saranno automaticamente scartate, per inciso). Mi è capitato un errore del genere durante il tentativo di download di immagini e video da subreddit di Reddit, dove questa notifica è comparsa nel caso di un loop che provava a scansionare un subreddit e a estrarre le immagini ed i video che riusciva a trovare.
Questo tipo di codice di stato lato client si presenta in molti casi in questa veste che segue: HTTP 1.1, formato HTML, riprova dopo 3600 secondi ovvero il server può accettare massimo 1 richiesta ogni ora. Il campo Retry-After in alcuni casi potrebbe non essere specificato nell’header.
HTTP/1.1 429 Too Many Requests
Content-Type: text/html
Retry-After: 3600Google returned a response with code 429 in python
Seguendo queste strategie, puoi gestire e risolvere efficacemente l’errore 429 in Python.
L’errore “Google returned a response with code 429” significa che l’applicazione ha superato il limite di richieste consentite da Google in un determinato periodo di tempo. Questo errore, noto anche come “Too Many Requests”, viene restituito quando si effettuano troppe richieste in un breve lasso di tempo e il server limita l’accesso per prevenire l’abuso.
Per risolvere questo problema in Python, ci sono diverse strategie che puoi adottare:
1. Implementare una logica di ripetizione con attesa esponenziale
Questa tecnica consiste nell’attendere per un intervallo di tempo crescente tra un tentativo e l’altro. Ad esempio, puoi attendere 1 secondo prima del primo tentativo, 2 secondi prima del secondo, 4 secondi prima del terzo, e così via.
import time
import requests
def make_request_with_retries(url, max_retries=5):
retries = 0
wait_time = 1 # tempo iniziale di attesa
while retries < max_retries:
response = requests.get(url)
if response.status_code == 200:
return response
elif response.status_code == 429:
print(f"Errore 429 ricevuto. Tentativo {retries + 1} di {max_retries}. Attesa di {wait_time} secondi.")
time.sleep(wait_time)
wait_time *= 2 # attesa esponenziale
retries += 1
else:
response.raise_for_status()
raise Exception(f"Max tentativi ({max_retries}) raggiunti con errore 429.")
url = 'https://example.com/api'
response = make_request_with_retries(url)
print(response.text)
2. Ridurre la frequenza delle richieste
Assicurati di non superare i limiti imposti riducendo il numero di richieste che invii in un determinato periodo di tempo. Questo può essere fatto utilizzando una funzione di ritardo fissa tra le richieste.
import time
import requests
def make_request_with_fixed_delay(url, delay=2):
response = requests.get(url)
if response.status_code == 429:
print("Errore 429 ricevuto. Attesa di 2 secondi.")
time.sleep(delay)
response = requests.get(url)
return response
url = 'https://example.com/api'
response = make_request_with_fixed_delay(url)
print(response.text)
3. Utilizzare una libreria per il rate-limiting
Puoi utilizzare librerie come ratelimit per implementare facilmente il rate-limiting nelle tue richieste.
import requests
from ratelimit import limits, sleep_and_retry
# Definire i limiti di richieste, ad esempio 10 richieste per minuto
ONE_MINUTE = 60
@sleep_and_retry
@limits(calls=10, period=ONE_MINUTE)
def call_api(url):
response = requests.get(url)
if response.status_code != 200:
raise Exception('API response: {}'.format(response.status_code))
return response
url = 'https://example.com/api'
response = call_api(url)
print(response.text)
4. Verificare e gestire le quote di API
Se stai utilizzando un’API con quote limitate, verifica le tue quote e gestisci correttamente le chiavi API. Potrebbe essere necessario richiedere un aumento delle quote se hai bisogno di effettuare più richieste.
Immagine di copertina generata da Midjourney
👇 Da non perdere 👇
- Gratis 🎉
- Lavoro 🔧
- Marketing & SEO 🌪
- Programmare 🖥
- Reti 💻
- Sicurezza & Privacy 👁
- 💬 Il nostro canale Telegram: iscriviti
- 🟡 Alcuni strumenti gratuiti per comunicare al meglio in pubblico
- 🔴 Che vuol dire morfologia
- 🟢 Come modificare un file PDF
