Iniciar Teste GratuitoEntrar
Integração

Use a Shifter com Beautiful Soup

Combine os proxies residenciais e de ISP do Shifter com o Beautiful Soup para um scraping em Python limpo e expressivo. O Beautiful Soup cuida do parsing de HTML, o Shifter cuida dos IPs residenciais, sem necessidade de navegador headless.

Início Rápido

Instalar

pip install beautifulsoup4 requests lxml

Uso Básico

import requests
from bs4 import BeautifulSoup

proxy_url = "customer-USERNAME-country-us-sid-123ABC:PASSWORD@p.shifter.io:443"
proxies   = {"http": proxy_url, "https": proxy_url}

response = requests.get("https://example.com", proxies=proxies, timeout=30)
soup = BeautifulSoup(response.text, "lxml")

print(soup.title.string)
for article in soup.select("article.post"):
    print(article.h2.text.strip(), "->", article.a["href"])

Recursos

Combina perfeitamente com requests, httpx, aiohttp e qualquer cliente HTTP Python que suporte um dicionário de proxies
Rotação por requisição por padrão, com `sid` para sessões persistentes e `ttl-N` para fixações por tempo de N segundos
Compatível com bs4 4.x e Python 3.7+ — funciona com os backends lxml e html.parser
Geo-direcionamento em 195+ países via parâmetros de nome de usuário: country, region, city, ASN
Ordens de magnitude mais rápido que scraping com navegador headless para alvos estáticos ou com pouco JS
Substituição direta para Scrapy, scrapers FastAPI, tarefas Airflow, AWS Lambda e qualquer pipeline de dados Python

Exemplos

Sessão Sticky + Crawl de Múltiplas Páginas

Fixe um IP residencial para todo um rastreamento de paginação adicionando `sid-XXX` ao nome de usuário do proxy. Adicione `country-uk` e `city-london` para segmentação geográfica.

import requests
import secrets
from bs4 import BeautifulSoup
from urllib.parse import urljoin

sid = secrets.token_hex(4)

proxy_url = (
    f"customer-USERNAME-country-uk-city-london-sid-{sid}-ttl-300:"
    f"PASSWORD@p.shifter.io:443"
)

# Use a session so connection pooling and cookies persist across requests.
session = requests.Session()
session.proxies = {"http": proxy_url, "https": proxy_url}
session.headers.update({
    "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
    "Accept-Language": "en-GB,en;q=0.9",
})

products  = []
url       = "https://example.co.uk/products"

while url:
    response = session.get(url, timeout=30)
    soup     = BeautifulSoup(response.text, "lxml")

    for card in soup.select(".product-card"):
        products.append({
            "title": card.select_one("h2").text.strip(),
            "price": card.select_one(".price").text.strip(),
            "url":   urljoin(url, card.select_one("a")["href"]),
        })

    next_link = soup.select_one("a.next-page")
    url       = urljoin(url, next_link["href"]) if next_link else None

print(f"Scraped {len(products)} products")

Scraping Paralelo com concurrent.futures

Remova o sid para rotação por requisição. ThreadPoolExecutor + requests + Shifter escala para dezenas de buscas simultâneas sem acionar limites de taxa por IP.

import requests
from bs4 import BeautifulSoup
from concurrent.futures import ThreadPoolExecutor, as_completed

# No sid -> every request gets a different residential IP.
PROXY_URL = "customer-USERNAME-country-us:PASSWORD@p.shifter.io:443"

def scrape(url: str) -> dict:
    response = requests.get(
        url,
        proxies={"http": PROXY_URL, "https": PROXY_URL},
        headers={"User-Agent": "Mozilla/5.0 AppleWebKit/537.36"},
        timeout=30,
    )
    soup = BeautifulSoup(response.text, "lxml")

    return {
        "url":   url,
        "title": (soup.title.string or "").strip(),
        "h1":    [h.text.strip() for h in soup.select("h1")],
        "links": [a["href"] for a in soup.select("a[href]")[:20]],
    }

urls = [
    "https://example.com/category/laptops",
    "https://example.com/category/phones",
    "https://example.com/category/tablets",
    "https://example.com/category/wearables",
    # ... hundreds more
]

with ThreadPoolExecutor(max_workers=16) as pool:
    futures = {pool.submit(scrape, u): u for u in urls}
    for f in as_completed(futures):
        try:
            result = f.result()
            print(result["url"], "->", result["title"])
        except Exception as exc:
            print("error:", futures[f], exc)

Crawl Robusto com Retentativas + Backoff

O scraping em produção precisa de retentativas em erros 5xx e de conexão. Combine o Retry do urllib3 com o Shifter e um sid novo a cada tentativa para driblar bloqueios temporários.

import requests
import secrets
from bs4 import BeautifulSoup
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

class ShifterClient:
    """requests.Session that rotates the residential IP on retry."""

    def __init__(self, country="us"):
        self.country = country
        self._session = requests.Session()

        retry = Retry(
            total=5,
            backoff_factor=1.5,
            status_forcelist=[429, 500, 502, 503, 504],
            allowed_methods=["GET", "POST", "HEAD"],
        )
        adapter = HTTPAdapter(max_retries=retry, pool_connections=20)
        self._session.mount("http://",  adapter)
        self._session.mount("https://", adapter)

    def _proxy(self) -> str:
        sid = secrets.token_hex(4)
        return (
            f"customer-USERNAME-country-{self.country}-sid-{sid}:"
            f"PASSWORD@p.shifter.io:443"
        )

    def get(self, url: str, **kwargs) -> requests.Response:
        return self._session.get(
            url,
            proxies={"http": self._proxy(), "https": self._proxy()},
            timeout=kwargs.pop("timeout", 30),
            **kwargs,
        )

client   = ShifterClient(country="de")
response = client.get("https://example.de/products")
soup     = BeautifulSoup(response.text, "lxml")

for product in soup.select(".product"):
    print(product.h2.text.strip(), product.select_one(".price").text.strip())

httpx (async) + Beautiful Soup

Se você precisa de fanout assíncrono para milhares de páginas, substitua requests por httpx. Mesma URL do Shifter, async/await nativo, total compatibilidade com Beautiful Soup.

# pip install httpx beautifulsoup4 lxml
import asyncio
import httpx
from bs4 import BeautifulSoup

PROXY = "customer-USERNAME-country-fr-sid-789GHI:PASSWORD@p.shifter.io:443"

async def fetch(client: httpx.AsyncClient, url: str) -> dict:
    resp = await client.get(url, timeout=30)
    soup = BeautifulSoup(resp.text, "lxml")
    return {
        "url":      url,
        "title":    (soup.title.string or "").strip(),
        "headings": [h.text.strip() for h in soup.select("h2")],
    }

async def main():
    async with httpx.AsyncClient(proxy=PROXY) as client:
        urls = [
            f"https://example.fr/products?page={i}" for i in range(1, 51)
        ]
        results = await asyncio.gather(*[fetch(client, u) for u in urls])

    for r in results:
        print(r["url"], "->", r["title"])

asyncio.run(main())
Perguntas Frequentes

Perguntas frequentes

Perguntas comuns sobre usar o Shifter com Beautiful Soup.

Não. Beautiful Soup é um analisador (parser), ele não faz requisições HTTP. O proxy é configurado no cliente HTTP que você combinar com o bs4 (requests, httpx, aiohttp, urllib). Depois que o HTML for obtido através do Shifter, você o passa para BeautifulSoup() normalmente.

Passe um dicionário de proxies para requests.get(): `{"http": "http://USER:PASS@p.shifter.io:443", "https": "..."}`. Use response.text como primeiro argumento para BeautifulSoup(). Para um crawl de múltiplas páginas, reutilize uma requests.Session para que cookies e conexões persistam.

Use o Beautiful Soup para scripts pontuais, notebooks e scrapes de pequeno a médio porte, é mais leve e mais fácil de ler. Use o Scrapy quando precisar de fila embutida, retentativas, persistência e concorrência em escala. Ambos funcionam perfeitamente com a Shifter.

Adicione um ID de sessão ao nome de usuário do proxy, por exemplo, `customer-USERNAME-country-us-sid-123ABC`. Reutilize uma única requests.Session em todas as buscas e o Shifter retornará o mesmo IP residencial. Adicione `ttl-N` para estender a vida útil do IP.

Sim. Combine bs4 com httpx (assíncrono) ou aiohttp. O HTML retornado é idêntico — passe-o para BeautifulSoup() da mesma forma. Para milhares de páginas, o fanout assíncrono é significativamente mais rápido que o ThreadPoolExecutor com requests.

Sim. Shifter é um gateway HTTP / SOCKS5 simples, não um SDK — não há nada incompatível com serverless nisso. Empacote requests + bs4 + lxml na sua camada Lambda, defina a URL do proxy via variável de ambiente e faça as chamadas normalmente.
Começar

Comece a Usar o Shifter com Beautiful Soup

Combine os 205M+ proxies residenciais e de ISP do Shifter com o Beautiful Soup para um scraping em Python limpo e expressivo. Rotação por solicitação, sessões fixas (sticky sessions) e suporte assíncrono completo via httpx.

Experimente o Shifter GratuitamenteConfigure em minutos. Cancele quando quiser.