Instalar requests: APIs y pedir datos al mundo exterior

1# requests: la librería más usada para hacer peticiones HTTP
2pip install requests==2.32.3
3
4# Verificar
5python -c "import requests; print(requests.__version__)"
6# Salida: 2.32.3

requests: simple, elegante y usada por millones de proyectos

1import requests
2
3# GET = "dame datos" (la operación más común)
4response = requests.get('https://jsonplaceholder.typicode.com/users')
5
6# Verificar que fue exitosa
7print(f"Status code: {response.status_code}")  # 200 = OK
8
9# Convertir JSON a diccionario/lista Python
10usuarios = response.json()
11
12print(f"Usuarios recibidos: {len(usuarios)}")
13print(f"Primer usuario: {usuarios[0]['name']}")
14print(f"Su email: {usuarios[0]['email']}")
15print(f"Su ciudad: {usuarios[0]['address']['city']}")

Tu primera petición: pedir usuarios a JSONPlaceholder

1import requests
2import pandas as pd
3
4def ingerir_usuarios() -> pd.DataFrame:
5    """Ingiere usuarios desde la API y devuelve un DataFrame limpio."""
6    
7    # 1. Pedir datos
8    response = requests.get('https://jsonplaceholder.typicode.com/users')
9    response.raise_for_status()  # Lanza error si status != 200
10    
11    # 2. Convertir a DataFrame (json_normalize para datos anidados)
12    usuarios = response.json()
13    df = pd.json_normalize(usuarios, sep='_')
14    
15    # 3. Seleccionar y renombrar columnas útiles
16    df = df[['id', 'name', 'email', 'address_city', 'company_name']].rename(columns={
17        'address_city': 'ciudad',
18        'company_name': 'empresa'
19    })
20    
21    # 4. Limpiar
22    df['email'] = df['email'].str.lower()
23    df['ciudad'] = df['ciudad'].str.title()
24    
25    return df
26
27# Ejecutar
28usuarios_df = ingerir_usuarios()
29print(usuarios_df)
30print(f"\nColumnas: {list(usuarios_df.columns)}")

Patrón completo: API → JSON → DataFrame → limpieza

1import requests
2import pandas as pd
3
4# Open-Meteo: API del tiempo gratuita y sin API key
5# Pedir el tiempo de Madrid (lat=40.42, lon=-3.70)
6response = requests.get('https://api.open-meteo.com/v1/forecast', params={
7    'latitude': 40.42,
8    'longitude': -3.70,
9    'daily': 'temperature_2m_max,temperature_2m_min,precipitation_sum',
10    'timezone': 'Europe/Madrid',
11    'forecast_days': 7
12})
13
14response.raise_for_status()
15data = response.json()
16
17# Convertir a DataFrame
18tiempo = pd.DataFrame({
19    'fecha': data['daily']['time'],
20    'temp_max': data['daily']['temperature_2m_max'],
21    'temp_min': data['daily']['temperature_2m_min'],
22    'lluvia_mm': data['daily']['precipitation_sum']
23})
24
25tiempo['fecha'] = pd.to_datetime(tiempo['fecha'])
26print(tiempo)

API del tiempo real: parámetros en la URL filtran los datos pedidos

1import requests
2import time
3
4def pedir_con_reintentos(url: str, params: dict = None, max_intentos: int = 3) -> dict:
5    """Pide datos a una API con reintentos y backoff exponencial."""
6    
7    for intento in range(max_intentos):
8        try:
9            response = requests.get(url, params=params, timeout=10)
10            
11            # 4xx (excepto 429): error del cliente, no reintentar
12            if 400 <= response.status_code < 500 and response.status_code != 429:
13                raise Exception(f"Error {response.status_code}: {response.text[:200]}")
14            
15            response.raise_for_status()
16            return response.json()
17                
18        except requests.exceptions.RequestException as e:
19            if intento < max_intentos - 1:
20                espera = 2 ** intento
21                print(f"Intento {intento+1} fallido: {e}. Esperando {espera}s...")
22                time.sleep(espera)
23            else:
24                print(f"Todos los intentos fallaron para {url}")
25                raise
26    
27    raise Exception(f"Fallaron todos los {max_intentos} intentos para {url}")

Reintentos con backoff exponencial: el patrón que todo pipeline de producción necesita

1import requests
2import pandas as pd
3
4def ingerir_posts_paginados() -> pd.DataFrame:
5    """Ingiere todos los posts de JSONPlaceholder página a página."""
6    todos_los_posts = []
7    page = 1
8    per_page = 10
9    
10    while True:
11        response = requests.get(
12            'https://jsonplaceholder.typicode.com/posts',
13            params={'_page': page, '_limit': per_page}
14        )
15        response.raise_for_status()
16        
17        datos = response.json()
18        if not datos:  # Lista vacía = no hay más páginas
19            break
20        
21        todos_los_posts.extend(datos)
22        print(f"Página {page}: {len(datos)} posts")
23        page += 1
24    
25    df = pd.DataFrame(todos_los_posts)
26    print(f"Total ingerido: {len(df)} posts")
27    return df
28
29posts = ingerir_posts_paginados()
30print(posts.head())

Paginación: pedir datos en bucle hasta que no haya más