Ir a la página de inicio
Home / Posts
Compartir en Twitter
Go to Homepage

OBTENER INFORMACIÓN DE UBICACIÓN DE DIRECCIONES IP CON PYTHON

November 28, 2025

Introducción a la obtención de información de ubicación de direcciones IP

En el ámbito de la programación y las noticias tecnológicas, conocer la ubicación geográfica asociada a una dirección IP es una habilidad valiosa. Esta información puede utilizarse en aplicaciones de análisis de tráfico web, seguridad informática, personalización de contenido y más. Python, gracias a su simplicidad y extensas bibliotecas, es una herramienta ideal para este propósito. Este tutorial detalla cómo utilizar la API de ipapi para obtener información de ubicación de direcciones IP, incluyendo ejemplos prácticos, manejo de errores y mejores prácticas actualizadas al 2025.

La API de ipapi proporciona datos como país, ciudad, región, código postal y coordenadas geográficas a partir de una dirección IP. Este servicio es accesible mediante solicitudes HTTP y devuelve respuestas en formato JSON, lo que facilita su integración en aplicaciones Python. A lo largo de este artículo, exploraremos cómo instalar las dependencias necesarias, realizar solicitudes a la API, procesar las respuestas y manejar posibles errores, todo ello con un enfoque profesional y orientado a desarrolladores interesados en tecnología.

Instalación de las dependencias necesarias

Para interactuar con la API de ipapi, necesitamos la biblioteca requests de Python, que permite realizar solicitudes HTTP de manera sencilla. Además, usaremos json para procesar las respuestas de la API. Antes de comenzar, asegúrate de tener Python instalado (versión 3.8 o superior recomendada para compatibilidad con las últimas actualizaciones de las bibliotecas).

Para instalar requests, ejecuta el siguiente comando en tu terminal:

pip install requests

Verifica la instalación importando la biblioteca en un script de Python:

import requests
print(requests.__version__)

Este código mostrará la versión instalada de requests. Si no hay errores, estás listo para continuar. La biblioteca json está incluida en la instalación estándar de Python, por lo que no requiere instalación adicional.

Registro en la API de ipapi

La API de ipapi ofrece un plan gratuito que permite realizar hasta 1000 solicitudes por día, suficiente para pruebas y proyectos pequeños. Para usar la API, debes registrarte en el sitio oficial de ipapi y obtener una clave de acceso. Sigue estos pasos:

  1. Visita el sitio web de ipapi.
  2. Crea una cuenta proporcionando un correo electrónico y una contraseña.
  3. Una vez registrado, recibirás una clave API en el panel de control.

Guarda esta clave, ya que la necesitarás para autenticar las solicitudes. Por seguridad, nunca compartas tu clave API públicamente ni la incluyas directamente en el código fuente si planeas subirlo a un repositorio público. Una práctica recomendada es almacenarla en una variable de entorno.

Para configurar una variable de entorno en tu sistema, puedes usar el siguiente ejemplo en una terminal Unix/Linux o macOS:

export IPAPI_KEY='tu_clave_api'

En Windows, usa:

set IPAPI_KEY=tu_clave_api

Luego, en tu script de Python, accede a la clave con la biblioteca os:

import os
api_key = os.getenv('IPAPI_KEY')

Este enfoque mantiene tu clave segura y facilita la gestión en diferentes entornos.

Realizar una solicitud básica a la API

Con las dependencias instaladas y la clave API configurada, podemos realizar una solicitud básica a la API de ipapi. La URL base para las solicitudes es http://api.ipapi.com/api/. Para consultar una dirección IP específica, añadimos la IP y la clave API como parámetros en la URL.

A continuación, un ejemplo de código que obtiene información de ubicación para la dirección IP 8.8.8.8 (un servidor DNS público de Google):

import requests
import os

api_key = os.getenv('IPAPI_KEY')
ip_address = '8.8.8.8'
url = f'http://api.ipapi.com/api/{ip_address}?access_key={api_key}'

response = requests.get(url)
data = response.json()

print(data)

La respuesta de la API será un diccionario JSON con información detallada. Una salida típica podría verse así:

{
    "ip": "8.8.8.8",
    "type": "ipv4",
    "continent_code": "NA",
    "continent_name": "North America",
    "country_code": "US",
    "country_name": "United States",
    "region_code": "CA",
    "region_name": "California",
    "city": "Mountain View",
    "zip": "94035",
    "latitude": 37.4223,
    "longitude": -122.085,
    "location": {
        "geoname_id": 5375480,
        "capital": "Washington D.C.",
        "languages": [
            {
                "code": "en",
                "name": "English",
                "native": "English"
            }
        ],
        "country_flag": "https://assets.ipapi.com/flags/us.svg",
        "country_flag_emoji": "🇺🇸",
        "country_flag_emoji_unicode": "U+1F1FA U+1F1F8",
        "calling_code": "1",
        "is_eu": false
    }
}

Este resultado incluye el país, la región, la ciudad, el código postal, las coordenadas geográficas y más. Puedes acceder a campos específicos, por ejemplo:

print(f"Ciudad: {data['city']}")
print(f"País: {data['country_name']}")
print(f"Coordenadas: ({data['latitude']}, {data['longitude']})")

Salida esperada:

Ciudad: Mountain View
País: United States
Coordenadas: (37.4223, -122.085)

Este código demuestra cómo realizar una solicitud simple y extraer información relevante. Asegúrate de reemplazar tu_clave_api con tu clave real o usar la variable de entorno.

Manejo de errores en las solicitudes

Las solicitudes a la API pueden fallar por diversas razones, como una clave API inválida, una dirección IP no válida o superar el límite de solicitudes. Es crucial implementar un manejo de errores robusto para garantizar que tu aplicación sea confiable.

La API de ipapi devuelve códigos de estado HTTP y mensajes de error en el cuerpo de la respuesta. Por ejemplo, si la clave API es incorrecta, podrías recibir:

{
    "success": false,
    "error": {
        "code": 101,
        "type": "invalid_access_key",
        "info": "You have not supplied a valid API Access Key."
    }
}

Para manejar estos errores, modifica el código para verificar el estado de la respuesta y el contenido del JSON:

import requests
import os

api_key = os.getenv('IPAPI_KEY')
ip_address = '8.8.8.8'
url = f'http://api.ipapi.com/api/{ip_address}?access_key={api_key}'

try:
    response = requests.get(url)
    response.raise_for_status()  # Lanza una excepción para códigos de estado 4xx/5xx
    data = response.json()

    if data.get('success', True):
        print(f"Ciudad: {data['city']}")
        print(f"País: {data['country_name']}")
        print(f"Coordenadas: ({data['latitude']}, {data['longitude']})")
    else:
        print(f"Error: {data['error']['info']}")
except requests.exceptions.HTTPError as http_err:
    print(f"Error HTTP: {http_err}")
except requests.exceptions.RequestException as err:
    print(f"Error en la solicitud: {err}")
except ValueError as json_err:
    print(f"Error al procesar JSON: {json_err}")

Este código maneja varios escenarios:

  1. Errores HTTP: Verifica si la solicitud falla debido a problemas de red o códigos de estado como 403 o 429.

  2. Errores de la API: Comprueba si la respuesta contiene un campo success con valor false y muestra el mensaje de error.

  3. Errores de JSON: Maneja casos en los que la respuesta no es un JSON válido.

  4. Errores de red: Captura problemas de conexión o tiempo de espera.

Ejemplo de salida en caso de error:

Error: You have not supplied a valid API Access Key.

Este enfoque asegura que tu aplicación pueda manejar fallos de manera elegante y proporcionar mensajes claros al usuario.

Procesamiento avanzado de datos de ubicación

Una vez que obtienes los datos de la API, puedes procesarlos para casos de uso específicos. Por ejemplo, podrías querer almacenar la información en un archivo CSV para análisis posterior o integrarla en una base de datos. A continuación, un ejemplo que guarda los datos de múltiples direcciones IP en un archivo CSV:

import requests
import os
import csv

api_key = os.getenv('IPAPI_KEY')
ip_addresses = ['8.8.8.8', '1.1.1.1', '208.67.222.222']

with open('ubicaciones.csv', mode='w', newline='', encoding='utf-8') as file:
    writer = csv.writer(file)
    writer.writerow(['IP', 'País', 'Ciudad', 'Latitud', 'Longitud'])

    for ip in ip_addresses:
        url = f'http://api.ipapi.com/api/{ip}?access_key={api_key}'
        try:
            response = requests.get(url)
            response.raise_for_status()
            data = response.json()

            if data.get('success', True):
                writer.writerow([
                    ip,
                    data['country_name'],
                    data['city'],
                    data['latitude'],
                    data['longitude']
                ])
            else:
                print(f"Error para {ip}: {data['error']['info']}")
        except requests.exceptions.RequestException as err:
            print(f"Error para {ip}: {err}")

print("Datos guardados en ubicaciones.csv")

Este código consulta tres direcciones IP, extrae información relevante y la guarda en un archivo CSV. La estructura del archivo resultante será:

IP,País,Ciudad,Latitud,Longitud
8.8.8.8,United States,Mountain View,37.4223,-122.085
1.1.1.1,Australia,Sydney,-33.8688,151.2093
208.67.222.222,United States,Reston,38.9389,-77.3462

Puedes abrir este archivo en herramientas como Excel o usarlo en scripts de análisis de datos. Este ejemplo ilustra cómo escalar el uso de la API para procesar múltiples IPs de manera eficiente.

Obtener la dirección IP del usuario

En algunos casos, es útil obtener la dirección IP del dispositivo actual y luego consultar su ubicación. Para ello, puedes usar un servicio como httpbin.org para obtener la IP pública del usuario. A continuación, un ejemplo que combina esta funcionalidad con la API de ipapi:

import requests
import os

# Obtener la IP del usuario
try:
    response = requests.get('https://httpbin.org/ip')
    response.raise_for_status()
    user_ip = response.json()['origin']
    print(f"Tu dirección IP es: {user_ip}")
except requests.exceptions.RequestException as err:
    print(f"Error al obtener la IP: {err}")
    user_ip = None

# Consultar ubicación con ipapi
if user_ip:
    api_key = os.getenv('IPAPI_KEY')
    url = f'http://api.ipapi.com/api/{user_ip}?access_key={api_key}'
    try:
        response = requests.get(url)
        response.raise_for_status()
        data = response.json()

        if data.get('success', True):
            print(f"Ciudad: {data['city']}")
            print(f"País: {data['country_name']}")
            print(f"Coordenadas: ({data['latitude']}, {data['longitude']})")
        else:
            print(f"Error: {data['error']['info']}")
    except requests.exceptions.RequestException as err:
        print(f"Error en la solicitud: {err}")

Salida de ejemplo:

Tu dirección IP es: 192.168.1.100
Ciudad: Buenos Aires
País: Argentina
Coordenadas: (-34.6037, -58.3816)

Este código primero obtiene la IP pública del usuario y luego consulta su ubicación. Es útil para aplicaciones que necesitan personalizar contenido según la ubicación del usuario, como sitios web de noticias tecnológicas que adaptan titulares según la región.

Mejores prácticas para trabajar con la API

Para optimizar el uso de la API de ipapi y garantizar un código robusto, considera las siguientes recomendaciones:

  1. Límite de solicitudes: El plan gratuito permite 1000 solicitudes diarias. Implementa un sistema de caché local para almacenar resultados de IPs consultadas frecuentemente y evitar superar el límite.
  2. Seguridad de la clave API: Usa variables de entorno o un archivo de configuración seguro para almacenar la clave API.
  3. Validación de IPs: Antes de enviar una solicitud, verifica que la dirección IP sea válida usando una expresión regular o una biblioteca como ipaddress:
import ipaddress

def is_valid_ip(ip):
    try:
        ipaddress.ip_address(ip)
        return True
    except ValueError:
        return False

ip = '8.8.8.8'
if is_valid_ip(ip):
    print("IP válida")
else:
    print("IP no válida")
  1. Tiempo de espera: Configura un tiempo de espera en las solicitudes para evitar que el programa se bloquee en caso de problemas de red:
response = requests.get(url, timeout=5)
  1. Monitoreo de errores: Registra los errores en un archivo de log para facilitar la depuración en aplicaciones de producción:
import logging

logging.basicConfig(filename='ipapi_errors.log', level=logging.ERROR)

try:
    response = requests.get(url)
    response.raise_for_status()
except requests.exceptions.RequestException as err:
    logging.error(f"Error para IP {ip_address}: {err}")

Estas prácticas aseguran que tu aplicación sea eficiente, segura y fácil de mantener.

Integración con bases de datos

Para proyectos más complejos, puedes almacenar los datos de ubicación en una base de datos como SQLite. Esto es útil para aplicaciones que necesitan consultar y analizar datos de ubicación de manera persistente. A continuación, un ejemplo que guarda los datos en una base de datos SQLite:

import requests
import os
import sqlite3

api_key = os.getenv('IPAPI_KEY')
ip_addresses = ['8.8.8.8', '1.1.1.1']

# Conectar a la base de datos
conn = sqlite3.connect('ubicaciones.db')
cursor = conn.cursor()

# Crear tabla
cursor.execute('''
    CREATE TABLE IF NOT EXISTS ubicaciones (
        ip TEXT PRIMARY KEY,
        pais TEXT,
        ciudad TEXT,
        latitud REAL,
        longitud REAL
    )
''')

# Consultar y guardar datos
for ip in ip_addresses:
    url = f'http://api.ipapi.com/api/{ip}?access_key={api_key}'
    try:
        response = requests.get(url)
        response.raise_for_status()
        data = response.json()

        if data.get('success', True):
            cursor.execute('''
                INSERT OR REPLACE INTO ubicaciones (ip, pais, ciudad, latitud, longitud)
                VALUES (?, ?, ?, ?, ?)
            ''', (
                ip,
                data['country_name'],
                data['city'],
                data['latitude'],
                data['longitude']
            ))
            conn.commit()
    except requests.exceptions.RequestException as err:
        print(f"Error para {ip}: {err}")

# Consultar datos almacenados
cursor.execute('SELECT * FROM ubicaciones')
rows = cursor.fetchall()
for row in rows:
    print(row)

conn.close()

Salida de ejemplo:

('8.8.8.8', 'United States', 'Mountain View', 37.4223, -122.085)
('1.1.1.1', 'Australia', 'Sydney', -33.8688, 151.2093)

Este código crea una base de datos SQLite, define una tabla para almacenar los datos de ubicación y guarda los resultados de las consultas a la API. Puedes usar esta base de datos para realizar análisis avanzados, como generar informes o visualizaciones.

Conclusiones

La obtención de información de ubicación a partir de direcciones IP es una tarea accesible gracias a Python y la API de ipapi. Este tutorial ha cubierto desde la instalación de dependencias hasta el procesamiento avanzado de datos, incluyendo el manejo de errores, la integración con bases de datos y mejores prácticas para un desarrollo robusto. Con los ejemplos proporcionados, puedes construir aplicaciones que aprovechen datos de geolocalización para casos de uso como análisis de tráfico, personalización de contenido o seguridad informática. Al implementar estas técnicas, estarás bien equipado para integrar capacidades de geolocalización en tus proyectos de programación y contribuir al ecosistema de noticias tecnológicas con soluciones innovadoras.