Integration

Shifter verwenden mit Cheerio

Kombinieren Sie Shifters Residential- und ISP-Proxys mit Cheerio für schnelles, schlankes Node-Scraping. Cheerio übernimmt das jQuery-artige HTML-Parsing, Shifter übernimmt die Residential IPs -- kein Headless-Browser erforderlich.

Schnellstart

Installieren

npm install cheerio axios https-proxy-agent

Grundlegende Nutzung

import axios from "axios";
import { HttpsProxyAgent } from "https-proxy-agent";
import { load } from "cheerio";

const proxyUrl =
  "customer-USERNAME-country-us-sid-123ABC:PASSWORD@p.shifter.io:443";

const { data: html } = await axios.get("https://example.com", {
  httpsAgent: new HttpsProxyAgent(proxyUrl),
  proxy: false,
});

const $ = load(html);
console.log($("h1").text());

$("article.post").each((_, el) => {
  console.log($(el).find("h2").text(), "->", $(el).find("a").attr("href"));
});

Funktionen

Funktioniert reibungslos mit axios, got, got-scraping, undici und jedem HTTP-Client, der eine Proxy-URL unterstützt

Standardmäßig Rotation pro Anfrage, mit `sid` für Sticky Sessions und `ttl-N` für zeitgesteuerte Pins von N Sekunden

Kompatibel mit Crawlee, Apify und jedem Produktions-Crawler-Framework, das eine Proxy-URL akzeptiert

Geo-Targeting in 195+ Ländern über Benutzernamensparameter -- country, region, city, ASN

Größenordnungsmäßig schneller als Headless-Browser-Scraping für statische oder JS-leichte Ziele

Kompatibel mit TypeScript, ESM, CommonJS und jeder Node.js LTS-Version ab 14

Beispiele

Sticky Session + mehrseitiger Crawl

Pinnen Sie eine Residential IP für die Dauer eines mehrseitigen Crawls. Fügen Sie `country-uk` für Geo-Targeting und `ttl-300` hinzu, um das Sticky-Fenster auf 5 Minuten zu verlängern.

import axios, { type AxiosInstance } from "axios";
import { HttpsProxyAgent } from "https-proxy-agent";
import { load } from "cheerio";
import { randomBytes } from "node:crypto";

function makeClient(country: string): AxiosInstance {
  const sid = randomBytes(4).toString("hex");
  const proxyUrl =
    `customer-USERNAME-country-${country}-sid-${sid}-ttl-300:` +
    `PASSWORD@p.shifter.io:443`;

  return axios.create({
    httpsAgent: new HttpsProxyAgent(proxyUrl),
    proxy: false,
    timeout: 30_000,
    headers: {
      "User-Agent":
        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36",
      "Accept-Language": "en-US,en;q=0.9",
    },
  });
}

const client = makeClient("uk");

let url: string | null = "https://example.co.uk/products";
const products: { title: string; price: string }[] = [];

while (url) {
  const { data: html } = await client.get(url);
  const $ = load(html);

  $(".product-card").each((_, el) => {
    products.push({
      title: $(el).find("h2").text().trim(),
      price: $(el).find(".price").text().trim(),
    });
  });

  const next = $("a.next-page").attr("href");
  url = next ? new URL(next, url).toString() : null;
}

console.log(`Scraped ${products.length} products`);

Paralleles Scraping (Rotation pro Anfrage)

Lassen Sie die sid für die Rotation pro Anfrage weg. Jeder parallele Abruf erhält eine andere Residential IP -- ideal, um eine Liste von URLs abzurufen, ohne IP-basierte Rate-Limits auszulösen.

import axios from "axios";
import { HttpsProxyAgent } from "https-proxy-agent";
import { load } from "cheerio";

function rotatingClient() {
  // No sid -> Shifter rotates the residential IP per request.
  const proxyUrl =
    "customer-USERNAME-country-us:PASSWORD@p.shifter.io:443";

  return axios.create({
    httpsAgent: new HttpsProxyAgent(proxyUrl),
    proxy: false,
    timeout: 30_000,
  });
}

async function scrape(url: string) {
  const client = rotatingClient();
  const { data: html } = await client.get(url);
  const $ = load(html);

  return {
    url,
    title: $("h1").first().text().trim(),
    headings: $("h2").map((_, el) => $(el).text().trim()).get(),
  };
}

const urls = [
  "https://example.com/category/laptops",
  "https://example.com/category/phones",
  "https://example.com/category/tablets",
  "https://example.com/category/wearables",
];

const results = await Promise.all(urls.map(scrape));
console.log(results);

got-scraping (integrierte Browser-Fingerprints)

got-scraping bündelt realistische Header-Generierung auf Basis von got. Kombinieren Sie es mit Shifter für einen kompakten, browsertypischen HTTP-Scraper, der dennoch 100x schneller als Puppeteer ist.

// npm install got-scraping cheerio
import { gotScraping } from "got-scraping";
import { load } from "cheerio";

const proxyUrl =
  "customer-USERNAME-country-de-city-berlin-sid-456DEF:PASSWORD@p.shifter.io:443";

const html = await gotScraping({
  url: "https://example.de/products",
  proxyUrl,
  headerGeneratorOptions: {
    browsers: [{ name: "chrome", minVersion: 120 }],
    devices: ["desktop"],
    locales: ["de-DE", "en"],
    operatingSystems: ["macos", "linux"],
  },
}).text();

const $ = load(html);

$(".product").each((_, el) => {
  console.log({
    title: $(el).find("h2").text().trim(),
    price: $(el).find(".price").text().trim(),
  });
});

Crawlee (Produktions-Crawler mit Shifter)

Crawlee (von Apify) verwaltet Queues, Wiederholungsversuche, Persistenz und Proxy-Rotation von Haus aus. Binden Sie Shifter als ProxyConfiguration ein und lassen Sie Crawlee den Rest orchestrieren.

// npm install crawlee cheerio
import { CheerioCrawler, ProxyConfiguration } from "crawlee";

const proxyConfiguration = new ProxyConfiguration({
  newUrlFunction: () => {
    // New residential IP per session. Crawlee rotates sessions
    // automatically on bans, so stale IPs get cycled out.
    const sid = Math.random().toString(36).slice(2, 10);
    return `customer-USERNAME-country-fr-sid-${sid}:PASSWORD@p.shifter.io:443`;
  },
});

const crawler = new CheerioCrawler({
  proxyConfiguration,
  maxConcurrency: 8,
  async requestHandler({ request, $, enqueueLinks, log }) {
    log.info(`${request.url} -> ${$("h1").text().trim()}`);

    $(".article").each((_, el) => {
      log.info(`  ${$(el).find("h2").text().trim()}`);
    });

    await enqueueLinks({ selector: "a.next-page", strategy: "same-domain" });
  },
});

await crawler.run([
  "https://example.fr/blog",
  "https://example.fr/news",
]);

FAQ

Häufig gestellte Fragen

Häufige Fragen zur Verwendung von Shifter mit Cheerio.

Nein. Cheerio ist ein Parser -- er stellt keine HTTP-Anfragen. Der Proxy wird auf dem jeweiligen HTTP-Client konfiguriert, den Sie mit Cheerio kombinieren (axios, got, undici, fetch). Sobald das HTML über Shifter abgerufen wurde, übergeben Sie es wie gewohnt an Cheerios load()-Funktion.

Konfigurieren Sie axios mit einem https-proxy-agent, der auf p.shifter.io:443 zeigt (mit Anmeldedaten inline). Rufen Sie die Seite ab, übergeben Sie response.data an cheerio.load() und fragen Sie dann wie mit jQuery ab. Das vollständige Setup umfasst etwa 10 Codezeilen.

Verwenden Sie Cheerio, wenn die benötigten Daten im initialen HTML-Payload enthalten sind -- es ist 10-100x schneller als Headless Chrome und benötigt nur einen Bruchteil des Arbeitsspeichers. Wechseln Sie zu Puppeteer oder Playwright nur dann, wenn die Seite Inhalte clientseitig per JavaScript hydratisiert.

Fügen Sie dem Proxy-Benutzernamen eine Session-ID hinzu -- zum Beispiel `customer-USERNAME-country-us-sid-123ABC`. Verwenden Sie dieselbe axios-Instanz für alle Anfragen im Crawl-Durchlauf, und Shifter gibt stets dieselbe Residential IP zurück. Fügen Sie `ttl-N` hinzu, um die Lebensdauer zu verlängern.

Ja. Crawlee wird mit einem CheerioCrawler geliefert, der Warteschlangen, Wiederholungsversuche und Parallelität verwaltet. Konfigurieren Sie Shifter über Crawlees ProxyConfiguration mit einer newUrlFunction, die pro Session eine neue Shifter-URL mit einer eindeutigen sid zurückgibt.

Ja. got-scraping akzeptiert eine `proxyUrl`-Option und verhandelt die Proxy-Verbindung transparent. In Kombination mit dem integrierten Header-Generator (der echte Browser-Fingerprints nachahmt) ist es eine hervorragende, schlanke Alternative zu Headless-Browsern.

Jetzt starten