Requests Python: como fazer requisições HTTP de forma simples e prática

20 minutos de leitura 15/08/2025 • Atualizado 1 mês atrás 5xp

A biblioteca Requests é um pacote Python que simplifica o trabalho com requisições HTTP. Com ela, você envia e recebe dados da web de forma direta, sem precisar montar manualmente query strings ou corpos de requisição.

Por que usar Requests?

Porque é simples, intuitivo e eficiente. Com poucas linhas de código, já é possível fazer requisições completas. Você ainda conta com recursos avançados.

Principais vantagens:

Gerenciamento de sessões e autenticação: mantém cookies, adiciona cabeçalhos e suporta diferentes métodos de login;
Ideal para APIs REST: perfeito para consumir ou testar serviços;
Suporte a todos os métodos HTTP: inclusive os personalizados;
SSL integrado e tratamento de erros: segurança e robustez por padrão.

Por isso, o Requests é a forma mais prática e segura de integrar Python e web, seja para buscar dados em uma API, enviar informações para um sistema externo ou automatizar tarefas como web scraping.

Faça o curso:

APIs para iniciantes – HTTP, Requests e APIs com Python

Como instalar a biblioteca Requests?

O Request não faz parte da biblioteca padrão do Python. Por esse motivo, você precisa adicioná-lo manualmente ao seu projeto.

Para isso, abra o terminal (ou prompt de comando) e execute:

pip install requests

pip install requests

O pip é o gerenciador de pacotes do Python e cuidará de baixar e instalar tudo o que você precisa.

Após a instalação, importe o módulo no seu código:

import requests

import requests

Pronto! Agora você já pode começar a enviar requisições HTTP usando o Requests.

Métodos HTTP mais usados no Request

Na biblioteca Requests, os métodos HTTP indicam ao servidor qual ação você quer executar. Cada método tem um propósito específico e entender como eles funcionam é essencial para integrar APIs e automatizar tarefas.

Conheça os principais a seguir:

GET

O GET é o método HTTP mais utilizado. Ele serve para solicitar dados de um recurso específico no servidor, como um arquivo, uma página HTML ou informações de uma API.

Sintaxe

requests.get(url, params={chave: valor}, **kwargs)

requests.get(url, params={chave: valor}, **kwargs)

Exemplo de uso do método GET

Vamos simular uma requisição usando https://httpbin.org/get:

import requests

url = "https://httpbin.org/get"               # Endpoint de teste para GET
params = {"nome": "Carlos", "idade": 32}      # Parâmetros opcionais

# Envia a requisição GET com parâmetros
response = requests.get(url, params=params)

print(response.status_code)  # Código de status
print(response.json())       # Resposta da API

import requests

url = "https://httpbin.org/get"               # Endpoint de teste para GET
params = {"nome": "Carlos", "idade": 32}      # Parâmetros opcionais

# Envia a requisição GET com parâmetros
response = requests.get(url, params=params)

print(response.status_code)  # Código de status
print(response.json())       # Resposta da API

Entenda o que diz o código:

url: endereço do recurso que será consultado;
params: dicionário com parâmetros que serão enviados na URL como query string;
requests.get(): envia a requisição GET para o servidor;
response.status_code: confirma se a requisição foi bem-sucedida (200 = OK);
response.json(): retorna o conteúdo da resposta em formato de dicionário (quando for JSON).

Você pode usar o GET para:

Buscar dados de uma API pública ou privada;
Acessar informações de um produto, cliente ou pedido;
Coletar conteúdo para processamento, como notícias ou cotações de moedas;
Integrar sistemas consultando dados externos.

Veja também:

Dicionário em Python: o guia definitivo para iniciantes

POST

O método POST é usado para enviar dados a um servidor, geralmente para criar um novo recurso. Ao contrário do GET, que envia informações na URL (query string), o POST envia os dados no corpo da requisição.

Sintaxe

requests.post(url, data=None, json=None, headers=None, **kwargs)

requests.post(url, data=None, json=None, headers=None, **kwargs)

Exemplo de uso do método Post

Vamos enviar dados para uma API de teste usando o https://httpbin.org/post, que retorna exatamente o que enviamos.

import requests

url = "https://httpbin.org/post"              # Endpoint de teste
dados = {"nome": "Carlos", "idade": 32}       # Dados a serem enviados

# Envia os dados no formato JSON
response = requests.post(url, json=dados)

print(response.status_code)  # Código de status (200 = sucesso)
print(response.json())       # Resposta da API como dicionário

import requests

url = "https://httpbin.org/post"              # Endpoint de teste
dados = {"nome": "Carlos", "idade": 32}       # Dados a serem enviados

# Envia os dados no formato JSON
response = requests.post(url, json=dados)

print(response.status_code)  # Código de status (200 = sucesso)
print(response.json())       # Resposta da API como dicionário

Entenda o que diz o código:

url: endereço que vai receber os dados;
dados: dicionário Python com as informações a enviar;
requests.post(url, json=dados): envia os dados no corpo da requisição em formato JSON;
response.status_code: mostra se a requisição foi bem-sucedida (200);
response.json(): retorna a resposta do servidor como um dicionário Python.

Na vida real, esse código poderia ser usado para:

Criar novos cadastros em sistemas;
Enviar dados de formulários para APIs;
Integrar Python com plataformas que exigem envio via POST.

Lendo e Escrevendo Arquivos JSON em Python

PUT

O método PUT é usado para atualizar um recurso existente, substituindo todos os seus dados. Em muitas APIs, se algum campo não for enviado, ele pode ser removido no servidor.

Sintaxe

requests.put(url, data=None, json=None, headers=None, **kwargs)

requests.put(url, data=None, json=None, headers=None, **kwargs)

Exemplo de uso do método PUT

Assim como nos exemplos anteriores, vamos usar https://httpbin.org/put para teste. Em um cenário real, você usaria o endpoint de atualização de uma API ou sistema.

import requests

url = "https://httpbin.org/put"               # Endpoint de teste para PUT
dados = {"nome": "Carlos", "idade": 33}       # Dados completos do recurso

# Envia os dados no formato JSON
response = requests.put(url, json=dados)

print(response.status_code)  # Código de status (200 = sucesso)
print(response.json())       # Resposta da API

import requests

url = "https://httpbin.org/put"               # Endpoint de teste para PUT
dados = {"nome": "Carlos", "idade": 33}       # Dados completos do recurso

# Envia os dados no formato JSON
response = requests.put(url, json=dados)

print(response.status_code)  # Código de status (200 = sucesso)
print(response.json())       # Resposta da API

Entenda o que diz o código:

url: endpoint que processa a atualização;
dados: dicionário com as informações completas do recurso (mesmo campos antigos + novos);
requests.put(): substitui todos os dados do recurso com o que foi enviado;
response.json(): confirma o que foi enviado e o resultado.

Na prática, você pode usar esse método PUT para:

Atualizar todos os dados de um perfil de usuário;
Modificar completamente as informações de um produto em um e-commerce;
Substituir registros inteiros em um banco de dados via API.

Veja também:

Como Escrever Dados JSON em um Arquivo em Python

DELETE

O método DELETE remove um recurso do servidor. Geralmente, ele é usado com autenticação para evitar exclusões indevidas.

Sintaxe

requests.delete(url, headers=None, **kwargs)

requests.delete(url, headers=None, **kwargs)

Exemplo de uso do método DELETE

Vamos simular a exclusão de um recurso usando https://httpbin.org/delete:

import requests

url = "https://httpbin.org/delete"            # Endpoint de teste para DELETE

# Envia a requisição de exclusão
response = requests.delete(url)

print(response.status_code)  # Código de status
print(response.json())       # Resposta da API

import requests

url = "https://httpbin.org/delete"            # Endpoint de teste para DELETE

# Envia a requisição de exclusão
response = requests.delete(url)

print(response.status_code)  # Código de status
print(response.json())       # Resposta da API

Entenda o que diz o código:

url: endereço do recurso que será removido;
requests.delete(): envia a instrução de exclusão para o servidor;
response.status_code: confirma se a exclusão foi processada com sucesso (200 ou 204);
response.json(): retorna detalhes (em APIs reais pode ser apenas um status).

Você pode usar esse método DELETE para:

Remover um usuário de um sistema;
Excluir um pedido de compra antes de ser processado;
Apagar um arquivo ou registro de uma API de armazenamento.

Personalizando suas requisições com parâmetros e headers no Requests

Quando você faz requisições HTTP com o Requests Python, pode ser necessário enviar informações extras junto à URL. Essas informações podem ser:

Parâmetros: dados passados na URL para filtrar ou identificar recursos.
Headers (cabeçalhos): pares chave: valor que informam detalhes adicionais da requisição, como autenticação, tipo de conteúdo ou identificação do cliente.

Geralmente, eles são usados para:

Fazer requisições autenticadas em APIs privadas;
Filtrar e buscar dados específicos;
Definir o formato de envio ou retorno de dados (JSON, XML etc.);
Passar informações de contexto ao servidor.

Entenda como usar essas informações a seguir:

Passando parâmetros na URL (`params={}`)

Parâmetros de URL permitem enviar informações adicionais para o servidor sem alterar o corpo da requisição. Eles são adicionados no final da URL, após um ?.

No Requests, crie um dicionário com os parâmetros e passe-o ao argumento params.

Veja esse exemplo:

import requests

url = "https://httpbin.org/get"
params = {"busca": "python", "pagina": 2}

response = requests.get(url, params=params)

print(response.url)          # URL final com parâmetros
print(response.status_code)  # Código de status
print(response.json())       # Resposta em JSON

import requests

url = "https://httpbin.org/get"
params = {"busca": "python", "pagina": 2}

response = requests.get(url, params=params)

print(response.url)          # URL final com parâmetros
print(response.status_code)  # Código de status
print(response.json())       # Resposta em JSON

O que acontece no código:

O dicionário params é convertido para ?busca=python&pagina=2;
O servidor recebe esses valores e os usa para processar a solicitação (por exemplo, fazer uma busca no banco de dados).

Passando headers personalizados

Headers são pares chave: valor que carregam metadados da requisição. Eles informam ao servidor, por exemplo, quem está fazendo a requisição e como o conteúdo deve ser tratado.

Para adicionar headers no Requests, crie um dicionário e passe-o no argumento headers.

Veja esse exemplo:

import requests

url = "https://httpbin.org/get"
headers = {
    "User-Agent": "Meu Agente de Usuário",
    "Authorization": "Bearer token123"
}

response = requests.get(url, headers=headers)

print(response.status_code)  # Código de status
print(response.json())       # Resposta em JSON

import requests

url = "https://httpbin.org/get"
headers = {
    "User-Agent": "Meu Agente de Usuário",
    "Authorization": "Bearer token123"
}

response = requests.get(url, headers=headers)

print(response.status_code)  # Código de status
print(response.json())       # Resposta em JSON

O que acontece no código:

O header User-Agent identifica o cliente que está fazendo a requisição;
O header Authorization envia credenciais (como um token) para acessar APIs privadas.

Como ler e enviar dados em JSON com o Requests?

O JSON (JavaScript Object Notation) é o formato mais usado para troca de informações entre sistemas, principalmente em APIs REST. Ele é simples, leve e pode ser lido facilmente por humanos e máquinas.

E quando você trabalha com APIs no Python usando a biblioteca Requests, o JSON aparece em dois momentos principais:

Ao enviar dados para o servidor (no corpo da requisição).
Ao receber dados do servidor (na resposta).

Entenda o que acontece nessas duas etapas.

Enviando dados no formato JSON

Quando enviamos dados no formato JSON, estamos preenchendo o corpo da requisição (request body). Isso é comum em métodos como POST e PUT para enviar informações a uma API. Por exemplo:

import requests

url = "https://httpbin.org/post"              # Endpoint de teste
payload = {"nome": "Carlos", "idade": 32}     # Dados a serem enviados

response = requests.post(url, json=payload)

print(response.status_code)  # Código de status (200 = sucesso)
print(response.json())       # Resposta convertida em dicionário Python

import requests

url = "https://httpbin.org/post"              # Endpoint de teste
payload = {"nome": "Carlos", "idade": 32}     # Dados a serem enviados

response = requests.post(url, json=payload)

print(response.status_code)  # Código de status (200 = sucesso)
print(response.json())       # Resposta convertida em dicionário Python

Entenda o que acontece no código:

url: endpoint que vai receber os dados (aqui, o httpbin.org para teste);
payload: dicionário Python com as informações que serão enviadas;
requests.post(url, json=payload): envia o payload como JSON, convertendo automaticamente e adicionando o cabeçalho correto;
response.status_code: exibe o código de status HTTP (200 significa sucesso);
response.json(): lê a resposta, converte o JSON retornado em um dicionário Python e imprime o resultado.

Interpretando dados em JSON

Interpretar dados em JSON significa trabalhar com o corpo da resposta, quando o servidor retorna informações nesse formato. E a maioria das APIs modernas envia os dados em JSON.

No Requests, você pode converter esse conteúdo diretamente para um dicionário Python usando o método .json().

Veja esse exemplo:

import requests

url = "https://api.github.com"
response = requests.get(url)

dados = response.json()  # Converte JSON em dicionário

print(dados.keys())               # Lista as chaves
print(dados["current_user_url"])  # Lê um valor específico

import requests

url = "https://api.github.com"
response = requests.get(url)

dados = response.json()  # Converte JSON em dicionário

print(dados.keys())               # Lista as chaves
print(dados["current_user_url"])  # Lê um valor específico

Entenda o que acontece no código:

url: https://api.github.com é o endpoint consultado;
requests.get(url): envia uma requisição GET para buscar os dados;
response.json(): lê o corpo da resposta (em JSON) e converte para um dicionário Python;
dados.keys(): lista todas as chaves retornadas pela API;
dados[“current_user_url”]: acessa diretamente um valor usando a chave correspondente.

Exemplo prático: consumindo uma API pública de dados meteorológicos com Requests

A API pública do Open-Meteo fornece dados meteorológicos sem necessidade de autenticação.

No exemplo abaixo, vamos consultar a temperatura e a velocidade do vento em São Paulo, usando apenas a latitude e longitude.

import requests

# 1. URL da API e parâmetros
url = "https://api.open-meteo.com/v1/forecast"
params = {
    "latitude": -23.55,         # Latitude de São Paulo
    "longitude": -46.63,        # Longitude de São Paulo
    "current_weather": True     # Retorna apenas o clima atual
}

# 2. Fazer a requisição GET com parâmetros
response = requests.get(url, params=params)

# 3. Verificar se a requisição foi bem-sucedida
if response.status_code == 200:
    dados = response.json()  # Converte o JSON em dicionário Python
    
    # 4. Extrair informações específicas
    clima_atual = dados.get("current_weather", {})
    temperatura = clima_atual.get("temperature")
    vento = clima_atual.get("windspeed")
    
    # 5. Imprimir resultados formatados
    print("📍 Clima atual em São Paulo:")
    print(f"🌡️ Temperatura: {temperatura}°C")
    print(f"💨 Velocidade do vento: {vento} km/h")
else:
    print(f"Erro {response.status_code}: não foi possível obter os dados.")

import requests

# 1. URL da API e parâmetros
url = "https://api.open-meteo.com/v1/forecast"
params = {
    "latitude": -23.55,         # Latitude de São Paulo
    "longitude": -46.63,        # Longitude de São Paulo
    "current_weather": True     # Retorna apenas o clima atual
}

# 2. Fazer a requisição GET com parâmetros
response = requests.get(url, params=params)

# 3. Verificar se a requisição foi bem-sucedida
if response.status_code == 200:
    dados = response.json()  # Converte o JSON em dicionário Python
    
    # 4. Extrair informações específicas
    clima_atual = dados.get("current_weather", {})
    temperatura = clima_atual.get("temperature")
    vento = clima_atual.get("windspeed")
    
    # 5. Imprimir resultados formatados
    print("📍 Clima atual em São Paulo:")
    print(f"🌡️ Temperatura: {temperatura}°C")
    print(f"💨 Velocidade do vento: {vento} km/h")
else:
    print(f"Erro {response.status_code}: não foi possível obter os dados.")

Entenda o que esse código faz:

Define a URL e os parâmetros (params): indicam a localização e os dados desejados. Aqui usamos latitude e longitude de São Paulo e current_weather=True para obter apenas as condições atuais;
Envia a requisição GET: requests.get(url, params=params) monta automaticamente a URL final, por exemplo: https://api.open-meteo.com/v1/forecast?latitude=-23.55&longitude=-46.63&current_weather=True;
Verifica o status da resposta: 200 significa sucesso;
Converte a resposta para dicionário Python: usando .json(), facilitando o acesso aos dados;
Extrai valores específicos: temperatura e velocidade do vento da chave "current_weather";
Exibe o resultado: formatado de forma clara para o usuário.

Importante

Você pode alterar latitude e longitude para consultar qualquer cidade do mundo;
Além do clima atual, a API pode fornecer previsão horária ou diária. Para isso, inclua parâmetros extras como hourly ou daily;
Esse padrão funciona para qualquer API pública ou privada: é só ajustar a URL, os parâmetros e as chaves que deseja extrair.

Tratamento de erros e códigos de status

Quando você trabalha com APIs e requisições HTTP, deve verificar se a resposta foi bem-sucedida antes de processar os dados. Isso evita que seu código quebre e permite lidar com problemas de forma controlada.

Para isso, siga os passos abaixo:

Verifique o `response.status_code`

O atributo status_code indica o resultado da requisição. Entenda o que significa esses atributos:

2xx: sucesso (por exemplo, 200 OK, 201 Created);
4xx: erro do cliente (por exemplo, 404 Not Found, 401 Unauthorized);
5xx: erro do servidor (por exemplo, 500 Internal Server Error);

Veja exemplo:

import requests

response = requests.get("https://api.github.com/users/octocat")

if response.status_code == 200:
    print("✅ Requisição bem-sucedida!")
elif response.status_code == 404:
    print("❌ Recurso não encontrado (404)")
elif response.status_code == 401:
    print("🔒 Não autorizado (401) – verifique credenciais")
else:
    print(f"⚠️ Erro {response.status_code}")

import requests

response = requests.get("https://api.github.com/users/octocat")

if response.status_code == 200:
    print("✅ Requisição bem-sucedida!")
elif response.status_code == 404:
    print("❌ Recurso não encontrado (404)")
elif response.status_code == 401:
    print("🔒 Não autorizado (401) – verifique credenciais")
else:
    print(f"⚠️ Erro {response.status_code}")

Entenda o que esse código faz:

import requests: importa a biblioteca Requests para fazer requisições HTTP;
requests.get(…): envia uma requisição GET para a API pública do GitHub, buscando informações sobre o usuário octocat;
if response.status_code == 200: imprime mensagem de sucesso se o servidor respondeu com 200 OK;
elif 404 / 401: trata erros específicos: recurso não encontrado (404) e não autorizado (401);
else: captura qualquer outro código (por exemplo: 500, 403, 429) e exibe mensagem genérica.

Lide com erros comuns em requisições HTTP

Alguns códigos de status HTTP aparecem com frequência nas respostas e merecem atenção especial. Veja os mais comuns:

404 – Not Found: o recurso não existe ou a URL está incorreta;
401 – Unauthorized: é necessário fornecer credenciais válidas (token, login/senha);
403 – Forbidden: acesso negado, mesmo com autenticação (permissão insuficiente);
500 – Internal Server Error: erro no servidor, geralmente temporário;
429 – Too Many Requests: limite de requisições excedido; é preciso aguardar antes de tentar novamente.

Torne o código mais seguro com `try/except`

Métodos HTTP como GET podem gerar exceções se houver problemas de conexão, tempo limite ou URL inválida, por exemplo. Mas usar try/except ajuda a tratar esses casos de forma controlada.

Veja este exemplo:

import requests

url = "https://api.github.com/users/octocat"

try:
    response = requests.get(url, timeout=5)  # Timeout evita travamento
    response.raise_for_status()  # Lança exceção para códigos 4xx e 5xx

    # Se chegou aqui, a resposta foi bem-sucedida
    print(response.json())

except requests.exceptions.HTTPError as errh:
    print(f"Erro HTTP: {errh}")
except requests.exceptions.ConnectionError as errc:
    print(f"Erro de conexão: {errc}")
except requests.exceptions.Timeout as errt:
    print(f"Tempo de espera excedido: {errt}")
except requests.exceptions.RequestException as err:
    print(f"Erro inesperado: {err}")

import requests

url = "https://api.github.com/users/octocat"

try:
    response = requests.get(url, timeout=5)  # Timeout evita travamento
    response.raise_for_status()  # Lança exceção para códigos 4xx e 5xx

    # Se chegou aqui, a resposta foi bem-sucedida
    print(response.json())

except requests.exceptions.HTTPError as errh:
    print(f"Erro HTTP: {errh}")
except requests.exceptions.ConnectionError as errc:
    print(f"Erro de conexão: {errc}")
except requests.exceptions.Timeout as errt:
    print(f"Tempo de espera excedido: {errt}")
except requests.exceptions.RequestException as err:
    print(f"Erro inesperado: {err}")

Esse código faz uma requisição para a API do GitHub e trata possíveis erros de forma controlada:

timeout=5: evita que a requisição fique travada esperando resposta;
response.raise_for_status(): gera uma exceção se o servidor retornar erro HTTP (códigos 4xx ou 5xx);
print(response.json()): exibe o conteúdo da resposta em formato JSON se não houver erros;
Blocos except: tratam diferentes tipos de falhas:
- HTTPError: erro de status HTTP;
- ConnectionError: problemas de conexão;
- Timeout: resposta demorou mais que o limite definido;
- RequestException: qualquer outro erro não previsto.

Boas práticas ao usar a biblioteca Requests

Para manter seu código funcional, eficiente e seguro, siga as práticas abaixo:

Use sessões para múltiplas requisições

Se precisar fazer várias chamadas para o mesmo servidor, utilize requests.Session(). Isso reaproveita conexões abertas, reduzindo tempo de resposta e consumo de recursos.

Defina `timeout` para evitar travamentos

Sempre especifique um tempo máximo de espera (timeout) para suas requisições. Isso impede que o código fique preso indefinidamente e ajuda a prevenir ataques de negação de serviço (DoS).

Valide certificados SSL

A verificação de certificados HTTPS é ativada por padrão no Requests. Nunca desative em produção, porque isso pode expor sua aplicação a ataques man-in-the-middle.

Respeite limites de API (throttling)

A maioria das APIs limita o número de requisições por período. Use pausas (time.sleep) ou controle de taxa para evitar bloqueios temporários.

Evite requisições desnecessárias

Implemente um cache local para armazenar resultados de consultas repetidas. Isso reduz a carga no servidor e deixa o sistema mais rápido.

Registre logs de tentativas e falhas

Mantenha um log com informações sobre requisições e erros. Isso facilita a depuração e o acompanhamento do histórico de comunicação com APIs.

Como aprender a automatizar tarefas com Python do zero?

Dominar a biblioteca Requests é fundamental para trabalhar com dados da web, integrar sistemas e criar automações que realmente fazem diferença no dia a dia.

Com ela, você pode consumir APIs, enviar e receber dados, lidar com autenticação, tratar erros e muito mais! E tudo de forma simples e eficiente.

Mas antes de dominar o Requests, você precisa aprender Python. Para isso, faça o curso gratuito Python para Iniciantes, da Asimov Academy.

Nesse curso, você vai aprender todos os conceitos essenciais de programação Python e construir seu primeiro projeto: um dashboard interativo que exibe os livros mais vendidos na Amazon.

Comece agora e aprenda na prática!

Curso Gratuito

Seu primeiro projeto Python – curso grátis com certificado!

Vá do zero ao primeiro projeto em apenas 2 horas com o curso Python para Iniciantes.

Comece agora

Cursos de programação gratuitos com certificado

Aprenda a programar e desenvolva soluções para o seu trabalho com Python para alcançar novas oportunidades profissionais. Aqui na Asimov você encontra:

Conteúdos gratuitos
Projetos práticos
Certificados
+20 mil alunos e comunidade exclusiva
Materiais didáticos e download de código

Inicie agora

Comentários

30xp

Comentar

Faça parte da discussão Crie sua conta gratuita e compartilhe
sua opinião nos comentários Entre para a Asimov

Conteúdo do artigo

Tags:

Compartilhe

Requests Python: como fazer requisições HTTP de forma simples e prática

Por que usar Requests?

APIs para iniciantes – HTTP, Requests e APIs com Python

Como instalar a biblioteca Requests?

Métodos HTTP mais usados no Request

GET

Dicionário em Python: o guia definitivo para iniciantes

POST

Lendo e Escrevendo Arquivos JSON em Python

PUT

Como Escrever Dados JSON em um Arquivo em Python

DELETE

Personalizando suas requisições com parâmetros e headers no Requests

Passando parâmetros na URL (params={})

Passando headers personalizados

Como ler e enviar dados em JSON com o Requests?

Enviando dados no formato JSON

Interpretando dados em JSON

Exemplo prático: consumindo uma API pública de dados meteorológicos com Requests

Tratamento de erros e códigos de status

Verifique o response.status_code

Lide com erros comuns em requisições HTTP

Torne o código mais seguro com try/except

Boas práticas ao usar a biblioteca Requests

Use sessões para múltiplas requisições

Defina timeout para evitar travamentos

Valide certificados SSL

Respeite limites de API (throttling)

Evite requisições desnecessárias

Registre logs de tentativas e falhas

Como aprender a automatizar tarefas com Python do zero?

Seu primeiro projeto Python – curso grátis com certificado!

Cursos de programação gratuitos com certificado

Comentários

Passando parâmetros na URL (`params={}`)

Verifique o `response.status_code`

Torne o código mais seguro com `try/except`

Defina `timeout` para evitar travamentos