Iniciar Teste GratuitoEntrar
Integração

Use a Shifter com Scrapy

Conecte os proxies residenciais e ISP da Shifter a qualquer spider do Scrapy por meio de um pequeno middleware de downloader. Rotação por requisição, sessões fixas e geo-targeting por spider, tudo em 20 linhas de Python.

Início Rápido

Instalar

pip install scrapy

Uso Básico

# settings.py
DOWNLOADER_MIDDLEWARES = {
    "myproject.middlewares.ShifterProxyMiddleware": 350,
    "scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware": 360,
}

# middlewares.py
class ShifterProxyMiddleware:
    PROXY = (
        "customer-USERNAME-country-us-sid-123ABC:"
        "PASSWORD@p.shifter.io:443"
    )

    def process_request(self, request, spider):
        request.meta["proxy"] = self.PROXY

# Run as usual:
# scrapy crawl my_spider

Recursos

Integre-se ao pipeline padrão de downloader-middleware do Scrapy - sem fork ou runtime modificado
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 diretamente com scrapy-playwright, scrapy-splash e scrapy-rotating-proxies
Geo-direcionamento em 195+ países via parâmetros de nome de usuário: country, region, city, ASN
Funciona com Scrapy Cloud, Scrapyd, GitHub Actions, Airflow e qualquer camada de orquestração
Compatível com Scrapy 2.x e Python 3.7+; suporta callbacks tanto síncronos quanto assíncronos

Exemplos

Downloader Middleware (Sessão Fixa)

A forma padrão de conectar um proxy ao Scrapy. Adicione um `sid` ao nome de usuário e todas as requisições do spider compartilharão um único IP residencial. Adicione `country-uk-city-london` para segmentação geográfica.

# myproject/middlewares.py
import secrets

class ShifterProxyMiddleware:
    """Routes every Scrapy request through Shifter's residential pool."""

    def __init__(self, country="us", city=None, ttl=300):
        self.sid = secrets.token_hex(4)
        parts = [
            "customer-USERNAME",
            f"country-{country}",
        ]
        if city:
            parts.append(f"city-{city}")
        parts.append(f"sid-{self.sid}")
        parts.append(f"ttl-{ttl}")
        username = "-".join(parts)

        self.proxy_url = f"http://{username}:PASSWORD@p.shifter.io:443"

    @classmethod
    def from_crawler(cls, crawler):
        s = crawler.settings
        return cls(
            country=s.get("SHIFTER_COUNTRY", "us"),
            city=s.get("SHIFTER_CITY"),
            ttl=s.getint("SHIFTER_TTL", 300),
        )

    def process_request(self, request, spider):
        request.meta["proxy"] = self.proxy_url

# myproject/settings.py
DOWNLOADER_MIDDLEWARES = {
    "myproject.middlewares.ShifterProxyMiddleware": 350,
    "scrapy.downloadermiddlewares.httpproxy.HttpProxyMiddleware": 360,
}

SHIFTER_COUNTRY = "uk"
SHIFTER_CITY    = "london"

Rotação Por Requisição

Não defina um sid, deixe o gateway alternar os IPs a cada requisição. Útil para scraping de alto volume de alvos paginados, onde cada página deve parecer um visitante diferente.

# myproject/middlewares.py
import secrets

class ShifterRotatingMiddleware:
    """Rotates the residential IP on every Scrapy request."""

    PROXY_HOST = "p.shifter.io:443"

    def process_request(self, request, spider):
        # Unique sid per request -> guaranteed new IP for every fetch
        unique_sid = secrets.token_hex(6)
        username   = (
            f"customer-USERNAME-country-{spider.country}"
            f"-sid-{unique_sid}"
        )
        request.meta["proxy"] = (
            f"http://{username}:PASSWORD@{self.PROXY_HOST}"
        )

# myproject/spiders/products.py
import scrapy

class ProductsSpider(scrapy.Spider):
    name    = "products"
    country = "us"  # consumed by the middleware

    custom_settings = {
        "DOWNLOADER_MIDDLEWARES": {
            "myproject.middlewares.ShifterRotatingMiddleware": 350,
        },
        "CONCURRENT_REQUESTS": 32,
    }

    start_urls = [
        f"https://example.com/products?page={i}" for i in range(1, 100)
    ]

    def parse(self, response):
        for card in response.css(".product-card"):
            yield {
                "title": card.css("h2::text").get(),
                "price": card.css(".price::text").get(),
                "url":   response.urljoin(card.css("a::attr(href)").get()),
            }

Spiders Por País (geo-scraping concorrente)

Construa uma classe de spider e parametrize o país em tempo de execução. Execute várias instâncias em paralelo, cada uma com seu próprio pool de IPs residenciais.

# scrapy crawl localized -a country=uk
# scrapy crawl localized -a country=de
# scrapy crawl localized -a country=jp

import scrapy

class LocalizedSpider(scrapy.Spider):
    name = "localized"

    def __init__(self, country="us", *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.country = country
        self.start_urls = [
            f"https://www.example.com/{country}/products",
        ]

    def start_requests(self):
        proxy = (
            f"customer-USERNAME-country-{self.country}-sid-{self.country}-batch:"
            f"PASSWORD@p.shifter.io:443"
        )
        for url in self.start_urls:
            yield scrapy.Request(url, meta={"proxy": proxy}, callback=self.parse)

    def parse(self, response):
        for product in response.css(".product"):
            yield {
                "country": self.country,
                "title":   product.css("h2::text").get(),
                "price":   product.css(".price::text").get(),
            }

Scrapy + scrapy-playwright (páginas renderizadas em JS)

Quando o alvo precisa de JavaScript, troque o downloader por scrapy-playwright. Passe o proxy nas opções de inicialização — o Scrapy continua cuidando do agendamento e dos pipelines.

# pip install scrapy-playwright
# playwright install chromium

# settings.py
DOWNLOAD_HANDLERS = {
    "http":  "scrapy_playwright.handler.ScrapyPlaywrightDownloadHandler",
    "https": "scrapy_playwright.handler.ScrapyPlaywrightDownloadHandler",
}
TWISTED_REACTOR = "twisted.internet.asyncioreactor.AsyncioSelectorReactor"

PLAYWRIGHT_LAUNCH_OPTIONS = {
    "headless": True,
    "proxy": {
        "server":   "http://p.shifter.io:443",
        "username": "customer-USERNAME-country-fr-sid-789GHI",
        "password": "PASSWORD",
    },
}

# spider.py
import scrapy

class JsHeavySpider(scrapy.Spider):
    name = "js_heavy"
    start_urls = ["https://app.example.com/dashboard"]

    def start_requests(self):
        for url in self.start_urls:
            yield scrapy.Request(
                url,
                meta={"playwright": True, "playwright_include_page": True},
                callback=self.parse,
            )

    async def parse(self, response):
        page = response.meta["playwright_page"]
        await page.wait_for_selector(".widget")
        widgets = await page.query_selector_all(".widget")
        for w in widgets:
            yield {"label": await w.text_content()}
        await page.close()
Perguntas Frequentes

Perguntas frequentes

Perguntas comuns sobre usar o Shifter com Scrapy.

Escreva um pequeno middleware de download que define `request.meta['proxy']` para sua URL da Shifter, depois registre-o em DOWNLOADER_MIDDLEWARES com prioridade menor que 750 (para que seja executado antes do HttpProxyMiddleware). Vinte linhas de Python — nenhum SDK necessário.

Gere um sid novo em process_request, por exemplo `secrets.token_hex(6)`, e incorpore-o ao nome de usuário do proxy. Cada requisição receberá um sid diferente e, portanto, um IP residencial diferente do gateway do Shifter. Nenhuma dependência externa de scrapy-rotating-proxies é necessária.

Use um sid fixo para toda a execução do crawl. Gere-o uma vez no início do spider (ou no construtor do middleware) e reutilize-o em todas as requisições. Adicione `ttl-N` para estender a vida útil do IP para N segundos.

Sim. Passe um argumento `-a country=uk` ao executar um spider, exponha-o como uma configuração em custom_settings, ou leia-o dentro do seu middleware. Construa a URL do proxy com `country-uk` no nome de usuário — toda requisição desse spider passará por IPs residenciais do Reino Unido.

Sim. Configure o proxy em PLAYWRIGHT_LAUNCH_OPTIONS — `server`, `username`, `password`. O scrapy-playwright os repassa para a chamada de launch do Playwright, que trata o desafio de autenticação básica no modo headless sem uma extensão.

Sim. Os projetos do Scrapy Cloud são apenas spiders do Scrapy, seu middleware de downloader e a URL de proxy da Shifter vão dentro do tarball do seu projeto. Adicione as credenciais como configurações do projeto no Scrapy Cloud (ou variáveis de ambiente) para que não sejam commitadas no código-fonte.
Começar

Comece a Usar o Shifter com Scrapy

Conecte os proxies residenciais e de ISP com mais de 205 milhões de IPs do Shifter aos seus spiders do Scrapy via um middleware de 20 linhas. Rotação por solicitação, sessões fixas e suporte completo ao scrapy-playwright.

Experimente o Shifter GratuitamenteConfigure em minutos. Cancele quando quiser.