So scrapen Sie YouTube-Daten mit Python

Im heutigen Artikel erfahren Sie, wie Sie:

Verwenden Sie Python und die yt-dlp-Bibliothek, um Video-Metadaten zu extrahieren und Videos herunterzuladen
Exportieren Sie diese wichtigen Informationen in eine CSV-Datei
Verwenden Sie ScraperAPI, um die Anti-Scraping-Maßnahmen von YouTube effektiv zu umgehen und umfassendere Daten zu sammeln

Machen Sie sich bereit, Ihre Fähigkeiten im Bereich Data Scraping zu verbessern und nutzen Sie die Fülle an Informationen, die auf YouTube verfügbar sind!

Inhaltsverzeichnis

TL;DR: Vollständiger YouTube Scraper

Für diejenigen, die mit Web Scraping oder der Automatisierung von Aufgaben in Python vertraut sind, bietet dieses Skript eine umfassende Anleitung zum Scraping verschiedener Arten von YouTube-Daten.

Hier ist eine kurze Zusammenfassung der Funktionen des Codes:

Herunterladen eines YouTube-Videos – Verwendet yt-dlp, um ein Video von einer angegebenen URL herunterzuladen.
Extrahieren von YouTube-Kommentaren – Extrahiert Kommentare aus einem YouTube-Video mithilfe von yt-dlp.
Extrahieren von Metadaten – Ruft Metadaten (z. B. Titel, Breite, Höhe, Sprache, Kanal, Likes) aus einem YouTube-Video ab, ohne es herunterzuladen.
Scraping von Kanalinformationen – Verwendet Anfragen und BeautifulSoup, um den Abschnitt „Info“ eines YouTube-Kanals zu durchsuchen und den Kanalnamen und die Beschreibung zu extrahieren.

  import requests
  from yt_dlp import YoutubeDL
  from bs4 import BeautifulSoup
  
  ## Downloading a YouTube Video
  def download_video(video_url):
      opts = {}
      with YoutubeDL(opts) as yt:
          yt.download((video_url))
      print(f"Downloaded video: {video_url}")
  
  ## Extracting YouTube Comments    
  def extract_comments(video_url):
      opts = {"getcomments": True}
      with YoutubeDL(opts) as yt:
          info = yt.extract_info(video_url, download=False)
          comments = info("comments")
          thread_count = info("comment_count")
          print("Number of threads: {}".format(thread_count))
          for comment in comments:
              print(comment('text'))
  
  ## Extracting Metadata
  def extract_metadata(video_url):
      opts = {}
      with YoutubeDL(opts) as yt:
          info = yt.extract_info(video_url, download=False)
          data = {
              "URL": video_url,
              "Title": info.get("title"),
              "Width": info.get("width"),
              "Height": info.get("height"),
              "Language": info.get("language"),
              "Channel": info.get("channel"),
              "Likes": info.get("like_count")
          }
          print("Metadata:", data)
          return data
  
  ## Scraping Channel Information
  def scrape_channel_info(channel_url, api_key):
      params = {
          'api_key': api_key,
          'url': channel_url,
          'render': 'true'
      }
      response = requests.get('https://api.scraperapi.com', params=params)
      if response.status_code == 200:
          soup = BeautifulSoup(response.text, 'html.parser')
          channel_name = soup.find('yt-formatted-string', {'id': 'text', "class":"style-scope ytd-channel-name"})
          channel_desc = soup.find('div', {'id': 'wrapper', "class":"style-scope ytd-channel-tagline-renderer"})
          if channel_name and channel_desc:
              channel_info = {
                  "channel_name": channel_name.text.strip(),
                  "channel_desc": channel_desc.text.strip(),
              }
              print("Channel Info:", channel_info)
              return channel_info
          else:
              print("Failed to retrieve channel info")
      else:
          print("Failed to retrieve the page:", response.status_code)
  
  ## Example Usage
  if __name__ == "__main__":
      # Download a video
      video_url =  "ANY_YOUTUBE_VIDEO_URL"
      download_video(video_url)
  
      # Extract comments
      video_url_for_comments = "https://www.youtube.com/watch?v=hzXabRASYs8"
      extract_comments(video_url_for_comments)
  
      # Extract metadata
      video_url_for_metadata = "ANY_YOUTUBE_VIDEO_URL"
      extract_metadata(video_url_for_metadata)
  
      # Scrape channel information
      api_key = 'YOUR_API_KEY'
      channel_url = 'https://www.youtube.com/@scraperapi/about'
      scrape_channel_info(channel_url, api_key)

Dieser Code bietet eine umfassende Möglichkeit, verschiedene Arten von YouTube-Daten mit Python zu scrapen und zu analysieren. Ersetzen Sie zunächst die Platzhalterwerte (z. B. YOUR_API_KEY, ANY_YOUTUBE_VIDEO_URL) mit Ihren tatsächlichen Daten.

Möchten Sie tiefer in das Scraping von YouTube eintauchen? Lesen Sie weiter!

Schritt-für-Schritt-Anleitung zum Scrapen von YouTube-Daten

Projektanforderungen

Hier sind die Tools und Bibliotheken, die Sie für dieses Projekt benötigen:

Python 3.8 oder neuer – Stellen Sie sicher, dass Sie die neueste Version installiert haben
yt-dlp – Zum Herunterladen von YouTube-Videos
ScraperAPI – Um beim Web Scraping zu helfen, ohne blockiert zu werden
Anfragen – Eine einfache HTTP-Bibliothek für Python
Schöne Suppe4 – Zum Parsen von HTML und Extrahieren der benötigten Daten
Json – Zur Verarbeitung von JSON-Daten

Schritt 1: Richten Sie Ihr Projekt ein

Beginnen wir mit der Einrichtung Ihrer Projektumgebung. Erstellen Sie zunächst ein neues Verzeichnis, um alles zu organisieren, und navigieren Sie dorthin.

Öffnen Sie Ihr Terminal und führen Sie diese Befehle aus:

  mkdir youtube-scraper
  cd youtube-scraper

Stellen Sie sicher, dass Python auf Ihrem System installiert ist – Python 3.8 oder neuer ist erforderlich. Lassen Sie uns nun die wesentlichen Bibliotheken zum Herunterladen und Scrapen von YouTube-Daten installieren.

Verwenden Sie den folgenden Befehl, um die Bibliotheken zu installieren:

  pip install yt-dlp requests beautifulsoup4

Mit diesen Schritten ist Ihr Projektverzeichnis bereit und Sie haben alle erforderlichen Tools installiert, um mit dem Herunterladen und Scrapen von YouTube-Daten zu beginnen.

Lassen Sie uns nun in den spannenden Teil eintauchen!

Schritt 2: YouTube-Videos mit Python herunterladen

Wir verwenden die yt_dlp Bibliothek zum Herunterladen von YouTube-Videos. Diese Bibliothek ist ein leistungsstarkes Tool für die Interaktion mit YouTube-Inhalten mit Python.

Zuerst geben wir die URL des YouTube-Videos an, das wir herunterladen möchten. Sie können die video_url Variable mit der URL eines beliebigen YouTube-Videos, das Sie herunterladen möchten.

  from yt_dlp import YoutubeDL

  video_url = "https://www.youtube.com/watch?v=xy5OQ2IWNtc"

Anschließend richten wir mithilfe eines Python-Wörterbuchs Optionen für den Downloader ein. In diesem Snippet haben wir zwei Optionen angegeben:

'format': 'best': Diese Option weist den Downloader an, das beste verfügbare Qualitätsformat für das Video auszuwählen
'outtmpl': '%(title)s.%(ext)s': Diese Option gibt die Vorlage für den Ausgabedateinamen an. Hier %(title)s wird durch den Titel des Videos ersetzt und %(ext)s wird durch die Dateierweiterung ersetzt (z. B. mp4, webm).

  # Set options for the downloader
  opts = {
      'format': 'best',  # Choose the best quality format available
      'outtmpl': '%(title)s.%(ext)s'  # Output template for the filename
  }

Schließlich erstellen wir eine YoutubeDL Objekt mit den angegebenen Optionen und verwenden Sie es zum Herunterladen des Videos mit dem download() Methode. Die Methode akzeptiert eine Liste von URLs als Parameter, sodass Sie mehrere Videos gleichzeitig herunterladen können.

Hier ist der vollständige Codeausschnitt:

  # Create a YoutubeDL object and download the video
  with YoutubeDL(opts) as yt:
      yt.download((video_url))

Durch Ausführen dieses Code-Snippets können Sie das angegebene YouTube-Video in der gewünschten Qualität und mit der gewünschten Dateinamenvorlage herunterladen.

Schritt 3: YouTube-Metadaten scrapen

Wichtiger Hinweis

Die hier bereitgestellten Informationen dienen ausschließlich Bildungszwecken. Dieser Leitfaden gewährt keine Rechte an den Videos oder Bildern, die möglicherweise durch Urheberrechte, geistiges Eigentum oder andere gesetzliche Rechte geschützt sind. Konsultieren Sie vor dem Herunterladen von Inhalten einen Rechtsberater und lesen Sie die Nutzungsbedingungen der Website.

Ohne das Video herunterzuladen, können wir die yt_dlp Bibliothek, um Details zu einem YouTube-Video abzurufen, etwa Titel, Größe, Kanal und Sprache.

Lassen Sie uns als Beispiel die Details dieses Videos mit dem extract_info() Methode, Festlegen der download Parameter auf False damit wir das Video nicht erneut herunterladen. Die Methode gibt ein Wörterbuch mit allen Informationen zum Video zurück.

Hier ist ein Ausschnitt zum Extrahieren der Daten:

  from yt_dlp import YoutubeDL

  video_url = "https://www.youtube.com/watch?v=xy5OQ2IWNtc"
  opts = dict()
  
  with YoutubeDL(opts) as yt:
      info = yt.extract_info(video_url, download=False)
      video_title = info.get("title")
      width = info.get("width")
      height = info.get("height")
      language = info.get("language")
      channel = info.get("channel")
      likes = info.get("like_count")
      
      data = {
          "URL": video_url,
          "Title": video_title,
          "Width": width,
          "Height": height,
          "Language": language,
          "Channel": channel,
          "Likes": likes
      }
      print(data)

Um weitere Details zum Video zu erhalten, können Sie andere Schlüssel aus dem Wörterbuch verwenden, das zurückgegeben wird von extract_info(). Hier sind einige nützliche:

Schlüssel	Element
`id`	Video-ID
`title`	Videotitel
`description`	Videobeschreibung
`uploader`	Name des Uploaders
`uploader_id`	ID des Uploaders
`upload_date`	Upload-Datum (JJJJMMTT)
`duration`	Dauer in Sekunden
`view_count`	Anzahl der Aufrufe
`like_count`	Anzahl der Likes
`dislike_count`	Anzahl der Dislikes
`comment_count`	Anzahl der Kommentare
`thumbnail`	URL des Miniaturbildes
`formats`	Liste der verfügbaren Formate
`subtitles`	Verfügbare Untertitel
`age_limit`	Altersbeschränkung
`categories`	Mit dem Video verbundene Kategorien
`tags`	Mit dem Video verknüpfte Tags
`is_live`	Wenn das Video ein Live-Stream ist

Mithilfe dieser Schlüssel erhalten Sie alle erforderlichen Informationen zu einem YouTube-Video.

Schritt 4: YouTube-Kommentare scrapen

Um Kommentare aus einem YouTube-Video zu extrahieren, verwenden wir die yt_dlp Bibliothek, um die Kommentare zu extrahieren, ohne das Video selbst herunterzuladen.

In diesem Beispiel werden wir die Kommentare aus diesem Video scrapen: Eine kurze Einführung in Git für Anfänger

Zuerst importieren wir die YoutubeDL Klasse aus dem yt_dlp Bibliothek und geben Sie die URL des YouTube-Videos an, das wir scrapen möchten:

  from yt_dlp import YoutubeDL

  # URL of the YouTube video
  video_url = "https://www.youtube.com/watch?v=r8jQ9hVA2qs"

Als nächstes erstellen wir ein Optionswörterbuch opts mit dem Schlüssel "getcomments" einstellen TrueDas sagt yt_dlp dass wir Kommentare extrahieren möchten:

  # Options for YoutubeDL to get comments
  opts = {
      "getcomments": True,
  }

Verwendung der YoutubeDL Klasse mit unseren angegebenen Optionen extrahieren wir die Videoinformationen, einschließlich der Kommentare, durch den Aufruf der extract_info() Methode, die wir zuvor verwendet haben.

Denken Sie daran, die download Parameter auf False Daher rufen wir nur die Metadaten und Kommentare ab, ohne das eigentliche Video herunterzuladen:

  # Extract video information, including comments

  with YoutubeDL(opts) as yt:
      info = yt.extract_info(video_url, download=False)

Als nächstes verwenden wir die get() Methode auf dem Wörterbuch mit dem Schlüssel "comments" um auf die Kommentare zuzugreifen. Wir ermitteln auch die Gesamtzahl der Kommentar-Threads mit dem Schlüssel "comment_count":

  # Get the comments
  comments = info.get("comments")
  thread_count = info("comment_count")

Abschließend drucken wir die Gesamtzahl der Kommentar-Threads und die Kommentare selbst aus:

  print("Number of threads: {}".format(thread_count))
  print(comments)

Hier ist der komplette Code zusammen:

  from yt_dlp import YoutubeDL

  # URL of the YouTube video
  video_url = "https://www.youtube.com/watch?v=hzXabRASYs8"
  
  # Options for YoutubeDL to get comments
  opts = {
      "getcomments": True,
  }
  
  # Extract video information, including comments
  with YoutubeDL(opts) as yt:
      info = yt.extract_info(video_url, download=False)
      
      # Get the comments
      comments = info.get("comments")
      thread_count = info("comment_count")
      
      # Print the number of comment threads and the comments
      print("Number of threads: {}".format(thread_count))
      print(comments)

Schritt 5: Informationen zum YouTube-Kanal scrapen

Um Informationen über einen YouTube-Kanal abzurufen, können wir ScraperAPI verwenden, um Blockierungen zu vermeiden, die Requests-Bibliothek zum Verarbeiten von HTTP-Anfragen und die BeautifulSoup-Bibliothek zum Parsen von HTML-Inhalten.

Für dieses Beispiel durchsuchen wir die „Info“-Seite des YouTube-Kanals von ScraperAPI und extrahieren den Kanalnamen und die Beschreibung.

Scraping der Informationen des YouTube-Kanals

Zuerst richten wir den API-Schlüssel für ScraperAPI und die URL der „Info“-Seite des YouTube-Kanals ein.

Hinweis: Sie haben keinen API-Schlüssel? Erstellen Sie ein kostenloses ScraperAPI-Konto und erhalten Sie 5.000 API-Credits, um alle unsere Tools zu testen.

Wir definieren auch die Parameter, die für die API-Anfrage benötigt werden; die render Parameter wird auf true ermöglicht die vollständige Darstellung des gesamten Javascripts auf der Webseite:

  api_key = 'YOUR_API_KEY'
  url = f'https://www.youtube.com/@scraperapi/about'
  params = {
      'api_key': api_key,
      'url': url,
      'render': 'true'
  }

Wir machen dann eine get() Anfrage an den ScraperAPI-Endpunkt, wobei wir unsere Parameter übergeben. Dadurch können wir alle Einschränkungen umgehen und den HTML-Inhalt der Seite abrufen:

  response = requests.get('https://api.scraperapi.com', params=params)

Wenn die Anfrage erfolgreich ist (Statuscode 200), verwenden wir BeautifulSoup um den HTML-Inhalt zu analysieren und den Namen und die Beschreibung des Kanals zu extrahieren. Wir lokalisieren diese Elemente mithilfe ihrer spezifischen HTML-Tags und Klassen, die wir zuvor identifiziert haben:

  if response.status_code == 200:
  soup = BeautifulSoup(response.text, 'html.parser')
  channel_name = soup.find('yt-formatted-string', {'id': 'text', "class":"style-scope ytd-channel-name"})
  channel_desc = soup.find('div', {'id': 'wrapper', "class":"style-scope ytd-channel-tagline-renderer"})
  if channel_name and info:       
      channel_info = {
      " channel_name" : channel_name.text.strip(),
      "channel_desc" : channel_desc.text.strip(),
      }
  else:
      print("Failed to retrieve channel info")
else:
  print("Failed to retrieve the page:", response.status_code)

Abschließend drucken wir die extrahierten Kanalinformationen aus:

Hier ist der komplette Code:

  import requests
  from bs4 import BeautifulSoup
  
  # API key for ScraperAPI
  api_key = 'YOUR_API_KEY'
  # URL of the YouTube channel's About page
  url = 'https://www.youtube.com/@scraperapi/about'
  # Parameters for the API request
  params = {
      'api_key': api_key,
      'url': url,
      'render': 'true'
  }
  
  # Make a GET request to ScraperAPI
  response = requests.get('https://api.scraperapi.com', params=params)
  
  # If the request is successful, parse the HTML and extract the channel info
  if response.status_code == 200:
      soup = BeautifulSoup(response.text, 'html.parser')
      channel_name = soup.find('yt-formatted-string', {'id': 'text', 'class': 'style-scope ytd-channel-name'})
      channel_desc = soup.find('div', {'id': 'wrapper', 'class': 'style-scope ytd-channel-tagline-renderer'})
  
      channel_info = {
          'channel_name': channel_name.text.strip(),
          'channel_desc': channel_desc.text.strip(),
      }
  else:
      print("Failed to retrieve the page:", response.status_code)
  
  # Print the extracted channel information
  print(channel_info)

Durch die Verwendung von ScraperAPI lassen sich Webinhalte ganz einfach abrufen. Dies hilft uns dabei, Daten von Websites wie YouTube zu scrapen, die möglicherweise Einschränkungen unterliegen.

ScraperAPI bewältigt alle Komplexitäten des Web Scraping, wie z. B. die Verwaltung der IP-Rotation, die Handhabung von CAPTCHAs und das Rendern von JavaScript, das herkömmliche Web Scraping-Techniken oft blockieren kann. So können wir uns auf das Extrahieren der erforderlichen Daten konzentrieren, ohne uns um diese häufigen Probleme kümmern zu müssen.

Beispielsweise verwendet YouTube häufig verschiedene Mechanismen, um automatisierten Zugriff zu verhindern, darunter Ratenbegrenzungen und komplexe Seitenstrukturen, die JavaScript-Rendering erfordern. Durch die Verwendung von ScraperAPI können wir diese Einschränkungen mühelos umgehen und so Daten wie Kanalinformationen, Videodetails und Kommentare abrufen, ohne blockiert zu werden.

So scrapen Sie YouTube-Suchergebnisse

Das Scraping von YouTube-Suchergebnissen kann wertvolle Einblicke in beliebte Inhalte und Trends im Zusammenhang mit bestimmten Schlüsselwörtern liefern. In diesem Beispiel verwenden wir ScraperAPI, um die Top-YouTube-Suchergebnisse für die Abfrage „scraperapi“ zu scrapen und die Titel und Links der Videos zu extrahieren.

Zuerst importieren wir die notwendigen Bibliotheken:

  import requests
  from bs4 import BeautifulSoup
  import json

Als nächstes richten wir unseren ScraperAPI-Schlüssel ein und geben die Suchanfrage an. Außerdem konstruieren wir die URL für die YouTube-Suchergebnisseite:

  api_key = 'YOUR_API_KEY'
  search_query = 'scraperapi'
  url = f'https://www.youtube.com/results?search_query={search_query}'
  params = {
      'api_key': api_key,
      'url': url,
      'render': 'true',
  }

Wir initialisieren eine leere Liste namens video_data um die extrahierten Videoinformationen zu speichern und eine Anfrage an den ScraperAPI-Endpunkt mit unseren Parametern zu stellen. Dadurch können wir den HTML-Inhalt der Suchergebnisseite abrufen:

  video_data = ()
  response = requests.get('https://api.scraperapi.com', params=params)

Wenn die Anfrage erfolgreich ist (Statuscode 200), analysieren wir den HTML-Inhalt mit Schöne Suppe:

  if response.status_code == 200:
  soup = BeautifulSoup(response.text, 'html.parser')
  videos = soup.find_all('div', {"id": "title-wrapper"})

Wir gebrauchen soup.find_all() um alle Div-Elemente mit dem id von title-wrapperdie die Videotitel und Links enthalten.

  videos = soup.find_all('div', {"id": "title-wrapper"})

Anschließend prüfen wir, ob Videoelemente gefunden wurden. Wenn Videos gefunden werden, drucken wir die Anzahl der gefundenen Videos aus und durchlaufen jedes Element, um den Titel und den Link zu extrahieren.

Wir bekommen die title Attribut des Ankertags, das den Titel des Videos enthält, und das href Attribut des Ankertags, das die relative URL des Videos enthält. Wir verketten sie mit der Basis-URL “https://www.youtube.com” um die vollständige URL zu bilden.

Anschließend speichern wir den extrahierten Titel und Link in einem Wörterbuch und hängen ihn an die video_data Liste.

  if videos:
  print(f"Found {len(videos)} videos")

  for video in videos:
      video_details = video.find("a", {"id": "video-title"})
      if video_details:
          title = video_details.get('title')
          link = video_details('href')
          video_info = {"title": title, "link": f"https://www.youtube.com{link}"}
          video_data.append(video_info)

Nachdem wir alle Videodetails extrahiert haben, speichern wir die video_data Liste in eine JSON-Datei zur weiteren Verwendung.

  with open('videos.json', 'w') as json_file:
  json.dump(video_data, json_file, indent=4)