---
title: "Gerenciando solicitações com falha em Python"
slug: retry-failed-requests-python
date: 2025-06-10T09:53:07+00:00
modified: 2025-11-04T08:49:12+00:00
permalink: https://brightdata.com.br/blog/dados-do-site/retry-failed-requests-python
type: blog
---
[ Blog ](https://brightdata.com.br/blog "Blog") / [Dados do site](https://brightdata.com.br/blog/dados-do-site)
[Dados do site](https://brightdata.com.br/blog/dados-do-site)
# Gerenciando solicitações com falha em Python
Aprenda a lidar com solicitações HTTP com falha em Python com estratégias de repetição eficazes e lógica personalizada.
9 min de leitura
[  ](https://brightdata.com/blog/authors/jake-nulty)
[Jake Nulty
Technical Writer
](https://brightdata.com/blog/authors/jake-nulty)
Sempre que estiver lidando com HTTP, as solicitações com falha são um fato inevitável da realidade com o qual é preciso lidar. No desenvolvimento da Web, o status 200 indica uma *boa resposta*. No entanto, nem sempre recebemos um 200, e este guia o ajudará a entender como lidar com esses códigos de status não 200.
De acordo com a [Mozilla](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status), os códigos de status podem ser divididos nas seguintes categorias:
- **100-199**: Respostas informativas
- **200-299**: Respostas bem-sucedidas
- **300-399**: Mensagens de redirecionamento
- **400-499**: Mensagens de erro do cliente
- **500-599**: Mensagens de erro do servidor
## O que são códigos de status?
[Os códigos de erro](/blog/proxy-101/proxy-error-codes) são importantes. Ao criar programas do lado do cliente, como raspadores da Web, precisamos nos concentrar principalmente nos códigos de status nas faixas de 400+ e 500+. Os códigos na faixa de 400 geralmente abrangem erros no lado do cliente, como problemas de autenticação, limitação de taxa, timeouts e o infame erro 404: Arquivo não encontrado. Nos códigos 500, geralmente estamos analisando problemas no servidor.
Há décadas, a Mozilla vem documentando os padrões de desenvolvimento da Web do [W3C](https://www.w3.org/) e do [IETF](https://www.ietf.org/). Abaixo está uma lista de códigos de erro comuns que você pode encontrar. Essa lista não é exaustiva. Esses erros são provenientes da [documentação oficial](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status#client_error_responses) da Mozilla. Dependendo do seu site de destino, seus códigos podem ser ligeiramente diferentes, mas a lógica deve permanecer a mesma.
**Código de status****Significado****Descrição**400Solicitação ruimVerifique o formato de sua solicitação401Não autorizadoVerifique sua chave de API403ProibidoNão é possível acessar esses dados404Não encontradoO site/ponto de extremidade não existe408Tempo limite da solicitaçãoA solicitação expirou, tente novamente429Muitas solicitaçõesDiminua a velocidade de suas solicitações500Erro interno do servidorErro genérico do servidor, solicitação de nova tentativa501Não implementadoO servidor ainda não é compatível com isso502Gateway ruimFalha na resposta de um servidor upstream503Serviço indisponívelO servidor está temporariamente fora do ar, tente novamente mais tarde504Tempo limite do gatewayTempo limite de espera por um servidor upstream## Estratégias de repetição
Ao implementar um mecanismo de repetição, você pode usar bibliotecas pré-construídas, como HTTPAdapter e Tenacity. Dependendo do seu caso, você pode até querer escrever sua própria lógica de repetição.
Normalmente, queremos um limite de tentativas e uma estratégia para recuar. Precisamos de um limite para não ficarmos presos em um loop infinito de novas tentativas. Precisamos recuar pouco a pouco para respeitar o servidor host. Quando as solicitações são muito rápidas, elas fazem com que você seja bloqueado ou sobrecarregam o servidor.
- **Limites de repetição**: Você precisa definir um limite. Após um número X de tentativas, seu scraper desistirá.
- **Algoritmo de backoff**: Este é relativamente simples. Você quer começar com um backoff pequeno e aumentá-lo a cada nova tentativa. Queremos começar com 0,3, depois aumentar para 0,6, 1,2 e assim por diante.
**Queremos tentar novamente nossas solicitações até um determinado limite. Após cada solicitação com falha, queremos esperar um pouco mais.**
## Adaptador HTTPA
Com o HTTPAdapter, precisamos configurar três coisas: `total`, `backoff_factor` e `status_forcelist`. `allowed_methods` não é realmente um requisito, mas torna nosso código mais seguro ao ajudar a definir nossas condições de repetição. No código abaixo, usamos [o httpbin](https://httpbin.org/) para forçar automaticamente um erro e acionar nossa lógica de repetição.
```none
import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry
#create a session
session = requests.Session()
#configure retry settings
retry = Retry(
total=3, #maximum retries
backoff_factor=0.3, #time between retries (exponential backoff)
status_forcelist=(429, 500, 502, 503, 504), #status codes to trigger a retry
allowed_methods={"GET", "POST"}
)
#mount the adapter with our custom settings
adapter = HTTPAdapter(max_retries=retry)
session.mount("http://", adapter)
session.mount("https://", adapter)
#actually make a request with our retry logic
try:
print("Making a request with retry logic...")
response = session.get("https://httpbin.org/status/500")
response.raise_for_status()
print("✅ Request successful:", response.status_code)
except requests.exceptions.RequestException as e:
print("❌ Request failed after retries:", e)
```
Depois de criarmos um objeto `Session`, fazemos o seguinte:
- Crie um objeto `Retry` e defina o seguinte:
- `total`: o limite máximo para tentar novamente uma solicitação.
- `backoff_factor`: Tempo de espera entre novas tentativas. Isso se ajusta exponencialmente à medida que nossas tentativas aumentam.
- `status_forcelist`: Uma lista de códigos de status ruins. Qualquer código dessa lista acionará automaticamente uma nova tentativa.
- Crie um objeto `HTTPAdapter` com nossa variável `retry`: `adapter = HTTPAdapter(max_retries=retry)`.
- Depois de criarmos o `adaptador`, nós o montamos nos métodos HTTP e HTTPS usando `session.mount()`.
Quando você executar esse código, nossas três tentativas`(total=3`) serão executadas e, em seguida, você obterá o seguinte resultado.
```none
Making a request with retry logic...
❌ Request failed after retries: HTTPSConnectionPool(host='httpbin.org', port=443): Max retries exceeded with url: /status/500 (Caused by ResponseError('too many 500 error responses'))
```
## Tenacidade
Você também pode usar o [Tenacity](https://tenacity.readthedocs.io/en/latest/), uma popular biblioteca de tentativas de código aberto para Python. Ela não se limita ao HTTP, mas nos oferece uma maneira expressiva e compreensível de implementar tentativas.
Primeiro, você precisa instalá-lo.
```none
pip install tenacity
```
Depois de instalado, criamos um *decorador* e o usamos para envolver uma função de solicitação. Com nosso decorador `@retry`, adicionamos os argumentos `stop`, `wait` e `retry`.
```none
import requests
from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type, RetryError
#define a retry strategy
@retry(
stop=stop_after_attempt(3), #retry up to 3 times
wait=wait_exponential(multiplier=0.3), #exponential backoff
retry=retry_if_exception_type(requests.exceptions.RequestException), #retry on request failures
)
def make_request():
print("Making a request with retry logic...")
response = requests.get("https://httpbin.org/status/500")
response.raise_for_status()
print("✅ Request successful:", response.status_code)
return response
# Attempt to make the request
try:
make_request()
except RetryError as e:
print("❌ Request failed after all retries:", e)
```
A lógica e as configurações aqui são muito semelhantes às do nosso primeiro exemplo com o HTTPAdapter.
- `stop=stop_after_attempt(3)`: Isso diz ao `tenacity` para desistir após 3 tentativas fracassadas.
- `wait=wait_exponential(multiplier=0.3)` usa a mesma espera que usamos anteriormente. Ele também recua exponencialmente, exatamente como antes.
- `retry=retry_if_exception_type(requests.exceptions.RequestException)` diz ao `tenacity` para usar essa lógica sempre que ocorrer uma `RequestException`.
- `make_request()` faz uma solicitação ao nosso endpoint de erro. Ele recebe todas as características do decorador que criamos acima dele.
Quando você executa esse código, obtém um resultado semelhante.
```none
Making a request with retry logic...
Making a request with retry logic...
Making a request with retry logic...
❌ Request failed after all retries: RetryError[]
```
## Crie seu próprio mecanismo de repetição
Você também pode criar seu próprio mecanismo de repetição. Ao lidar com código personalizado, essa pode ser a melhor abordagem. Com uma quantidade relativamente pequena de código, podemos obter o mesmo efeito que obtemos com essas bibliotecas.
No código abaixo, precisamos importar `o sleep` para nosso backoff exponencial. Mais uma vez, definimos nossa configuração: `total`, `backoff_factor` e `bad_codes`. Em seguida, usamos um loop `while` para manter nossa lógica de repetição. `Enquanto` ainda temos tentativas e não obtivemos êxito, tentamos a solicitação.
```none
import requests
from time import sleep
#create a session
session = requests.Session()
#define our retry settings
total = 3
backoff_factor = 0.3
bad_codes = [429, 500, 502, 503, 504]
#try counter and success boolean
current_tries = 0
success = False
#attempt until we succeed or run out of tries
while current_tries < total and not success:
try:
print("Making a request with retry logic...")
response = session.get("https://httpbin.org/status/500")
if response.status_code in bad_codes:
raise requests.exceptions.HTTPError(f"Received {response.status_code}, triggering retry")
print("✅ Request successful:", response.status_code)
success = True
except requests.exceptions.RequestException as e:
print(f"❌ Request failed: {e}, retries left: {total-current_tries}")
sleep(backoff_factor)
backoff_factor = backoff_factor * 2
current_tries+=1
```
A lógica real aqui é tratada por um simples loop `while`.
- Se `response.status_code` estiver em nossa lista de `bad_codes`, lançaremos uma exceção.
- Se uma solicitação falhar, nós:
- Imprime uma mensagem de erro no console.
- `sleep(backoff_factor)` aguarda antes de enviar a próxima solicitação.
- `backoff_factor = backoff_factor * 2` duplica nosso `backoff_factor` para a próxima tentativa.
- Nós incrementamos `current_tries` para não ficarmos no loop indefinidamente.
Aqui está o resultado de nossa lógica de repetição personalizada.
```none
Making a request with retry logic...
❌ Request failed: Received 500, triggering retry, retries left: 3
Making a request with retry logic...
❌ Request failed: Received 500, triggering retry, retries left: 2
Making a request with retry logic...
❌ Request failed: Received 500, triggering retry, retries left: 1
```
## Como superar bloqueios
Na natureza, alguns sites vão bloquear você. A prática recomendada é sempre [usar um proxy com solicitações Python](/blog/proxy-101/proxy-with-python-requests). Com um proxy, sua solicitação é roteada por uma máquina diferente. Isso protegerá sua identidade e evitará que seu endereço IP seja bloqueado pelo site de destino. Temos até um [guia detalhado](/blog/proxy-101/how-to-bypass-an-ip-ban) sobre como contornar bloqueios de IP. Nossos [proxies residenciais](/proxy-types/residential-proxies) foram criados para que você supere esses desafios.
## Conclusão
Agora você sabe como lidar com solicitações HTTP com falha no Python. Se estiver escrevendo um scraper, um cliente de API ou ferramentas de automação, você saberá como lidar com esses problemas. Para evitar todos os tipos de solicitações com falha, desenvolvemos produtos como a [API Web Unlocker](/products/web-unlocker) e o [Scraping Browser](/products/scraping-browser). Essas ferramentas lidam automaticamente com medidas antibot, [desafios CAPTCHA](/blog/dados-do-site/what-is-a-captcha) e bloqueios de IP, garantindo uma raspagem da Web perfeita e eficiente até mesmo para os sites mais desafiadores.
Inscreva-se agora e comece seu teste gratuito hoje mesmo.
Contate-nosTeste grátis
Índice
Dedicated Scraper APIs & No-Code Scrapers
Over 1000 scrapers for all popular domains. Simplify your web scraping.
[See pricing](/pricing/web-scraper "See pricing")
Just want data? Skip scraping.
Hundreds of ready-to-use datasets from all popular domains.
[See pricing](/pricing/datasets "See pricing")
[ ](https://news.ycombinator.com/submitlink?t=Gerenciando+solicita%C3%A7%C3%B5es+com+falha+em+Python&u=https://brightdata.com.br/blog/dados-do-site/retry-failed-requests-python) [ ](https://www.linkedin.com/shareArticle?mini=true&title=Gerenciando+solicita%C3%A7%C3%B5es+com+falha+em+Python&url=https://brightdata.com.br/blog/dados-do-site/retry-failed-requests-python) [ ](http://www.reddit.com/submit?title=Gerenciando+solicita%C3%A7%C3%B5es+com+falha+em+Python&url=https://brightdata.com.br/blog/dados-do-site/retry-failed-requests-python)
## Você também pode estar interessado em
[  ](https://brightdata.com.br/blog/ai/openhuman-with-bright-data "Acesso à Web Pronto para Produção no OpenHuman Através do Bright Data CLI")
[AI
Antonello Zanini
Technical Writer
### Acesso à Web Pronto para Produção no OpenHuman Através do Bright Data CLI
Integre o Bright Data CLI ao OpenHuman para habilitar acesso à web pronto para produção e coleta de dados para agentes de IA.
09-Sep-2026
14 min de leitura
](https://brightdata.com.br/blog/ai/openhuman-with-bright-data)
[  ](https://brightdata.com.br/blog/dados-do-site/multimodal-web-scraping-with-minimax "Scraping de Dados Multimodal com MiniMax")
[Dados do site
Antonello Zanini
Technical Writer
### Scraping de Dados Multimodal com MiniMax
Combine a API Web Unlocker da Bright Data com a visão MiniMax M3 para extrair dados estruturados de imagens e capturas de tela de páginas web.
09-Sep-2026
5 min de leitura
](https://brightdata.com.br/blog/dados-do-site/multimodal-web-scraping-with-minimax)
[  ](https://brightdata.com.br/blog/ai/best-cli-tools-for-codex "As 10 Melhores Ferramentas CLI para Codex em 2026 – Testadas & Classificadas")
[AI
Daniel Shashko
Web Data & AI Expert
### As 10 Melhores Ferramentas CLI para Codex em 2026 – Testadas & Classificadas
As 10 ferramentas CLI que tornam o Codex mais rápido e capaz, começando com o Bright Data CLI para acesso real à web de dentro do sandbox.
06-Sep-2026
24 min de leitura
](https://brightdata.com.br/blog/ai/best-cli-tools-for-codex)