Configuração de proxy no curl e wget: guia completo

```html

Ao fazer scraping de sites, automatizar solicitações de API ou monitorar preços de concorrentes em marketplaces, você inevitavelmente encontrará bloqueios por IP. As ferramentas curl e wget são ferramentas padrão para trabalhar com solicitações HTTP na linha de comando, e a configuração correta do proxy nelas é criticamente importante para contornar restrições. Neste artigo, vamos explorar todas as maneiras de usar proxies no curl e wget: desde comandos básicos até cenários avançados com rotação de IP e tratamento de erros.

Sintaxe básica de proxy no curl e wget

Vamos começar com os comandos mais simples para se conectar através de um proxy. Ambas as ferramentas suportam um parâmetro para especificar o servidor proxy, mas a sintaxe é um pouco diferente.

Usando proxy no curl

No curl, o proxy é especificado através do parâmetro -x ou --proxy. O formato básico do comando é:

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

Um exemplo específico com um servidor proxy real:

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

Este comando enviará uma solicitação para api.ipify.org (um serviço que retorna seu endereço IP) através do servidor proxy especificado. Você verá o IP do proxy, e não seu endereço real.

Usando proxy no wget

No wget, o proxy é configurado através do parâmetro -e use_proxy=yes e variáveis de ambiente, ou diretamente através de opções:

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

Ou uma versão mais curta através de variáveis de ambiente (mais sobre isso na seção abaixo):

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

Autenticação no servidor proxy

A maioria dos serviços de proxy comerciais exige autenticação com login e senha. Isso protege o proxy contra uso não autorizado e permite monitorar o tráfego de cada cliente. Vamos ver como passar as credenciais no curl e wget.

Autenticação no curl

No curl, o login e a senha podem ser especificados diretamente na URL do servidor proxy ou através de um parâmetro separado -U:

# Método 1: login e senha na URL
curl -x http://username:password@proxy-server:port http://example.com

# Método 2: através do parâmetro -U
curl -x http://proxy-server:port -U username:password http://example.com

Um exemplo específico com credenciais:

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

Um ponto importante: se a senha contiver caracteres especiais (@, :, /, ?), eles precisam ser codificados no formato URL. Por exemplo, o símbolo @ é substituído por %40:

# Se a senha contiver @: pass@456
curl -x http://user123:pass%40456@45.130.123.45:8080 http://api.ipify.org

Autenticação no wget

No wget, a autenticação é configurada através dos parâmetros --proxy-user e --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

Ou através de variáveis de ambiente com credenciais na URL:

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

Trabalhando com diferentes tipos de proxies: HTTP, HTTPS, SOCKS5

Os servidores proxy operam em diferentes protocolos, e a escolha do tipo depende da tarefa. Proxies HTTP são adequados para solicitações simples, HTTPS fornecem criptografia, e SOCKS5 funcionam em um nível mais baixo e suportam qualquer tráfego. Ao fazer scraping em marketplaces como Wildberries ou Ozon, muitas vezes são utilizados proxies residenciais, que podem operar em qualquer um desses protocolos.

Proxies HTTP e HTTPS

Proxies HTTP são o tipo mais comum. Eles operam no nível do protocolo HTTP e são adequados para a maioria das tarefas de web scraping:

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

# Proxy HTTPS no curl (para conexões seguras)
curl -x https://proxy-server:8080 https://example.com

Importante: mesmo que o site de destino use HTTPS, o proxy pode ser HTTP. O curl automaticamente estabelecerá um túnel através do método CONNECT:

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

Proxies SOCKS5

SOCKS5 é um protocolo mais versátil que opera no nível TCP e suporta qualquer tipo de tráfego (HTTP, HTTPS, FTP, até mesmo UDP). Isso torna o SOCKS5 uma escolha ideal para tarefas complexas de automação:

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

# SOCKS5 com autenticação
curl -x socks5://username:password@proxy-server:1080 http://example.com

# SOCKS5h (resolução DNS através do proxy)
curl -x socks5h://proxy-server:1080 http://example.com

A diferença entre socks5 e socks5h: no primeiro caso, as solicitações DNS vão do seu computador, no segundo — através do servidor proxy. Use socks5h se quiser ocultar completamente sua atividade, incluindo solicitações DNS.

No wget, o suporte a SOCKS5 é limitado, portanto, para essas tarefas, é melhor usar curl ou utilitários adicionais como proxychains.

Dica: Para scraping em marketplaces (Wildberries, Ozon, Yandex.Market), recomenda-se usar proxies residenciais ou móveis com protocolo HTTP/HTTPS — eles são menos propensos a bloqueios, pois têm IPs de usuários reais.

Configurando proxy através de variáveis de ambiente

Se você trabalha regularmente através de proxies, é mais conveniente configurar as variáveis de ambiente uma vez do que especificar os parâmetros em cada comando. O curl e o wget leem automaticamente essas variáveis.

Configuração para a sessão atual

Exporte as variáveis no terminal (valem até o fechamento da sessão):

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

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

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

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

Depois disso, o curl e o wget usarão automaticamente o proxy:

# O proxy será aplicado automaticamente
curl http://api.ipify.org
wget http://example.com

Configuração permanente no .bashrc ou .zshrc

Para que os proxies sejam aplicados em cada inicialização do terminal, adicione as variáveis ao arquivo de configuração do seu shell:

# Abra o arquivo no editor
nano ~/.bashrc  # para bash
# ou
nano ~/.zshrc   # para zsh

# Adicione ao final do arquivo:
export http_proxy="http://username:password@proxy-server:8080"
export https_proxy="http://username:password@proxy-server:8080"

# Salve e aplique as alterações:
source ~/.bashrc

Exceções: no_proxy

Às vezes, é necessário excluir determinados endereços da proxy (por exemplo, localhost ou serviços internos):

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

Agora, as solicitações para esses endereços irão diretamente, sem passar pelo proxy.

Rotação de proxies em scripts bash

Ao fazer scraping em massa (por exemplo, coletando preços de milhares de produtos no Wildberries), o uso de um único proxy levará ao bloqueio. A solução é a rotação de endereços IP. Vamos ver como implementar isso em scripts bash.

Rotação simples de uma lista de proxies

Crie um arquivo proxies.txt com a lista de servidores proxy (um por linha):

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

Script para rotação sequencial de proxies:

#!/bin/bash

# Arquivo com a lista de URLs para scraping
urls_file="urls.txt"
# Arquivo com a lista de proxies
proxies_file="proxies.txt"

# Lê os proxies em um array
mapfile -t proxies < "$proxies_file"
proxy_count=${#proxies[@]}
current_proxy=0

# Processa cada URL
while IFS= read -r url; do
    # Escolhe o proxy em círculo
    proxy="${proxies[$current_proxy]}"
    
    echo "Solicitação para $url através de $proxy"
    curl -x "$proxy" -s "$url" -o "output_$(basename $url).html"
    
    # Muda para o próximo proxy
    current_proxy=$(( (current_proxy + 1) % proxy_count ))
    
    # Pausa entre solicitações (1-3 segundos)
    sleep $((RANDOM % 3 + 1))
done < "$urls_file"

Este script usa sequencialmente os proxies da lista, voltando ao primeiro após o último. A pausa aleatória entre as solicitações torna a atividade mais natural.

Escolha aleatória de proxies

Para maior imprevisibilidade, você pode escolher proxies aleatoriamente:

#!/bin/bash

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

while IFS= read -r url; do
    # Escolha aleatória de proxy
    random_index=$((RANDOM % proxy_count))
    proxy="${proxies[$random_index]}"
    
    echo "Solicitação para $url através do proxy #$random_index"
    curl -x "$proxy" -s "$url" -o "output_$(date +%s).html"
    
    sleep $((RANDOM % 3 + 1))
done < "urls.txt"

Rotação automática através da API do serviço de proxy

Muitos provedores de proxy (incluindo serviços que fornecem proxies residenciais) oferecem rotação automática através de um único ponto de entrada. Você usa um endereço de proxy, e o IP muda a cada solicitação ou de acordo com um timer:

# Proxy com rotação automática
# O IP muda a cada solicitação
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

# As duas solicitações acima obterão endereços IP diferentes

Esta é a maneira mais conveniente para scraping em larga escala — você não precisa gerenciar a lista de proxies manualmente.

Transmitindo cabeçalhos e User-Agent através de proxy

Sites modernos analisam não apenas o endereço IP, mas também os cabeçalhos HTTP da solicitação. A ausência de User-Agent ou cabeçalhos suspeitos pode levar ao bloqueio mesmo ao usar proxies de qualidade. Vamos ver como configurar corretamente os cabeçalhos no curl e wget.

User-Agent no curl

User-Agent é um cabeçalho que identifica o navegador e o sistema operacional. O curl, por padrão, envia seu próprio User-Agent (curl/7.x.x), o que imediatamente indica automação. Substitua-o por um navegador real:

# Chrome no 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 no 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

Cabeçalhos adicionais

Para uma solicitação mais realista, adicione cabeçalhos 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 no wget

No wget, o User-Agent é definido através do 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

Randomização do User-Agent em scripts

Para scraping em larga escala, é útil alternar o User-Agent para que as solicitações pareçam vir de diferentes usuários:

#!/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 aleatório
    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 e tratamento de erros

Ao trabalhar com proxies, frequentemente ocorrem erros: timeouts, falhas de conexão, autenticação incorreta. Vamos ver como diagnosticar e tratar essas situações.

Verificando a funcionalidade do proxy

A maneira mais simples de verificar um proxy é solicitar um serviço que retorna seu IP:

# Verificando proxy HTTP
curl -x http://proxy:8080 http://api.ipify.org

# Verificando proxy SOCKS5
curl -x socks5://proxy:1080 http://api.ipify.org

# Com saída de informações detalhadas
curl -x http://proxy:8080 -v http://api.ipify.org

O parâmetro -v (verbose) mostrará detalhes da conexão, incluindo cabeçalhos e erros.

Tratamento de timeouts

Proxies lentos ou servidores sobrecarregados podem causar timeouts. Defina limites de tempo razoáveis:

# Timeout de conexão de 10 segundos, timeout total de 30 segundos
curl -x http://proxy:8080 --connect-timeout 10 --max-time 30 http://example.com

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

Tratamento automático de erros em scripts

Script para scraping com troca automática para o próximo proxy em caso de erro:

#!/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 "Tentativa através do proxy: $proxy"
        
        if curl -x "$proxy" \
                --connect-timeout 10 \
                --max-time 30 \
                -s -f "$url" -o output.html; then
            echo "Sucesso com o proxy: $proxy"
            return 0
        else
            echo "Erro com o proxy: $proxy, tentando o próximo"
        fi
    done
    
    echo "Todos os proxies estão indisponíveis para $url"
    return 1
}

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

O parâmetro -f faz com que o curl retorne um erro para status HTTP 4xx e 5xx, permitindo tratar não apenas erros de rede, mas também bloqueios a nível de aplicação.

Registro para depuração

Mantenha logs detalhados das solicitações para análise de problemas:

# Salvando cabeçalhos de resposta
curl -x http://proxy:8080 -D headers.txt http://example.com

# Log completo da interação
curl -x http://proxy:8080 -v http://example.com 2>&1 | tee curl.log

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

Cenários práticos de uso

Vamos considerar tarefas reais onde curl e wget com proxies resolvem problemas de negócios específicos.

Scraping de preços de concorrentes em marketplaces

Tarefa: coletar preços de 500 produtos de concorrentes no Wildberries para análise de estratégia de preços. O Wildberries bloqueia ativamente solicitações em massa de um único IP.

Solução: uso de proxies residenciais com rotação e randomização de User-Agent:

#!/bin/bash

# Proxy com rotação 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"
)

# Lê IDs dos produtos de um arquivo
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 "Produto $product_id baixado"
    sleep $((RANDOM % 5 + 3))  # Pausa de 3-8 segundos
done < product_ids.txt

Monitoramento da disponibilidade da API de diferentes regiões

Tarefa: verificar como a API do seu serviço funciona para usuários de diferentes países (geobloqueios, tempo de resposta).

Solução: proxies com IPs dos países desejados:

#!/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 de $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, tempo de resposta ${response_time}s"
done

Baixando arquivos através do wget com rotação de proxies

Tarefa: baixar um arquivo zip de arquivos (imagens de produtos, documentos) de um site que limita a velocidade para um único 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 "Baixando $filename através do 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

Testando criativos publicitários em diferentes GEOs

Tarefa: verificar como os anúncios do Facebook Ads aparecem para usuários dos EUA, Canadá e Reino Unido (diferentes moedas, idiomas, disponibilidade de ofertas).

#!/bin/bash

# Proxies móveis 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 "Prévia salva para $country"
done

Para tais tarefas, proxies móveis são especialmente eficazes, pois imitam usuários reais de smartphones e raramente levantam suspeitas nos sistemas antifraude do Facebook.

Importante para afiliados: Ao verificar criativos publicitários através de proxies, use IPs móveis e os respectivos User-Agent de dispositivos móveis. O Facebook analisa a consistência dos dados (o tipo de dispositivo no User-Agent deve corresponder ao tipo de IP).

Automatizando a verificação da disponibilidade do site

Tarefa: monitorar a disponibilidade do seu site a cada 5 minutos, simulando solicitações de usuários reais (não do IP do 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] ERRO - HTTP $http_code" >> "$LOG_FILE"
        # Enviando alerta (por exemplo, através da API do Telegram)
        curl -s "https://api.telegram.org/botTOKEN/sendMessage" \
             -d "chat_id=CHAT_ID&text=Site indisponível: HTTP $http_code"
    fi
    
    sleep 300  # 5 minutos
done

Conclusão

Curl e wget são ferramentas poderosas para automatizar solicitações HTTP, e a configuração correta de proxies as torna indispensáveis para scraping, monitoramento e testes. Nós cobrimos todos os aspectos-chave: desde a sintaxe básica até cenários avançados com rotação de IP, tratamento de erros e randomização de cabeçalhos.

Principais conclusões do artigo:

Use o parâmetro -x no curl e variáveis de ambiente para configurar proxies
Escolha o tipo de proxy para a tarefa: HTTP para solicitações simples, SOCKS5 para versatilidade
Sempre substitua o User-Agent padrão por um navegador realista
Implemente rotação de proxies para scraping em larga escala — isso é crítico para contornar bloqueios
Adicione tratamento de erros e timeouts em scripts de produção
Use pausas aleatórias entre solicitações para simular comportamento humano

Para tarefas que exigem alto nível de anonimato e risco mínimo de bloqueios (scraping de marketplaces, verificação de anúncios, monitoramento de concorrentes), recomendamos o uso de proxies residenciais. Eles têm IPs de usuários reais, o que torna suas solicitações indistinguíveis do tráfego normal e reduz significativamente a probabilidade de serem incluídas em listas de bloqueio.

Agora você tem um conjunto completo de ferramentas e conhecimentos para trabalhar efetivamente com proxies no curl e wget. Aplique essas técnicas em seus projetos, adapte os exemplos para tarefas específicas e amplie a automação sem medo de bloqueios.

```

Configuração de proxy no curl e wget: guia completo com exemplos para scraping