So scrapen Sie Amazon-Suchergebnisse mit Next.jseine Full-Stack-Scraping-Route

Amazons Suchergebnisseite gehört zu den reichhaltigsten öffentlichen Datensätzen im E-Commerce: Jede Suchanfrage gibt ein gerankt sortiertes Raster von Produkten mit Titeln, Preisen, Bewertungen, Rezensionszahlen und einem Link zu jedem Angebot zurück. Zu verfolgen, wie sich dieses Raster im Laufe der Zeit verändert, zeigt Ihnen, was verkauft wird, wo ein Mitbewerber für ein Keyword steht und wie sich Preise in einer Kategorie entwickeln. Die Daten sind öffentlich, aber sie zuverlässig aus einem Skript abzurufen, ist der schwierige Teil, denn Amazon rendert große Teile der Seite mit JavaScript und fordert automatisierten Datenverkehr schnell heraus.

Dieser Leitfaden zeigt Ihnen, wie Sie die Amazon-SERP mit Next.js scrapen, auf dem Full-Stack-Weg. Sie erstellen eine kleine, ausführbare Next.js-App, deren Server Action die Crawling API aufruft, um eine gerenderte Amazon-Suchseite abzurufen, jedes Produkt mit Cheerio parst und die Ergebnisse in einem React-Raster rendert. Das Crawlbase-Token bleibt dabei die ganze Zeit serverseitig und wird nie an den Browser weitergegeben. Die Anleitung beschränkt sich auf öffentliche Suchdaten, und der Rechtsabschnitt am Ende ist kein Boilerplate, lesen Sie ihn also, bevor Sie dies auf reales Volumen anwenden. Wenn Sie stattdessen die einfache Skript-Version möchten, lesen Sie Amazon-Suchseiten mit der Crawling API scrapen.

Was Sie erstellen werden

Eine Next.js-App (App Router) mit einer Server Action, die ein Such-Keyword entgegennimmt, die gerenderte Amazon-SERP über die Crawling API abruft, sie mit Cheerio parst und einen strukturierten Datensatz pro Produkt an eine Client-Komponente zurückgibt, die das Raster rendert. Wir erfassen diese Felder pro Artikel:

• Name der Produkttitel wie auf der Karte angezeigt, z. B. "Apple iPhone 15 Pro Max 256GB".
• Preis der angezeigte Preis, z. B. "$1.199,00".
• Bild die Produkt-Thumbnail-URL für das Rendern der Karte.
• Bewertung der Sternbewertungstext, wenn vorhanden, z. B. "4.7 out of 5 stars".
• Rezensionen die neben der Bewertung angezeigte Kundenrezensionszahl.
• URL der absolute Link zur einzelnen Produktseite.

Warum eine einfache Anfrage bei Amazon scheitert

Wenn Sie eine Amazon-Such-URL mit einem einfachen HTTP-Client abrufen, erhalten Sie selten das saubere Produktraster, das Sie im Browser sehen. Zwei Dinge arbeiten gegen Sie. Erstens rendert Amazon Preise, Bewertungen und Teile jeder Ergebniskarte im Browser mit JavaScript, sodass das rohe HTML unvollständig zurückkommen kann. Zweitens erkennt Amazon automatisierten Datenverkehr schnell: Rechenzentrum-IPs und Anfragemuster, die nicht wie ein echter Browser aussehen, erhalten ein CAPTCHA, eine "Robot-Check"-Zwischenseite oder eine vollständige Sperrung, lange bevor Sie die Produkte erreichen.

Ein funktionierender Amazon-SERP-Scraper benötigt also zwei Dinge in einer einzigen Anfrage: einen Browser, der die Seite tatsächlich rendert, und eine IP, die die Plattform als echten Besucher liest. Sie können das selbst mit einem Headless-Browser und einem Pool von rotierenden Wohngebiets-Proxys zusammenstellen, aber diese zu verbinden und funktionsfähig zu halten, ist der größte Teil der Arbeit. Die Crawling API vereint beides in einem einzigen Aufruf: Sie senden ihr die URL mit einem JavaScript-Token, sie rendert die Seite hinter einer vertrauenswürdigen IP und gibt fertiges HTML zum Parsen zurück. Dies in einer Next.js-Server-Action zu tun, hält Ihr Token clientseitig aus dem Spiel und den Abruf auf dem Server, genau wo er hingehört.

Voraussetzungen

Sie benötigen einige Dinge, bevor Sie Code schreiben. Keines davon nimmt viel Zeit in Anspruch.

Node.js 18.17 oder höher. Next.js benötigt eine aktuelle Node-Laufzeitumgebung. Überprüfen Sie Ihre Version mit node --version. Falls Sie es nicht haben, installieren Sie es von der Node.js-Website oder über einen Versionsmanager wie nvm.

Grundlegende React- und Next.js-Kenntnisse. Sie sollten mit React-Komponenten, Hooks und dem Ausführen einer Next.js-App vertraut sein. Falls App Router und Server Actions neu für Sie sind, decken die offiziellen Next.js-Dokumente beides ab, und unser Leitfaden zum Aufbau eines Web-Scrapers mit Node.js ist eine gute Ergänzung für den Scraping-Teil.

Ein Crawlbase-Konto und ein JS-Token. Registrieren Sie sich, öffnen Sie Ihr Dashboard und kopieren Sie Ihr JavaScript-Token (JS-Token) von der Konto-Dokumentationsseite. Behandeln Sie das Token wie ein Passwort: Es authentifiziert Ihre Anfragen, also halten Sie es serverseitig und aus der Versionskontrolle heraus. Wir lesen es aus einer Umgebungsvariable, ohne es jemals in einer Client-Komponente hartzukodieren.

Projekt einrichten

Richten Sie eine Next.js-App ein und installieren Sie dann die zwei Bibliotheken, die der Scraper benötigt. Wenn der Create-Assistent fragt, wählen Sie den App Router; die übrigen Standardeinstellungen sind in Ordnung.

node --version

npx create-next-app@latest amazon-serp-scraper
cd amazon-serp-scraper

npm install crawlbase cheerio

Zwei Abhängigkeiten erledigen die Arbeit: crawlbase ist der offizielle Node-Client für die Crawling API, und cheerio parst das zurückgegebene HTML mit einer jQuery-ähnlichen API, sodass Sie einzelne Felder per CSS-Selektor herausziehen können. Falls Selektoren neu für Sie sind, ist der Leitfaden zu XPath und CSS-Selektoren eine gute Ergänzung. Legen Sie nun Ihr Token in einer Env-Datei im Projektstamm ab, damit es serverseitig bleibt:

# .env.local (never commit this file)
CRAWLBASE_JS_TOKEN=YOUR_CRAWLBASE_TOKEN

Da CRAWLBASE_JS_TOKEN kein NEXT_PUBLIC_-Präfix hat, hält Next.js es auf dem Server und bündelt es nie in Client-JavaScript. Das ist der gesamte Punkt des Abrufs in einer Server Action.

Schritt 1: Die gerenderte SERP in einer Server Action abrufen

Erstellen Sie app/actions.js. Die Direktive 'use server' am Anfang markiert alles in der Datei als Server Action, sodass dieser Code nur jemals auf dem Server ausgeführt wird, wo das Token sicher ist. Importieren Sie den CrawlingAPI-Client, lesen Sie das Token aus der Umgebung und fordern Sie die aus dem Keyword aufgebaute Amazon-Such-URL an. Das Überprüfen des Statuscodes vor dem Parsen hält Fehler sichtbar statt still.

'use server';

const { CrawlingAPI } = require('crawlbase');

const api = new CrawlingAPI({ token: process.env.CRAWLBASE_JS_TOKEN });

async function fetchSerpHtml(keyword) {
  const query = encodeURIComponent(keyword.trim());
  const pageUrl = `https://www.amazon.com/s?k=${query}`;
  const options = { ajax_wait: 'true', page_wait: 5000 };
  const response = await api.get(pageUrl, options);
  if (response.statusCode === 200) {
    return response.body;
  }
  console.error(`Request failed: ${response.statusCode}`);
  return null;
}

Die beiden Warte-Optionen sind wichtig für ein clientseitig gerendertes Ziel wie dieses. ajax_wait weist die API an, zu warten, bis asynchrone Inhalte fertig geladen sind, und page_wait wartet nach dem Laden eine festgelegte Anzahl von Millisekunden, damit spät gerenderte Elemente erscheinen, bevor die Seite erfasst wird. Fünf Sekunden sind ein vernünftiger Startpunkt; erhöhen Sie den Wert, wenn Preise oder Bewertungen leer zurückkommen. An diesem Punkt haben Sie serverseitig abgerufenes Amazon-HTML in der Hand, mit dem Token außerhalb des Browsers. Das bestätigt, dass das Rendering funktioniert, bevor Sie einen einzigen Selektor schreiben.

Schritt 2: Jedes Produkt mit Cheerio parsen

Mit gerenderetem HTML in der Hand laden Sie es in Cheerio und gehen durch die Ergebniskarten. Amazon legt jedes Suchergebnis in einem sich wiederholenden Block aus, der mit div[data-component-type="s-search-result"] getaggt ist. Sie wählen also jede Karte aus und lesen dann Name, Preis, Bild, Bewertung, Rezensionszahl und den Produktlink darin. Das defensive Lesen jedes Feldes verhindert, dass ein fehlender Wert den Durchlauf zum Absturz bringt. Fügen Sie diese Funktion derselben Datei app/actions.js hinzu.

const cheerio = require('cheerio');

function parseProducts(html) {
  const $ = cheerio.load(html);
  const products = [];

  $('div[data-component-type="s-search-result"]').each((_, el) => {
    const card = $(el);
    const name = card.find('h2 span').first().text().trim();
    if (!name) return;

    const path = card.find('h2 a').attr('href');

    products.push({
      name,
      price: card.find('.a-price .a-offscreen').first().text().trim() || null,
      image: card.find('img.s-image').attr('src') || null,
      rating: card.find('.a-icon-alt').first().text().trim() || null,
      reviews: card.find('.a-size-base.s-underline-text').first().text().trim() || null,
      url: path ? `https://www.amazon.com${path}` : null,
    });
  });

  return products;
}

Einige Details machen das robust. Der Preis befindet sich in einem versteckten .a-offscreen-Span innerhalb des .a-price-Blocks, was die sauberste einzelne Quelle für den angezeigten Betrag ist. Wir lesen diesen, anstatt Symbol und Ziffern zusammenzusetzen. Jedes Feld fällt auf null zurück, wenn das Element fehlt, was bei gesponserten Karten und manchen Angeboten vorkommt, die eine Bewertung oder eine Rezensionszahl weglassen. Der Produktlink ist ein relativer Pfad, also setzen wir den Amazon-Ursprung davor, um eine absolute, klickbare URL zu erhalten.

Schritt 3: Eine Server Action und die Datenform bereitstellen

Verbinden Sie nun Abruf und Parse zu einer einzigen exportierten Server Action, die Ihre Benutzeroberfläche aufrufen kann. Sie nimmt ein Keyword, gibt die geparsten Produkte zurück und lässt das Token nie zum Client durchsickern, da all das in der 'use server'-Datei bleibt. Fügen Sie das am Ende von app/actions.js hinzu.

export async function scrapeAmazonProducts(keyword) {
  if (!keyword || !keyword.trim()) return { products: [], error: 'Empty search' };
  try {
    const html = await fetchSerpHtml(keyword);
    if (!html) return { products: [], error: 'Fetch failed' };
    const products = parseProducts(html);
    return { products, error: null };
  } catch (err) {
    console.error(err);
    return { products: [], error: 'Something went wrong' };
  }
}

Ein einfaches { products, error }-Objekt zurückzugeben, anstatt zu werfen, hält die Client-Komponente einfach: Sie kann das Raster rendern, wenn products Zeilen hat, und eine Meldung anzeigen, wenn error gesetzt ist, ohne im UI verstreute try/catch-Blöcke. Alles oben läuft auf dem Server, sodass Token, Crawling-API-Aufruf und Cheerio-Parse vollständig aus dem Browser-Bundle bleiben.

Schritt 4: Die Ergebnisse in einem React-Raster rendern

Die Client-Seite ist klein. Eine einzelne Client-Komponente hält den Suchzustand, ruft die Server Action bei der Übermittlung auf und ordnet die zurückgegebenen Produkte in Karten zu. Erstellen Sie app/page.jsx mit der Direktive 'use client', damit sie React-Hooks nutzen kann, importieren und rufen Sie die Action dann direkt auf; Next.js übernimmt den Server-Round-Trip für Sie.

'use client';

import { useState } from 'react';
import { scrapeAmazonProducts } from './actions';

export default function Home() {
  const [keyword, setKeyword] = useState('');
  const [products, setProducts] = useState([]);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState(null);

  async function handleSubmit(event) {
    event.preventDefault();
    setLoading(true);
    setError(null);
    const result = await scrapeAmazonProducts(keyword);
    setProducts(result.products);
    setError(result.error);
    setLoading(false);
  }

  return (
    <main className="container">
      <form onSubmit={handleSubmit}>
        <input
          value={keyword}
          onChange={(e) => setKeyword(e.target.value)}
          placeholder="Search Amazon (iPhone, laptop, headphones...)"
        />
        <button type="submit" disabled={loading}>
          {loading ? 'Searching...' : 'Search'}
        </button>
      </form>

      {error && <p className="error">{error}</p>}

      <div className="grid">
        {products.map((product, i) => (
          <a key={i} href={product.url} target="_blank" className="card">
            {product.image && <img src={product.image} alt={product.name} />}
            <h3>{product.name}</h3>
            <p className="price">{product.price}</p>
            <p className="rating">{product.rating} ({product.reviews || 0})</p>
          </a>
        ))}
      </div>
    </main>
  );
}

Das ist das gesamte Frontend. Das Formular aktualisiert keyword bei jedem Tastendruck; bei der Übermittlung setzt es ein Lade-Flag, wartet auf die Server Action und speichert die zurückgegebenen Produkte und Fehler. Das Raster ordnet jedes Produkt in eine Karte zu, die in einem neuen Tab auf das Amazon-Angebot verlinkt. Gestalten Sie es mit Tailwind oder normalem CSS nach Belieben; der Datenfluss ist das Entscheidende. Starten Sie die App mit npm run dev, öffnen Sie localhost:3000, suchen Sie nach etwas wie "iPhone 15 Pro Max" und die gerenderten, geparsten Produkte erscheinen im Raster.

Wie die Ausgabe aussieht

Die Server Action gibt ein sauberes Array von Datensätzen zurück, einen pro Produkt, bevor es jemals das Raster erreicht. Protokollieren Sie result.products und Sie erhalten eine Struktur wie diese, bereit zum Rendern, Schreiben in JSON oder Persistieren in eine Datenbank.

[
  {
    "name": "Apple iPhone 15 Pro Max 256GB Natural Titanium",
    "price": "$1,199.00",
    "image": "https://m.media-amazon.com/images/I/81fxjeu8fdL._AC_UL320_.jpg",
    "rating": "4.7 out of 5 stars",
    "reviews": "1,284",
    "url": "https://www.amazon.com/dp/B0CHX1W1XY"
  },
  {
    "name": "Samsung Galaxy S24 Ultra 256GB Unlocked",
    "price": "$1,099.99",
    "image": "https://m.media-amazon.com/images/I/71CXi9gZ4mL._AC_UL320_.jpg",
    "rating": "4.5 out of 5 stars",
    "reviews": "912",
    "url": "https://www.amazon.com/dp/B0CMDRCZBP"
  }
]

Über mehrere Ergebnisseiten skalieren

Eine Ergebnisseite ist ein Demo-Beispiel; ein echter Job läuft die Paginierung durch. Amazon stellt die Seitennummer über den page-Abfrageparameter bereit, sodass Sie jede Seite über dieselbe Server Action abrufen, sie mit derselben Funktion parsen und die Zeilen sammeln können. Da jede Ergebnisseite dieselbe Kartenstruktur hat, funktioniert der bereits geschriebene Parser über alle Seiten ohne Änderungen. Fügen Sie eine seitenbasierte Variante zu app/actions.js hinzu.

export async function scrapeAmazonPages(keyword, totalPages) {
  const all = [];
  const query = encodeURIComponent(keyword.trim());
  for (let page = 1; page <= totalPages; page++) {
    const url = `https://www.amazon.com/s?k=${query}&page=${page}`;
    const response = await api.get(url, { ajax_wait: 'true', page_wait: 5000 });
    if (response.statusCode === 200) {
      all.push(...parseProducts(response.body));
    }
  }
  return all;
}

Um jede Zeile mit vollständigen Produktdetails anzureichern (vollständige Beschreibung, jedes Bild, die Kaufoption, vollständige Rezensionsdaten), nehmen Sie die url aus jeder Karte und rufen diese einzelne Produktseite über denselben API-Client ab, dann schreiben Sie einen kleinen Parser für das Produktlayout. Das Muster ist identisch: rendern, dann parsen. Mehr zu rendering-intensiven Zielen finden Sie unter JavaScript-Websites crawlen.

Unblockiert bleiben

Selbst mit gehandhabtem Rendering beobachtet Amazon Datenverkehr mit Scraper-ähnlichem Muster. Ein paar Gewohnheiten halten einen Durchlauf gesund und gelten für jedes schwierige kommerzielle Ziel.

• Drosseln Sie Ihre Anfragen. Seiten in einer engen Schleife zu hammern, ist der schnellste Weg zu einem CAPTCHA. Verteilen Sie Anfragen und variieren Sie Ihre Keywords, statt einen Pfad mit voller Geschwindigkeit zu crawlen.
• Setzen Sie auf Rotation. Ein Pool von Wohngebiets-IPs verteilt Anfragen über viele echte Nutzeradressen, sodass keine einzelne Adresse ein Ratenlimit auslöst. Die Crawling API übernimmt das für Sie; wenn Sie Ihren eigenen Stack aufbauen, ist das der Teil, den Sie richtig machen müssen.
• Lesen Sie die Statuscodes. Ein Durchlauf, der beginnt, Herausforderungen oder Nicht-200-Antworten zurückzugeben, signalisiert Ihnen, dass die aktuelle Rate oder IP-Stufe nicht mehr ausreicht. Behandeln Sie das als Signal zum Drosseln, nicht als Rauschen zum Ignorieren.

Das umfassendere Vorgehen finden Sie unter Websites scrapen ohne blockiert zu werden. Wenn Sie Ihren eigenen Datenverkehr lieber durch einen rotierenden Pool leiten, als die verwaltete API zu nutzen, bietet der Smart AI Proxy dieselbe Wohngebiets-IP-Rotation als Drop-in-Proxy-Endpunkt.

Ist das Scrapen von Amazon legal?

Ob das Scrapen von Amazon erlaubt ist, hängt von Amazons Nutzungsbedingungen, Ihrer Gerichtsbarkeit und dem ab, was Sie mit den Daten machen. Amazons Bedingungen schränken automatisierten Zugriff ein, sodass Scraping unabhängig davon, wie sorgfältig Ihr Tooling ist, gegen diese Bedingungen verstoßen kann. Keiner der hier gezeigten Code-Schnipsel ändert das; er macht nur den technischen Teil funktionsfähig. Lesen Sie Amazons Nutzungsbedingungen und seine robots.txt, und behandeln Sie beides als Grenze für das, was Sie sammeln.

Ein paar Grenzen, an denen Sie festhalten sollten. Sammeln Sie nur öffentliche Suchdaten: Produktnamen, Preise, Bewertungen, Rezensionszahlen, das Thumbnail und den Produktlink, den jeder ohne Konto sehen kann. Respektieren Sie Amazons erklärte Ratenerwartungen und halten Sie Ihr Anfragevolumen niedrig genug, dass Sie seine Server nicht belasten. Vermeiden Sie personenbezogene Daten, einschließlich alles, was mit identifizierbaren Rezensenten über den auf einer Ergebnisseite angezeigten öffentlichen Rezensionstext und Zählungen hinaus verknüpft ist. Verbreiten Sie urheberrechtlich geschützte Produktbilder oder Beschreibungen nicht massenweise weiter; referenzieren Sie sie, veröffentlichen Sie sie nicht als Ihre eigenen. Wenn Sie planen, die Daten kommerziell zu nutzen, holen Sie sich eine Erlaubnis oder eine offizielle Vereinbarung, anstatt Schweigen als Zustimmung zu betrachten.

Für Volumen oder kommerzielle Nutzung bietet Amazon offizielle Kanäle, einschließlich der Product Advertising API für Affiliates und Amazons Verkäufer- und Werbe-APIs für registrierte Unternehmen, und das sind die richtigen Werkzeuge, wenn Sie große Mengen, garantierte Struktur oder kommerzielle Rechte benötigen. Dieser Leitfaden beschränkt sich bewusst auf öffentliche Such- und Angebotsseiten, weil das die Linie ist, die die Arbeit vertretbar hält. Er deckt nichts hinter einem Login ab, keine Käufer- oder Verkäufer-Kontodaten, keinen Bestellverlauf, keine privaten Nachrichten oder Versuche, Authentifizierung oder eine CAPTCHA-Herausforderung als Zugangsmittel zu umgehen. Wenn Ihr Projekt mehr als öffentliche Suchdaten benötigt, sind Amazons offizielle APIs oder eine Datenvereinbarung der korrekte Weg, kein clevererer Scraper.

Häufig gestellte Fragen

Warum eine Next.js-Server-Action statt eines clientseitigen Abrufs verwenden?

Weil das Crawlbase-Token nie den Browser erreichen darf. Eine Server Action läuft nur auf dem Server, sodass Sie das Token aus process.env.CRAWLBASE_JS_TOKEN lesen, den Crawling-API-Aufruf durchführen und mit Cheerio parsen können, ohne dass etwas davon in Client-JavaScript gebündelt wird. Die Client-Komponente ruft einfach die Action auf und rendert, was zurückkommt. Das hält auch Cheerio, eine Node-Bibliothek, aus dem Browser, wo es nicht laufen kann.

Warum gibt eine einfache Anfrage unvollständige Daten von Amazon zurück?

Weil Amazon Preise, Bewertungen und Teile jeder Ergebniskarte clientseitig mit JavaScript rendert und automatisierten Datenverkehr mit CAPTCHAs und Robot-Checks herausfordert. Eine einfache HTTP-Anfrage kann mit fehlenden Schlüsselfeldern zurückkommen oder vollständig blockiert werden. Um eine vollständige Seite zu erhalten, müssen Sie sie hinter einer vertrauenswürdigen IP rendern, was das JS-Token der Crawling API für Sie übernimmt.

Benötige ich das normale Token oder das JS-Token für Amazon?

Verwenden Sie das JS-Token. Das normale Token ruft statisches HTML ab, das bei Amazon mit fehlenden Preisen oder Bewertungen zurückkommen kann. Das JS-Token rendert die Seite in einem echten Browser, bevor es das HTML zurückgibt, sodass die Ergebnisfelder vorhanden sind, wenn Cheerio sie parst.

Meine Selektoren geben null zurück. Was hat sich geändert?

Höchstwahrscheinlich Amazons Markup. Seine s-search-result-Karten, a-price-Blöcke und a-offscreen-Spans ändern sich ohne Vorankündigung und variieren je nach Region und Anfragetyp, sodass Selektoren, die letzten Monat funktionierten, kaputt gehen können. Überprüfen Sie eine Live-Seite in den Entwicklertools Ihres Browsers und aktualisieren Sie die Selektoren. Regelmäßige Selektor-Wartung ist bei jedem Produktions-Scraper normal.

Wie unterscheidet sich das vom einfachen Python- oder Node-Skript-Ansatz?

Daten und Crawling-API-Aufruf sind dieselben; der Rahmen ist Full-Stack. Hier befinden sich Abruf und Parse in einer Next.js-Server-Action, und ein React-Raster rendert die Ergebnisse in einer Browser-Benutzeroberfläche mit dem Token sicher serverseitig. Wenn Sie nur ein Skript benötigen, das JSON ausgibt, ist der einfachere Weg, Amazon-Suchseiten direkt mit der Crawling API zu scrapen oder einen Web-Scraper mit Node.js zu erstellen, ohne das Framework drum herum.

Kann ich persönliche Käufer- oder Verkäuferdaten von Amazon scrapen?

Nein, und dieser Leitfaden behandelt das nicht. Kontodaten, Bestellverlauf und private Nachrichten befinden sich hinter einem Login, sind also keine öffentlichen Daten. Das Scrapen von durch Login gesperrten Inhalten, personenbezogenen Daten oder das Umgehen von Authentifizierung oder einem CAPTCHA, um diese zu erreichen, ist hier außerhalb des Geltungsbereichs und verstößt gegen Amazons Bedingungen. Für genehmigten Zugriff ist der korrekte Weg Amazons offizielle APIs oder eine Lizenzvereinbarung.

MA

Muhammad Atif

Senior Full Stack Developer · Crawlbase

Senior Full Stack Developer bei Crawlbase, der die Plattform aufbaut und über Scraping-Architektur, Proxys und Datenpipelines schreibt.

IK

Ian Kalvin

Technical Support Engineer · Crawlbase

Technical Support Engineer bei Crawlbase, der von der Front darüber schreibt, was beim Scraping und bei Proxy-Setups im Produktivbetrieb tatsächlich kaputtgeht.