Configuración de proxy en curl y wget: guía completa

```html

Al hacer scraping de sitios web, automatizar solicitudes de API o monitorear precios de competidores en marketplaces, inevitablemente se encontrará con bloqueos por IP. Las herramientas curl y wget son herramientas estándar para trabajar con solicitudes HTTP en la línea de comandos, y la configuración correcta de proxies en ellas es crítica para eludir las restricciones. En este artículo, analizaremos todas las formas de usar proxies en curl y wget: desde comandos básicos hasta escenarios avanzados con rotación de IP y manejo de errores.

Sintaxis básica de proxy en curl y wget

Comencemos con los comandos más simples para conectarse a través de un proxy. Ambas herramientas admiten un parámetro para especificar el servidor proxy, pero la sintaxis es un poco diferente.

Uso de proxies en curl

En curl, el proxy se especifica a través del parámetro -x o --proxy. El formato básico del comando es:

curl -x http://proxy-server:port http://example.com

Un ejemplo específico con un servidor proxy real:

curl -x http://45.130.123.45:8080 http://api.ipify.org

Este comando enviará una solicitud a api.ipify.org (un servicio que devuelve su dirección IP) a través del servidor proxy especificado. Verá la IP del proxy, no su dirección real.

Uso de proxies en wget

En wget, el proxy se configura a través del parámetro -e use_proxy=yes y variables de entorno, o directamente a través de opciones:

wget -e use_proxy=yes -e http_proxy=http://45.130.123.45:8080 http://example.com

O una versión más corta a través de variables de entorno (más sobre esto en la sección siguiente):

export http_proxy="http://45.130.123.45:8080"
wget http://example.com

Autenticación en el servidor proxy

La mayoría de los servicios de proxy comerciales requieren autenticación con nombre de usuario y contraseña. Esto protege al proxy de usos no autorizados y permite rastrear el tráfico de cada cliente. Veamos cómo transmitir las credenciales en curl y wget.

Autenticación en curl

En curl, el nombre de usuario y la contraseña se pueden especificar directamente en la URL del servidor proxy o a través de un parámetro separado -U:

# Método 1: nombre de usuario y contraseña en la URL
curl -x http://username:password@proxy-server:port http://example.com

# Método 2: a través del parámetro -U
curl -x http://proxy-server:port -U username:password http://example.com

Un ejemplo específico con credenciales:

curl -x http://user123:pass456@45.130.123.45:8080 http://api.ipify.org

Un punto importante: si la contraseña contiene caracteres especiales (@, :, /, ?), deben ser codificados en formato URL. Por ejemplo, el símbolo @ se reemplaza por %40:

# Si la contraseña contiene @: pass@456
curl -x http://user123:pass%40456@45.130.123.45:8080 http://api.ipify.org

Autenticación en wget

En wget, la autenticación se configura a través de los parámetros --proxy-user y --proxy-password:

wget --proxy-user=username --proxy-password=password \
     -e use_proxy=yes -e http_proxy=http://45.130.123.45:8080 \
     http://example.com

O a través de variables de entorno con credenciales en la URL:

export http_proxy="http://username:password@45.130.123.45:8080"
wget http://example.com

Trabajando con diferentes tipos de proxies: HTTP, HTTPS, SOCKS5

Los servidores proxy funcionan con diferentes protocolos, y la elección del tipo depende de la tarea. Los proxies HTTP son adecuados para solicitudes simples, HTTPS proporciona cifrado, y SOCKS5 opera a un nivel más bajo y admite cualquier tráfico. Al hacer scraping en marketplaces como Wildberries o Ozon, a menudo se utilizan proxies residenciales, que pueden operar con cualquiera de estos protocolos.

Proxies HTTP y HTTPS

Los proxies HTTP son el tipo más común. Funcionan a nivel del protocolo HTTP y son adecuados para la mayoría de las tareas de scraping web:

# Proxy HTTP en curl
curl -x http://proxy-server:8080 http://example.com

# Proxy HTTPS en curl (para conexiones seguras)
curl -x https://proxy-server:8080 https://example.com

Importante: incluso si el sitio objetivo utiliza HTTPS, el proxy puede ser HTTP. Curl establecerá automáticamente un túnel mediante el método CONNECT:

# Proxy HTTP para un sitio HTTPS (funciona correctamente)
curl -x http://proxy-server:8080 https://secure-site.com

Proxies SOCKS5

SOCKS5 es un protocolo más versátil que funciona a nivel TCP y admite cualquier tipo de tráfico (HTTP, HTTPS, FTP, incluso UDP). Esto hace que SOCKS5 sea una opción ideal para tareas complejas de automatización:

# SOCKS5 en curl
curl -x socks5://proxy-server:1080 http://example.com

# SOCKS5 con autenticación
curl -x socks5://username:password@proxy-server:1080 http://example.com

# SOCKS5h (resolución DNS a través del proxy)
curl -x socks5h://proxy-server:1080 http://example.com

La diferencia entre socks5 y socks5h: en el primer caso, las solicitudes DNS se realizan desde su computadora, en el segundo, a través del servidor proxy. Use socks5h si desea ocultar completamente su actividad, incluidas las solicitudes DNS.

En wget, el soporte para SOCKS5 es limitado, por lo que para tales tareas es mejor usar curl o utilidades adicionales como proxychains.

Consejo: Para hacer scraping en marketplaces (Wildberries, Ozon, Yandex.Market), se recomienda utilizar proxies residenciales o móviles con protocolo HTTP/HTTPS, ya que son menos propensos a bloqueos, ya que tienen IP de usuarios reales.

Configuración de proxy a través de variables de entorno

Si trabaja regularmente a través de un proxy, es más conveniente configurar las variables de entorno una vez que especificar los parámetros en cada comando. Curl y wget leen automáticamente estas variables.

Configuración para la sesión actual

Exporte las variables en la terminal (son válidas hasta que se cierre la sesión):

# Para tráfico HTTP
export http_proxy="http://username:password@proxy-server:8080"

# Para tráfico HTTPS
export https_proxy="http://username:password@proxy-server:8080"

# Para tráfico FTP
export ftp_proxy="http://username:password@proxy-server:8080"

# Para SOCKS5
export all_proxy="socks5://username:password@proxy-server:1080"

Después de esto, curl y wget usarán automáticamente el proxy:

# El proxy se aplicará automáticamente
curl http://api.ipify.org
wget http://example.com

Configuración permanente en .bashrc o .zshrc

Para que los proxies se apliquen en cada inicio de terminal, agregue las variables al archivo de configuración de su shell:

# Abra el archivo en un editor
nano ~/.bashrc  # para bash
# o
nano ~/.zshrc   # para zsh

# Agregue al final del archivo:
export http_proxy="http://username:password@proxy-server:8080"
export https_proxy="http://username:password@proxy-server:8080"

# Guarde y aplique los cambios:
source ~/.bashrc

Exclusiones: no_proxy

A veces es necesario excluir ciertas direcciones de la proxy (por ejemplo, localhost o servicios internos):

export no_proxy="localhost,127.0.0.1,192.168.0.0/16,.local"

Ahora las solicitudes a estas direcciones irán directamente, omitiendo el proxy.

Rotación de proxies en scripts bash

Al hacer scraping masivo (por ejemplo, recopilando precios de miles de tarjetas de productos en Wildberries), usar un solo proxy resultará en un bloqueo. La solución es la rotación de direcciones IP. Veamos cómo implementar esto en scripts bash.

Rotación simple de una lista de proxies

Cree un archivo proxies.txt con una lista de servidores proxy (uno por línea):

http://user1:pass1@proxy1.example.com:8080
http://user2:pass2@proxy2.example.com:8080
http://user3:pass3@proxy3.example.com:8080

Script para rotación secuencial de proxies:

#!/bin/bash

# Archivo con la lista de URL para hacer scraping
urls_file="urls.txt"
# Archivo con la lista de proxies
proxies_file="proxies.txt"

# Leemos los proxies en un array
mapfile -t proxies < "$proxies_file"
proxy_count=${#proxies[@]}
current_proxy=0

# Procesamos cada URL
while IFS= read -r url; do
    # Elegimos el proxy en círculo
    proxy="${proxies[$current_proxy]}"
    
    echo "Solicitud a $url a través de $proxy"
    curl -x "$proxy" -s "$url" -o "output_$(basename $url).html"
    
    # Cambiamos al siguiente proxy
    current_proxy=$(( (current_proxy + 1) % proxy_count ))
    
    # Pausa entre solicitudes (1-3 segundos)
    sleep $((RANDOM % 3 + 1))
done < "$urls_file"

Este script usa secuencialmente los proxies de la lista, regresando al primero después del último. Una pausa aleatoria entre solicitudes hace que la actividad sea más natural.

Selección aleatoria de proxies

Para mayor imprevisibilidad, se pueden seleccionar proxies al azar:

#!/bin/bash

proxies_file="proxies.txt"
mapfile -t proxies < "$proxies_file"
proxy_count=${#proxies[@]}

while IFS= read -r url; do
    # Selección aleatoria de proxy
    random_index=$((RANDOM % proxy_count))
    proxy="${proxies[$random_index]}"
    
    echo "Solicitud a $url a través del proxy #$random_index"
    curl -x "$proxy" -s "$url" -o "output_$(date +%s).html"
    
    sleep $((RANDOM % 3 + 1))
done < "urls.txt"

Rotación automática a través de la API del servicio de proxy

Muchos proveedores de proxies (incluyendo servicios que ofrecen proxies residenciales) ofrecen rotación automática a través de un único punto de entrada. Utiliza una dirección de proxy, y la IP cambia con cada solicitud o por temporizador:

# Proxy con rotación automática
# La IP cambia con cada solicitud
curl -x http://username:password@rotating.proxy.com:8080 http://api.ipify.org
curl -x http://username:password@rotating.proxy.com:8080 http://api.ipify.org

# Las dos solicitudes anteriores obtendrán diferentes direcciones IP

Esta es la forma más conveniente para el scraping a gran escala: no es necesario gestionar manualmente la lista de proxies.

Envío de encabezados y User-Agent a través de proxies

Los sitios web modernos analizan no solo la dirección IP, sino también los encabezados HTTP de la solicitud. La falta de User-Agent o encabezados sospechosos puede llevar a bloqueos incluso al usar proxies de calidad. Veamos cómo configurar correctamente los encabezados en curl y wget.

User-Agent en curl

User-Agent es un encabezado que identifica el navegador y el sistema operativo. Curl envía por defecto su propio User-Agent (curl/7.x.x), lo que inmediatamente indica automatización. Reemplácelo por un navegador real:

# Chrome en Windows
curl -x http://proxy:8080 \
     -A "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36" \
     http://example.com

# Firefox en macOS
curl -x http://proxy:8080 \
     -A "Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:121.0) Gecko/20100101 Firefox/121.0" \
     http://example.com

Encabezados adicionales

Para una solicitud más realista, agregue encabezados típicos de navegador:

curl -x http://proxy:8080 \
     -H "User-Agent: Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0" \
     -H "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8" \
     -H "Accept-Language: ru-RU,ru;q=0.9,en;q=0.8" \
     -H "Accept-Encoding: gzip, deflate, br" \
     -H "Connection: keep-alive" \
     -H "Upgrade-Insecure-Requests: 1" \
     http://example.com

User-Agent en wget

En wget, el User-Agent se establece a través del parámetro --user-agent:

wget --user-agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0" \
     -e use_proxy=yes -e http_proxy=http://proxy:8080 \
     http://example.com

Aleatorización de User-Agent en scripts

Para scraping a gran escala, es útil alternar el User-Agent para que las solicitudes parezcan de diferentes usuarios:

#!/bin/bash

# Array de User-Agent
user_agents=(
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0 Safari/537.36"
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) Safari/605.1.15"
    "Mozilla/5.0 (X11; Linux x86_64) Firefox/121.0"
    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) Safari/604.1"
)

while IFS= read -r url; do
    # User-Agent aleatorio
    random_ua=${user_agents[$RANDOM % ${#user_agents[@]}]}
    
    curl -x http://proxy:8080 -A "$random_ua" -s "$url"
    sleep 2
done < "urls.txt"

Diagnóstico de problemas y manejo de errores

Al trabajar con proxies, a menudo surgen errores: tiempos de espera, rechazos de conexión, autenticación incorrecta. Veamos cómo diagnosticar y manejar estas situaciones.

Verificación de la funcionalidad del proxy

La forma más sencilla de verificar un proxy es solicitar un servicio que devuelva su IP:

# Verificación de proxy HTTP
curl -x http://proxy:8080 http://api.ipify.org

# Verificación de proxy SOCKS5
curl -x socks5://proxy:1080 http://api.ipify.org

# Con salida de información detallada
curl -x http://proxy:8080 -v http://api.ipify.org

El parámetro -v (verbose) mostrará detalles de la conexión, incluidos encabezados y errores.

Manejo de tiempos de espera

Los proxies lentos o los servidores sobrecargados pueden causar tiempos de espera. Establezca límites de tiempo razonables:

# Tiempo de espera de conexión de 10 segundos, tiempo de espera total de 30 segundos
curl -x http://proxy:8080 --connect-timeout 10 --max-time 30 http://example.com

# En wget
wget --timeout=30 --tries=3 -e http_proxy=http://proxy:8080 http://example.com

Manejo automático de errores en scripts

Script para scraping con cambio automático al siguiente proxy en caso de error:

#!/bin/bash

proxies_file="proxies.txt"
mapfile -t proxies < "$proxies_file"

fetch_with_retry() {
    local url=$1
    local max_attempts=3
    
    for proxy in "${proxies[@]}"; do
        echo "Intento a través del proxy: $proxy"
        
        if curl -x "$proxy" \
                --connect-timeout 10 \
                --max-time 30 \
                -s -f "$url" -o output.html; then
            echo "Éxito con el proxy: $proxy"
            return 0
        else
            echo "Error con el proxy: $proxy, probando el siguiente"
        fi
    done
    
    echo "Todos los proxies están inactivos para $url"
    return 1
}

# Uso
fetch_with_retry "http://example.com/page1"

El parámetro -f hace que curl devuelva un error en los estados HTTP 4xx y 5xx, lo que permite manejar no solo errores de red, sino también bloqueos a nivel de aplicación.

Registro para depuración

Mantenga registros detallados de las solicitudes para analizar problemas:

# Guardar encabezados de respuesta
curl -x http://proxy:8080 -D headers.txt http://example.com

# Registro completo de interacción
curl -x http://proxy:8080 -v http://example.com 2>&1 | tee curl.log

# Solo estado HTTP
curl -x http://proxy:8080 -o /dev/null -s -w "%{http_code}\n" http://example.com

Escenarios prácticos de uso

Analicemos tareas reales donde curl y wget con proxies resuelven problemas comerciales específicos.

Scraping de precios de competidores en marketplaces

Tarea: recopilar precios de 500 productos de competidores en Wildberries para analizar la estrategia de precios. Wildberries bloquea activamente las solicitudes masivas desde una sola IP.

Solución: uso de proxies residenciales con rotación y aleatorización de User-Agent:

#!/bin/bash

# Proxy con rotación automática
PROXY="http://user:pass@rotating-residential.proxy.com:8080"

# Array de User-Agent
user_agents=(
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) Chrome/120.0.0.0"
    "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0) Safari/604.1"
)

# Leemos los ID de productos desde un archivo
while IFS= read -r product_id; do
    ua=${user_agents[$RANDOM % ${#user_agents[@]}]}
    
    curl -x "$PROXY" \
         -A "$ua" \
         -H "Accept-Language: ru-RU,ru;q=0.9" \
         -s "https://www.wildberries.ru/catalog/${product_id}/detail.aspx" \
         -o "products/${product_id}.html"
    
    echo "Producto $product_id descargado"
    sleep $((RANDOM % 5 + 3))  # Pausa de 3-8 segundos
done < product_ids.txt

Monitoreo de disponibilidad de API desde diferentes regiones

Tarea: verificar cómo funciona la API de su servicio para usuarios de diferentes países (geobloqueos, velocidad de respuesta).

Solución: proxies con IP de los países necesarios:

#!/bin/bash

# Proxies de diferentes países
declare -A proxies=(
    ["US"]="http://user:pass@us-proxy.com:8080"
    ["DE"]="http://user:pass@de-proxy.com:8080"
    ["JP"]="http://user:pass@jp-proxy.com:8080"
)

API_URL="https://api.yourservice.com/v1/status"

for country in "${!proxies[@]}"; do
    echo "Verificando desde $country..."
    
    response_time=$(curl -x "${proxies[$country]}" \
                         -s -o /dev/null \
                         -w "%{time_total}" \
                         "$API_URL")
    
    http_code=$(curl -x "${proxies[$country]}" \
                     -s -o /dev/null \
                     -w "%{http_code}" \
                     "$API_URL")
    
    echo "$country: HTTP $http_code, tiempo de respuesta ${response_time}s"
done

Descarga de archivos a través de wget con rotación de proxies

Tarea: descargar un archivo de archivos (imágenes de productos, documentos) de un sitio que limita la velocidad para una sola IP.

#!/bin/bash

proxies_file="proxies.txt"
mapfile -t proxies < "$proxies_file"
proxy_count=${#proxies[@]}
current=0

while IFS= read -r file_url; do
    proxy="${proxies[$current]}"
    filename=$(basename "$file_url")
    
    echo "Descargando $filename a través del proxy #$current"
    
    wget --proxy-user=username --proxy-password=password \
         -e use_proxy=yes -e http_proxy="$proxy" \
         -O "downloads/$filename" \
         "$file_url"
    
    current=$(( (current + 1) % proxy_count ))
    sleep 2
done < file_urls.txt

Pruebas de creatividades publicitarias en diferentes GEO

Tarea: verificar cómo se ven los anuncios de Facebook Ads para usuarios de EE. UU., Canadá y el Reino Unido (diferentes monedas, idiomas, disponibilidad de ofertas).

#!/bin/bash

# Proxies móviles de diferentes países para realismo
declare -A mobile_proxies=(
    ["US"]="http://user:pass@us-mobile.proxy.com:8080"
    ["CA"]="http://user:pass@ca-mobile.proxy.com:8080"
    ["GB"]="http://user:pass@gb-mobile.proxy.com:8080"
)

AD_URL="https://www.facebook.com/ads/library/?id=YOUR_AD_ID"

for country in "${!mobile_proxies[@]}"; do
    curl -x "${mobile_proxies[$country]}" \
         -A "Mozilla/5.0 (iPhone; CPU iPhone OS 17_0) Safari/604.1" \
         -H "Accept-Language: en-US,en;q=0.9" \
         -s "$AD_URL" \
         -o "ads_preview_${country}.html"
    
    echo "Vista previa guardada para $country"
done

Para tales tareas, los proxies móviles son especialmente efectivos, ya que imitan a usuarios reales de smartphones y son menos propensos a levantar sospechas en los sistemas antifraude de Facebook.

Importante para los arbitrajistas: Al verificar creatividades publicitarias a través de proxies, use IP móviles y el User-Agent correspondiente de dispositivos móviles. Facebook analiza la consistencia de los datos (el tipo de dispositivo por User-Agent debe coincidir con el tipo de IP).

Automatización de la verificación de disponibilidad del sitio

Tarea: monitorear la disponibilidad de su sitio cada 5 minutos, simulando solicitudes de usuarios reales (no desde la IP del servidor).

#!/bin/bash

PROXY="http://user:pass@residential.proxy.com:8080"
SITE_URL="https://yoursite.com"
LOG_FILE="uptime.log"

while true; do
    timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    
    http_code=$(curl -x "$PROXY" \
                     -s -o /dev/null \
                     -w "%{http_code}" \
                     --max-time 10 \
                     "$SITE_URL")
    
    if [ "$http_code" -eq 200 ]; then
        echo "[$timestamp] OK - HTTP $http_code" >> "$LOG_FILE"
    else
        echo "[$timestamp] ERROR - HTTP $http_code" >> "$LOG_FILE"
        # Enviar alerta (por ejemplo, a través de la API de Telegram)
        curl -s "https://api.telegram.org/botTOKEN/sendMessage" \
             -d "chat_id=CHAT_ID&text=El sitio no está disponible: HTTP $http_code"
    fi
    
    sleep 300  # 5 minutos
done

Conclusión

Curl y wget son herramientas poderosas para automatizar solicitudes HTTP, y la configuración correcta de proxies las hace indispensables para scraping, monitoreo y pruebas. Hemos cubierto todos los aspectos clave: desde la sintaxis básica hasta escenarios avanzados con rotación de IP, manejo de errores y aleatorización de encabezados.

Principales conclusiones del artículo:

Utilice el parámetro -x en curl y variables de entorno para configurar el proxy
Elija el tipo de proxy según la tarea: HTTP para solicitudes simples, SOCKS5 para versatilidad
Siempre reemplace el User-Agent estándar por uno realista de navegador
Implemente rotación de proxies para scraping a gran escala: esto es crítico para eludir bloqueos
Agregue manejo de errores y tiempos de espera en scripts de producción
Utilice pausas aleatorias entre solicitudes para simular el comportamiento humano

Para tareas que requieren un alto nivel de anonimato y un riesgo mínimo de bloqueos (scraping de marketplaces, verificación de publicidad, monitoreo de competidores), recomendamos utilizar proxies residenciales. Tienen IP de usuarios domésticos reales, lo que hace que sus solicitudes sean indistinguibles del tráfico normal y reduce significativamente la probabilidad de ser incluidos en listas de bloqueo.

Ahora tiene un conjunto completo de herramientas y conocimientos para trabajar de manera efectiva con proxies en curl y wget. Aplique estas técnicas en sus proyectos, adapte ejemplos a tareas específicas y escale la automatización sin temor a bloqueos.

```

Configuración de proxy en curl y wget: guía completa con ejemplos para scraping