Démarrer l'essai gratuitSe connecter
Intégration

Utilisez Shifter avec Scrapy

Intégrez les proxies résidentiels et ISP de Shifter dans n'importe quelle araignée Scrapy via un petit middleware de téléchargement. Rotation par requête, sessions persistantes et ciblage géographique par araignée — le tout en 20 lignes de Python.

Démarrage rapide

Installer

pip install scrapy

Utilisation de base

# 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

Fonctionnalités

Intégration dans le pipeline standard de middleware de téléchargement de Scrapy — sans fork ni runtime modifié
Rotation par requête par défaut, avec `sid` pour les sessions persistantes et `ttl-N` pour des épinglages temporisés de N secondes
Compatible directement avec scrapy-playwright, scrapy-splash et scrapy-rotating-proxies
Ciblage géographique dans 195+ pays via des paramètres de nom d'utilisateur : pays, région, ville, ASN
Fonctionne avec Scrapy Cloud, Scrapyd, GitHub Actions, Airflow et toute couche d'orchestration
Compatible avec Scrapy 2.x et Python 3.7+ — prend en charge les callbacks synchrones et asynchrones

Exemples

Middleware de téléchargement (session persistante)

La méthode standard pour brancher un proxy dans Scrapy. Ajoutez un `sid` au nom d'utilisateur et chaque requête de l'araignée partagera une même IP résidentielle. Ajoutez `country-uk-city-london` pour le ciblage géographique.

# 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"

Rotation par requête

Ne définissez pas de sid — laissez la passerelle faire tourner les IP à chaque requête. Utile pour le scraping à fort volume de cibles paginées où chaque page doit sembler provenir d'un visiteur différent.

# 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()),
            }

Araignées par pays (géo-scraping concurrent)

Créez une seule classe d'araignée et paramétrez le pays à l'exécution. Lancez plusieurs instances en parallèle — chacune avec son propre pool d'IP résidentielles.

# 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 (pages rendues en JavaScript)

Lorsque la cible nécessite JavaScript, remplacez le téléchargeur par scrapy-playwright. Passez le proxy dans les options de lancement — Scrapy gère toujours la planification et les 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()
FAQ

Questions fréquentes Questions FAQ

Questions fréquentes sur l'utilisation de Shifter avec Scrapy.

Écrivez un petit middleware de téléchargement qui définit `request.meta['proxy']` sur votre URL Shifter, puis enregistrez-le dans DOWNLOADER_MIDDLEWARES avec une priorité inférieure à 750 (afin qu'il s'exécute avant HttpProxyMiddleware). Vingt lignes de Python — aucun SDK requis.
Commencer

Commencer à utiliser Shifter avec Scrapy

Intégrez les 205M+ proxies résidentiels et ISP de Shifter dans vos spiders Scrapy via un middleware de 20 lignes. Rotation par requête, sessions persistantes et prise en charge complète de scrapy-playwright.

Essayez Shifter gratuitementConfiguration en quelques minutes. Annulez à tout moment.