So bauen Sie einen YouTube-Kanal-ScraperVideos, Aufrufe und Metadaten

Ein öffentlicher YouTube-Kanal ist ein kompakter Datensatz, der offen zugänglich ist. Öffnet man den Videos-Tab eines Erstellers, sieht man für jeden Upload den Titel, die Aufrufzahl, das Veröffentlichungsdatum, die Laufzeit und einen Link zur Wiedergabeseite. Aggregiert über einen gesamten Kanal ermöglicht dieses öffentliche Metadaten eine Wettbewerbsanalyse von Inhalten, Forschung zu Veröffentlichungsrhythmen und Trend-Tracking, ohne auf ein einziges privates Konto zugreifen zu müssen.

Diese Anleitung zeigt, wie man einen YouTube-Kanal-Scraper in JavaScript und Node.js aufbaut. Es wird ein kleiner, ausführbarer Scraper entwickelt, der die öffentliche Videos-Seite eines Kanals über die Crawling API mit JavaScript-Rendering abruft, jede Videokarte mit cheerio parst und die Ergebnisse als JSON oder CSV exportiert. Die gesamte Anleitung beschränkt sich auf öffentliche, nicht-personenbezogene Daten: Videoauflistungen auf einem Kanal, den jeder öffnen kann, niemals private Playlists, Kommentare oder gesperrte Inhalte. Der rechtliche Abschnitt gegen Ende ist kein Standardtext, also lesen Sie ihn, bevor Sie dies auf größere Volumen anwenden.

Was Sie bauen werden

Ein Node.js-Skript, das die Videos-URL eines öffentlichen YouTube-Kanals entgegennimmt, das JavaScript-gerenderte HTML über die Crawling API abruft und für jedes Video auf dieser Seite einen strukturierten Datensatz extrahiert. Als durchgehendes Beispiel verwenden wir den Videos-Tab eines öffentlichen Kanals und extrahieren folgende Felder pro Video:

• Titel der Videotitel, wie er auf der Karte erscheint, zum Beispiel "Official Trailer".
• Aufrufe der öffentliche Aufrufzähltext, wie "56K views".
• Upload-Datum das relative Veröffentlichungsdatum, etwa "6 days ago".
• Dauer das Laufzeit-Badge auf dem Thumbnail, wie "2:14".
• Link die absolute URL zur individuellen Wiedergabeseite.

Zusätzlich lesen wir etwas Kontext auf Kanalebene (Kanaltitel und Handle), damit jeder Export selbstbeschreibend ist, und schreiben die Videoliste dann als JSON und CSV heraus.

Warum eine einfache Anfrage bei YouTube scheitert

Wenn Sie die Videos-URL eines Kanals mit einem einfachen HTTP-Client abrufen, erhalten Sie einen Status 200 und fast keine der gesuchten Daten. YouTube baut das Video-Grid im Browser: Der initiale HTML-Code ist eine dünne Hülle, und das eigentliche Karten-Markup wird erst durch JavaScript injiziert, nachdem die Seitenskripte ausgeführt wurden und die Watchdaten geladen sind. Ein reines fetch erfasst die Seite bevor das alles passiert, sodass cheerio ein leeres Grid findet.

Zusätzlich zum Rendering beobachtet YouTube automatisierten Traffic. Datacenter-IPs und Anfragemuster, die nicht wie ein echter Browser aussehen, werden schnell herausgefordert oder rate-limitiert, sodass selbst ein Headless-Browser auf einem einfachen Server oft blockiert wird. Ein funktionierender Kanal-Scraper benötigt daher zwei Dinge in einer Anfrage: einen Browser, der das Grid tatsächlich rendert, und eine IP, die die Plattform als echten Besucher erkennt. Dies lässt sich selbst zusammensetzen mit einem Headless-Browser plus einem Pool aus rotierenden Residential-Proxies, aber diese Komponenten zusammenzufügen und betriebsbereit zu halten, macht den Großteil der Arbeit aus. Die Crawling API kombiniert beides in einem einzigen Aufruf: Sie senden die URL mit aktiviertem JavaScript-Rendering, die API rendert die Seite hinter einer vertrauenswürdigen IP und gibt fertiges HTML zurück, das Sie parsen können.

Voraussetzungen

Einige Dinge müssen vorhanden sein, bevor Code geschrieben wird. Keine davon nimmt viel Zeit in Anspruch.

Grundlegende JavaScript- und Node.js-Kenntnisse. Sie sollten vertraut damit sein, ein Node-Skript zu schreiben und auszuführen sowie Pakete mit npm zu installieren. Wer neu bei Node ist, kommt mit der offiziellen Dokumentation und einem Einsteigerkurs auf das Niveau, das dieses Tutorial voraussetzt. Für eine ausführlichere Anleitung siehe unsere Anleitung zum Erstellen eines Web-Scrapers mit Node.js.

Node.js 16 oder neuer. Bestätigen 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.

Ein Crawlbase-Konto und Token. Melden Sie sich an, öffnen Sie Ihr Dashboard und kopieren Sie Ihren JavaScript-Request-Token von der Konto-Dokumentationsseite. Behandeln Sie den Token wie ein Passwort: Er authentifiziert Ihre Anfragen, halten Sie ihn also aus der Versionskontrolle heraus. Neue Konten erhalten eine Batch freier Anfragen, und Sie zahlen nur für erfolgreiche, was mehr als ausreicht, um diese Anleitung zu befolgen.

Projekt einrichten

Erstellen Sie einen Projektordner, initialisieren Sie ihn und installieren Sie die zwei Bibliotheken, die der Scraper benötigt.

node --version

mkdir youtube-channel-scraper && cd youtube-channel-scraper
npm init -y

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. Wer neu bei Selektoren ist, für den passt der Leitfaden zum Crawlen von JavaScript-Websites gut zu dieser Anleitung.

Schritt 1: Die gerenderte Videos-Seite abrufen

Beginnen Sie mit dem Abrufen der fertigen Seite. Importieren Sie die CrawlingAPI-Klasse, initialisieren Sie sie mit Ihrem Token und rufen Sie die Videos-URL des Kanals ab. Da das Grid clientseitig rendert, übergeben Sie ajax_wait und ein page_wait, damit spät ladende Karten erscheinen, bevor die Seite erfasst wird. Einen Fehler beim Statuscode zu prüfen, bevor geparst wird, macht Fehler laut statt still.

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

const api = new CrawlingAPI({ token: 'YOUR_CRAWLBASE_TOKEN' });

async function crawl(pageUrl) {
  const options = { ajax_wait: 'true', page_wait: 7000 };
  const response = await api.get(pageUrl, options);
  if (response.statusCode === 200) {
    return response.body;
  }
  console.error(`Request failed: ${response.statusCode}`);
  return null;
}

const channelUrl = 'https://www.youtube.com/@Netflix/videos';
crawl(channelUrl).then((html) => {
  console.log(html ? html.slice(0, 500) : 'No HTML returned');
});

Die beiden Wait-Optionen sind bei einem clientseitig gerenderten Ziel wie diesem wichtig. ajax_wait weist die API an, auf das Fertigladen asynchroner Inhalte zu warten, und page_wait hält nach dem Laden eine feste Anzahl von Millisekunden an, damit das spät rendernde Video-Grid erscheint, bevor die Seite erfasst wird. Sieben Sekunden sind ein vernünftiger Ausgangswert für YouTube; erhöhen Sie ihn, wenn das Grid leer zurückkommt. Führen Sie das Skript mit node scraper.js aus und Sie sollten echtes Kanal-Markup sehen, keine abgespeckte Hülle. Das bestätigt, dass das Rendering funktioniert, bevor ein einziger Selektor geschrieben wird.

Schritt 2: Jedes Video mit cheerio parsen

Mit dem gerenderten HTML laden Sie es in cheerio und iterieren die Videokarten. Der gerenderte Videos-Tab legt jeden Upload in einem sich wiederholenden Grid-Renderer aus, sodass Sie jede Karte auswählen und dann Titel, Aufrufe, Upload-Datum, Dauer und Watch-Link darin auslesen. Jedes Feld defensiv zu lesen hält einen fehlenden Wert davon ab, den gesamten Durchlauf zum Absturz zu bringen, und die relative URL auf dem Titelanker muss zu einer absoluten URL umgewandelt werden.

const cheerio = require('cheerio');

function parseChannel(html) {
  const $ = cheerio.load(html);
  const channel = {
    title: $('#inner-header-container .ytd-channel-name .ytd-channel-name:first').text().trim(),
    channelHandle: $('.meta-item #channel-handle').text().trim(),
    videos: [],
  };

  $('#contents ytd-rich-item-renderer').each((_, el) => {
    const card = $(el);
    const title = card.find('#video-title').text().trim();
    if (!title) return;

    const meta = card.find('#metadata-line span');
    const href = card.find('a#video-title-link').attr('href')
      || card.find('a#thumbnail').attr('href');

    channel.videos.push({
      title,
      views: $(meta).eq(0).text().trim() || null,
      uploadDate: $(meta).eq(1).text().trim() || null,
      duration: card.find('#overlays #text').text().trim() || null,
      link: href ? new URL(href, 'https://www.youtube.com').href : null,
    });
  });

  return channel;
}

Einige Details machen dies robust. Das Video-Grid verwendet YouTubes ytd-rich-item-renderer-Karten, und innerhalb jeder Karte enthält #video-title den Titel, während #metadata-line span die zwei Metadaten-Spans enthält: Der erste ist die Aufrufzahl, der zweite das relative Upload-Datum. Das Dauer-Badge sitzt im Thumbnail-Overlay unter #overlays #text. Der Watch-Link wird aus dem Attribut href des Ankers mit attr gelesen und dann durch den URL-Konstruktor übergeben, sodass ein relativer /watch?v=...-Pfad zu einem absoluten Link wird. Jedes Feld fällt auf null zurück, wenn das Element fehlt.

Schritt 3: Alles zusammensetzen

Jetzt verbinden Sie Fetch und Parse zu einem ausführbaren Skript. Holen Sie das gerenderte HTML, übergeben Sie es an den Parser und geben Sie den strukturierten Kanaldatensatz aus.

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

const api = new CrawlingAPI({ token: 'YOUR_CRAWLBASE_TOKEN' });

async function crawl(pageUrl) {
  const options = { ajax_wait: 'true', page_wait: 7000 };
  const response = await api.get(pageUrl, options);
  if (response.statusCode === 200) return response.body;
  console.error(`Request failed: ${response.statusCode}`);
  return null;
}

function parseChannel(html) {
  const $ = cheerio.load(html);
  const channel = {
    title: $('#inner-header-container .ytd-channel-name .ytd-channel-name:first').text().trim(),
    channelHandle: $('.meta-item #channel-handle').text().trim(),
    videos: [],
  };
  $('#contents ytd-rich-item-renderer').each((_, el) => {
    const card = $(el);
    const title = card.find('#video-title').text().trim();
    if (!title) return;
    const meta = card.find('#metadata-line span');
    const href = card.find('a#video-title-link').attr('href')
      || card.find('a#thumbnail').attr('href');
    channel.videos.push({
      title,
      views: $(meta).eq(0).text().trim() || null,
      uploadDate: $(meta).eq(1).text().trim() || null,
      duration: card.find('#overlays #text').text().trim() || null,
      link: href ? new URL(href, 'https://www.youtube.com').href : null,
    });
  });
  return channel;
}

async function main() {
  const channelUrl = 'https://www.youtube.com/@Netflix/videos';
  const html = await crawl(channelUrl);
  if (!html) return;
  const channel = parseChannel(html);
  console.log(`${channel.title} (${channel.channelHandle}): ${channel.videos.length} videos`);
  console.log(JSON.stringify(channel.videos.slice(0, 3), null, 2));
}

main();

Wie die Ausgabe aussieht

Führen Sie das vollständige Skript mit node scraper.js aus und erhalten Sie ein sauberes Array von Datensätzen, einen pro Video, bereit zum Schreiben in JSON, CSV oder eine Datenbank. Die Aufrufzahlen und Upload-Daten sind die öffentlichen Strings genau so, wie YouTube sie rendert.

[
  {
    "title": "Ilary Blasi: The one and only | Official Trailer | Netflix",
    "views": "56K views",
    "uploadDate": "6 days ago",
    "duration": "2:14",
    "link": "https://www.youtube.com/watch?v=pNY3NkGX6e8"
  },
  {
    "title": "Verified Stand-Up | Official Trailer | Netflix",
    "views": "50K views",
    "uploadDate": "11 days ago",
    "duration": "1:58",
    "link": "https://www.youtube.com/watch?v=gMIvGpHd2dk"
  }
]

Als JSON und CSV exportieren

Die Ausgabe in der Konsole ist für eine Überprüfung in Ordnung, aber normalerweise möchte man die Daten auf der Festplatte haben. JSON zu schreiben ist ein Einzeiler; ein kleiner CSV-Writer hält jedes Video in einer eigenen Zeile mit maskierten Feldern, sodass Kommas in einem Titel die Spalten nicht durcheinanderbringen.

const fs = require('fs');

function saveJson(channel, file) {
  fs.writeFileSync(file, JSON.stringify(channel, null, 2));
}

function saveCsv(videos, file) {
  const headers = ['title', 'views', 'uploadDate', 'duration', 'link'];
  const cell = (v) => `"${(v ?? '').replace(/"/g, '""')}"`;
  const rows = videos.map((v) => headers.map((h) => cell(v[h])).join(','));
  fs.writeFileSync(file, [headers.join(','), ...rows].join('\n'));
}

// in main(), after parseChannel():
saveJson(channel, 'channel.json');
saveCsv(channel.videos, 'channel.csv');

Der cell-Helfer umschließt jeden Wert in Anführungszeichen und verdoppelt eingebettete Anführungszeichen, die Standard-CSV-Maskierung, sodass ein Titel mit einem Komma oder einem Anführungszeichen in einer einzigen Spalte bleibt. JSON behält das verschachtelte Kanalobjekt; CSV flacht nur die Videozeilen ab, was die Form ist, die die meisten Tabellenkalkulationen und BI-Tools erwarten.

Die vollständige Kanalauflistung abrufen

Die gerenderte Videos-Seite gibt Ihnen den aktuellsten Batch von Uploads, nicht den gesamten Back-Katalog, da YouTube beim Scrollen weitere Karten nachladen lässt. Eine gerenderte Seite ist eine solide Demo und oft alles, was man für aktuelle Aktivitätsforschung braucht. Um tiefer in einen Kanal einzutauchen, gibt es einige Optionen, die dasselbe Fetch-dann-Parse-Muster beibehalten.

• Beim Rendern scrollen. Übergeben Sie ein längeres page_wait und verwenden Sie die Scroll-Optionen der Crawling API, sodass die Seite mehr Zeilen lädt bevor sie erfasst wird, dann führen Sie dasselbe parseChannel über das größere Grid aus.
• Per-Video-Links abgehen. Nehmen Sie jeden link aus der geparsten Liste und rufen Sie diese Watch-Seite durch dieselbe crawl-Funktion ab, um eine Zeile mit öffentlichen Details von der Video-Seite selbst anzureichern, dann schreiben Sie einen kleinen Parser für dieses Layout.

Was auch immer Sie wählen, die Struktur ändert sich nicht: rendern, dann parsen. Halten Sie Ihr Anfragevolumen bescheiden, damit Sie einen Kanal lesen und nicht belasten.

Ungeblockt bleiben

Selbst wenn das Rendering erledigt ist, überwacht YouTube scraper-ähnlichen Traffic. Einige Gewohnheiten halten einen Durchlauf gesund, und sie gelten für jedes schwierige, populäre Ziel.

• Anfragen dosieren. Kanäle in einer engen Schleife zu bearbeiten ist der schnellste Weg, gedrosselt zu werden. Verteilen Sie Anfragen und variieren Sie die Kanäle, die Sie abrufen, anstatt einen Pfad mit voller Geschwindigkeit zu crawlen.
• Auf Rotation setzen. Ein Pool von Residential-IPs verteilt Anfragen auf viele echte Nutzeradressen, sodass keine einzelne ein Rate-Limit auslöst. Die Crawling API übernimmt das für Sie; wenn Sie Ihren eigenen Stack betreiben, ist das der Teil, den Sie richtig hinbekommen müssen.
• Statuscodes lesen. Ein Durchlauf, der beginnt, Challenges oder Fehler zurückzugeben, sagt Ihnen, dass die aktuelle Rate oder das IP-Tier nicht mehr ausreicht. Behandeln Sie das als Signal zum Zurückschalten, nicht als Rauschen, das man ignoriert.

Für das umfassendere Playbook, siehe wie man Websites scrapt ohne geblockt zu werden. Wenn Sie lieber Ihren eigenen Traffic durch einen rotierenden Pool leiten möchten anstatt die verwaltete API zu verwenden, bietet der Smart AI Proxy dieselbe Residential-IP-Rotation als Drop-in-Proxy-Endpunkt. Für eine andere Form von YouTube-Daten, Video- und Suchergebnisse anstatt eines Kanal-Grids, siehe unsere Anleitung zum Scrapen von YouTube-Daten.

Ist es legal, YouTube zu scrapen?

Ob das Scrapen von YouTube erlaubt ist, hängt von YouTubes Nutzungsbedingungen, Ihrer Rechtsordnung und dem Verwendungszweck der Daten ab. YouTubes Bedingungen schränken den automatisierten Zugriff auf die Website ein, sodass Scraping unabhängig von der Sorgfalt Ihrer Werkzeuge gegen diese Bedingungen verstoßen kann. Keiner der hier vorliegenden Codes ändert das; er macht nur den technischen Teil funktionsfähig. Lesen Sie YouTubes Nutzungsbedingungen und seine robots.txt, respektieren Sie seine Rate-Erwartungen und behandeln Sie beides als Grenze für das, was Sie erfassen.

Halten Sie den Umfang eng. Erfassen Sie nur öffentliche, nicht-personenbezogene Daten: die Videotitel, Aufrufzahlen, Upload-Daten, Laufzeiten und Watch-Links, die jeder auf einem öffentlichen Kanal ohne Anmeldung sehen kann. Aggregieren Sie, wo es geht (Veröffentlichungsrhythmus, Aufrufverteilungen, Thementrends), anstatt ein Profil eines einzelnen Erstellers zu erstellen. Berühren Sie nichts hinter einem Login, private oder nicht gelistete Videos, Kommentare oder personenbezogene Daten von Zuschauern und Erstellern. Wo personenbezogene Daten betroffen sind, gelten Datenschutzgesetze wie die DSGVO und der CCPA: Sie benötigen eine Rechtsgrundlage zur Verarbeitung und müssen Lösch- und Auskunftsanfragen nachkommen. Verteilen Sie keine urheberrechtlich geschützten Videoinhalte, zu denen Sie Links abrufen; ein Link zu einer öffentlichen Watch-Seite ist keine Lizenz zum Rehosten der Medien.

Für alles, was über Ad-hoc-öffentliche Forschung hinausgeht, bietet YouTube einen offiziellen, sanktionierten Weg: die YouTube Data API. Sie gibt Kanal- und Videometadaten in einer stabilen, strukturierten Form mit einem klaren Kontingent und Bedingungen zurück und ist das richtige Werkzeug, wenn Sie Volumen, Zuverlässigkeit oder kommerzielle Rechte benötigen. Diese Anleitung ist bewusst auf öffentliche Kanal-Auflistungsseiten beschränkt, weil das die Grenze ist, die die Arbeit vertretbar macht. Sie deckt keine privaten Videos, Kommentare, Zuschauerdaten, kontosperrungsgeschützte Inhalte oder Versuche ab, die Authentifizierung zu umgehen. Wenn Ihr Projekt mehr als öffentliche Auflistungen benötigt, ist die YouTube Data API oder eine Datenvereinbarung der richtige Weg, kein ausgefeilterer Scraper.

Häufig gestellte Fragen

Warum gibt eine einfache Anfrage ein leeres Video-Grid von YouTube zurück?

Weil YouTube das Video-Grid im Browser mit JavaScript aufbaut. Der initiale HTML-Code ist eine dünne Hülle, und das eigentliche Karten-Markup wird erst injiziert, nachdem die Seitenskripte ausgeführt wurden und die Watchdaten geladen sind, sodass eine rohe HTTP-Anfrage den Status 200 mit leerem Grid zurückgibt. Um eine befüllte Seite zu erhalten, müssen Sie sie zuerst rendern, was die JavaScript-Anfrage der Crawling API für Sie übernimmt.

Brauche ich eine normale oder eine JavaScript-Anfrage für YouTube?

Verwenden Sie eine JavaScript-Anfrage. Eine normale Anfrage ruft statisches HTML ab, das bei einem YouTube-Kanal als leere Hülle ohne Karten zurückkommt. Die JavaScript-Anfrage rendert die Seite in einem echten Browser, bevor das HTML zurückgegeben wird, und die Optionen ajax_wait und page_wait geben dem Grid Zeit, fertig zu laden, sodass cheerio Karten zum Parsen hat.

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

Höchstwahrscheinlich YouTubes Markup. Seine Renderer-Tags und Element-IDs (ytd-rich-item-renderer, #video-title, #metadata-line und die übrigen) ändern sich ohne Ankündigung, und sie unterscheiden sich zwischen Videos-Tab, Shorts und der Kanal-Startseite, sodass Selektoren, die letzten Monat funktionierten, brechen können. Untersuchen Sie eine live gerenderte Seite in den Dev-Tools Ihres Browsers und aktualisieren Sie die Selektoren. Periodische Selektor-Wartung ist bei jedem Produktions-Scraper normal.

Wie erhalte ich alle Videos, nicht nur den neuesten Batch?

Der erste Render gibt die neuesten Uploads zurück, weil YouTube beim Scrollen weitere Karten nachlädt. Um weiter zurückzugehen, übergeben Sie ein längeres page_wait mit den Scroll-Optionen der Crawling API, damit mehr Zeilen vor der Erfassung laden, dann führen Sie denselben Parser über das größere Grid aus. Für tiefe Back-Kataloge paginiert die offizielle YouTube Data API Kanal-Uploads sauber und ist die bessere Wahl.

Sollte ich die YouTube Data API verwenden oder die Website scrapen?

Wenn Sie Volumen, garantierte Struktur oder kommerzielle Nutzungsrechte benötigen, verwenden Sie die offizielle YouTube Data API. Sie ist dafür gebaut und hält Sie auf der richtigen Seite von YouTubes Bedingungen. Das Scrapen öffentlicher Kanal-Auflistungen mit dem Ansatz in dieser Anleitung eignet sich für kleinere, öffentliche Datenforschung ohne API-Zugang, solange Sie ToS, robots.txt und Rate-Limits respektieren.

Kann ich Kommentare oder Zuschauerdaten eines Kanals scrapen?

Nein, und diese Anleitung deckt das nicht ab. Kommentare sind nutzergeschriebene persönliche Inhalte, und Zuschauerdaten sind nicht öffentlich, sodass beide außerhalb des öffentlichen, nicht-personenbezogenen Umfangs hier liegen. Wo personenbezogene Daten betroffen sind, gelten DSGVO und CCPA, und Sie benötigen eine Rechtsgrundlage sowie eine Möglichkeit, Löschanfragen nachzukommen. Für sanktionierten Zugang zu dieser Art von Daten ist die YouTube Data API mit angemessener Einwilligung und Bedingungen der richtige Weg.

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.