Skip to content

Alles für WordPress, Webentwicklung — und mehr

📹 YouTube Data API v3: Videodaten mit PHP abrufen (2026)
Webentwicklung
6 Min1,155 Wörter

📹 YouTube Data API v3: Videodaten mit PHP abrufen (2026)

Warum Videodaten per API parsen, wenn Sie die Seite einfach öffnen können?

Das manuelle Sammeln von Informationen zu Dutzenden Videos kostet Stunden. Titel, Dauer, Aufrufzahlen, Veröffentlichungsdatum: All das per Hand von YouTube zu kopieren, ist ein sicherer Weg zu Fehlern und Burnout.

Die YouTube Data API v3 löst das Problem programmatisch. Eine HTTP-Anfrage, und Sie erhalten strukturiertes JSON mit snippet, contentDetails und statistics. Kein HTML-Parsing, keine Captchas.

In diesem Tutorial: eine Schritt-für-Schritt-Anleitung vom Erstellen eines API-Schlüssels bis zu einem einsatzbereiten PHP-Skript, das Informationen zu jedem YouTube-Video anhand seiner URL extrahiert. Der Code ist real, getestet und mit Erklärungen zu jeder Zeile versehen.

💡 Kurzer Überblick:

  • API-Schlüssel in der Google Cloud Console erstellen und YouTube Data API v3 aktivieren
  • Die Struktur des /videos-Endpunkts und seiner Parameter part, id und key verstehen
  • Eine PHP-Funktion schreiben, um die Video-ID aus einem beliebigen YouTube-Link zu extrahieren
  • Eine Anfrage per file_get_contents() stellen und die JSON-Antwort parsen
  • Fehler behandeln: ungültiger Schlüssel, falsche ID, ausgeschöpftes Kontingent
  • Eine Alternative betrachten: die fertige Bibliothek madcoda/php-youtube-api

Schritt 1: Einen YouTube Data API-Schlüssel beziehen

Um mit der API zu arbeiten, benötigen Sie einen Schlüssel. Hier der kürzeste Weg:

  • Öffnen Sie die Google Cloud Console und erstellen Sie ein neues Projekt (oder wählen Sie ein bestehendes aus).
  • Gehen Sie zu APIs & Services → Bibliothek, suchen Sie nach „YouTube Data API v3" und klicken Sie auf Aktivieren.
  • Gehen Sie zu Anmeldedaten → Anmeldedaten erstellen → API-Schlüssel.
  • (Empfohlen) Schränken Sie den Schlüssel ein: Wählen Sie im Abschnitt API-Einschränkungen die YouTube Data API v3 aus, damit der Schlüssel nicht mit anderen Google-Diensten funktioniert.

Der Schlüssel sieht aus wie eine Zeichenkette wie AIzaSyD-... mit 39 Zeichen. Ohne ihn liefert die API einen 403-Fehler.

Das tägliche Kontingent beträgt 10.000 Einheiten. Eine Anfrage an /videos kostet 1 Einheit. Für Tests und kleine Projekte ist das mehr als ausreichend. Planen Sie eine produktionsreife Last, beantragen Sie eine Kontingenterhöhung im selben Bereich der Console.

Schritt 2: API-Endpunkt und seine Parameter

URL zum Abrufen von Videoinformationen:

1GET https://www.googleapis.com/youtube/v3/videos

Parameter werden als Query-String übergeben:

Parameter

Erforderlich

Beschreibung

part

Ja

Kommagetrennte Liste von Feldern: snippet, contentDetails, statistics, status, topicDetails usw.

id

Ja

YouTube-Video-ID (11 Zeichen, z. B. 1ejTKov_Sm4)

key

Ja

Ihr API-Schlüssel

hl

Nein

Sprache für Textfelder (z. B. ru für russische Titel)

maxResults

Nein

Anzahl der Ergebnisse (1-50, Standard ist 5)

Drei Hauptwerte für part, die die meisten Szenarien abdecken:

  • snippet: Basisinformationen: title, description, channelId, channelTitle, publishedAt, thumbnails (Satz von Vorschaubild-URLs in verschiedenen Auflösungen), tags, categoryId.
  • contentDetails: Eigenschaften: duration (im ISO-8601-Format, z. B. PT4M13S), dimension (2d/3d), definition (sd/hd), caption (ob Untertitel vorhanden sind).
  • statistics: Zahlen: viewCount, likeCount, commentCount.

Wichtiger Hinweis: Das Feld dislikeCount in statistics ist seit Dezember 2021 deaktiviert, die API liefert stets 0. Das Feld favoriteCount ist ebenfalls veraltet (seit August 2015 immer 0). Verlassen Sie sich in Ihrem Code nicht darauf.

Schritt 3: Video-ID aus der URL extrahieren

Bevor Sie die API aufrufen, müssen Sie die Video-ID aus dem Link extrahieren. YouTube hat mehrere URL-Formate:

  • Standard: https://www.youtube.com/watch?v=1ejTKov_Sm4
  • Kurz: https://youtu.be/1ejTKov_Sm4
  • Einbettung: https://www.youtube.com/embed/1ejTKov_Sm4
  • Mit Parametern: https://www.youtube.com/watch?v=1ejTKov_Sm4&t=120

Eine einfache PHP-Funktion behandelt all diese Varianten:

1/**
2 * Extracts video ID from YouTube URL.
3 * Supports formats: watch?v=, youtu.be/, /embed/
4 *
5 * @param string $url YouTube video URL
6 * @return string|null Video ID (11 characters) or null on error
7 */
8function getYouTubeVideoId(string $url): ?string
9{
10    $parsed = parse_url($url);
11 
12    // Short link youtu.be/VIDEO_ID
13    if (isset($parsed['host']) && str_contains($parsed['host'], 'youtu.be')) {
14        return ltrim($parsed['path'], '/') ?: null;
15    }
16 
17    // Standard link watch?v=VIDEO_ID
18    if (isset($parsed['query'])) {
19        parse_str($parsed['query'], $params);
20        if (!empty($params['v'])) {
21            return $params['v'];
22        }
23    }
24 
25    // Embed link /embed/VIDEO_ID
26    if (isset($parsed['path']) && str_starts_with($parsed['path'], '/embed/')) {
27        return substr($parsed['path'], 7);
28    }
29 
30    return null;
31}
32 
33// Usage example
34$videoUrl = 'https://www.youtube.com/watch?v=1ejTKov_Sm4';
35$videoId  = getYouTubeVideoId($videoUrl);
36echo $videoId; // 1ejTKov_Sm4

Die Funktion nutzt ausschließlich die eingebauten Fähigkeiten von PHP: parse_url() zerlegt die URL in ihre Bestandteile, parse_str() parst den Query-String in ein Array. Keine externen Abhängigkeiten.

Schritt 4: API-Anfrage und Antwort-Parsing

Alles zusammenfügen. Wir bauen die URL, indem wir die ID und den Schlüssel einsetzen, stellen eine GET-Anfrage und dekodieren das JSON:

1<?php
2 
3$apiKey   = 'AIzaSyD-YOUR_KEY';
4$videoUrl = 'https://www.youtube.com/watch?v=1ejTKov_Sm4';
5$videoId  = getYouTubeVideoId($videoUrl);
6 
7if (!$videoId) {
8    die('Failed to extract video ID from URL.');
9}
10 
11$endpoint = sprintf(
12    'https://www.googleapis.com/youtube/v3/videos?part=snippet,contentDetails,statistics&id=%s&key=%s',
13    $videoId,
14    $apiKey
15);
16 
17// Option with file_get_contents (requires allow_url_fopen = On in php.ini)
18$context = stream_context_create([
19    'http' => [
20        'timeout'        => 10,
21        'ignore_errors'  => true, // do not crash on HTTP errors
22    ],
23]);
24 
25$response = @file_get_contents($endpoint, false, $context);
26 
27if ($response === false) {
28    die('Network request failed. Check your connection or use cURL.');
29}
30 
31$data = json_decode($response);
32 
33if (json_last_error() !== JSON_ERROR_NONE) {
34    die('API response is not JSON. The key might be invalid.');
35}
36 
37// API returns error in error field, not HTTP status
38if (isset($data->error)) {
39    die('API Error: ' . $data->error->message);
40}
41 
42if (empty($data->items)) {
43    die('No video found with this ID.');
44}
45 
46$video = $data->items[0];
47 
48echo 'Title: ' . $video->snippet->title . PHP_EOL;
49echo 'Channel: ' . $video->snippet->channelTitle . PHP_EOL;
50echo 'Published: ' . $video->snippet->publishedAt . PHP_EOL;
51echo 'Duration: ' . $video->contentDetails->duration . PHP_EOL;
52echo 'Views: ' . number_format($video->statistics->viewCount ?? 0) . PHP_EOL;
53echo 'Likes: ' . number_format($video->statistics->likeCount ?? 0) . PHP_EOL;
54echo 'Comments: ' . number_format($video->statistics->commentCount ?? 0) . PHP_EOL;
55 
56// Max resolution thumbnail URL
57if (isset($video->snippet->thumbnails->maxres)) {
58    echo 'Thumbnail: ' . $video->snippet->thumbnails->maxres->url . PHP_EOL;
59}

Der Code ist merklich robuster als ein bloßes file_get_contents() aus einer Entwurfsversion. Hinzugefügt wurden: Prüfung der ID-Extraktion, Behandlung von Netzwerkfehlern, JSON-Validierung, Reaktion auf Google-API-Fehler (das Feld error), Prüfung auf leere Antwort und der ??-Fallback-Operator für optionale Statistikfelder.

CURL als Alternative

Ist die Direktive allow_url_fopen auf Ihrem Hosting deaktiviert, funktioniert file_get_contents() nicht. Verwenden Sie in diesem Fall cURL:

1$ch = curl_init();
2curl_setopt_array($ch, [
3    CURLOPT_URL            => $endpoint,
4    CURLOPT_RETURNTRANSFER => true,
5    CURLOPT_TIMEOUT        => 10,
6    CURLOPT_FOLLOWLOCATION => true,
7]);
8$response = curl_exec($ch);
9$httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
10curl_close($ch);
11 
12if ($httpCode !== 200 || $response === false) {
13    die('Request failed. HTTP code: ' . $httpCode);
14}

Fertige Bibliothek: madcoda/php-youtube-api

Einen Wrapper manuell für die Produktion zu schreiben, ist zusätzliche Arbeit. Für Projekte, die regelmäßige API-Interaktion statt eines einmaligen Abrufs benötigen, gibt es madcoda/php-youtube-api, einen schlanken PHP-Wrapper ohne externe Abhängigkeiten. Installation:

1composer require madcoda/php-youtube-api

Verwendung:

1$youtube = new Madcoda\Youtube(['key' => 'YOUR_KEY']);
2$video   = $youtube->getVideoInfo('1ejTKov_Sm4');
3 
4echo $video->snippet->title;
5echo $video->statistics->viewCount;

Die Bibliothek übernimmt Routineaufgaben: Paginierung, Wiederholungsanfragen, Formatierung der Dauer von ISO 8601 in ein lesbares Format. Für einmalige Skripte ist sie übertrieben, für einen arbeitenden Dienst ist sie gerechtfertigt.

Der obige Video-Guide zeigt den gesamten Prozess anschaulich: vom Aktivieren der API in der Console bis zur ersten erfolgreichen Anfrage. Wir empfehlen, ihn vor dem Schreiben des Codes anzusehen: 15 Minuten Video sparen eine Stunde Dokumentationslektüre.

PHP-Code auf einem Monitor in Nahaufnahme

⁉️🤔 Häufig gestellte Fragen

Was kostet die Nutzung der YouTube Data API?

Die API selbst ist kostenlos. Sie zahlen nur mit Kontingent: 10.000 Einheiten pro Tag für jedes Projekt. Eine Anfrage an /videos kostet 1 Einheit, Sie können also täglich Daten zu 10.000 Videos abrufen, ohne einen Cent auszugeben. Für kommerzielle Projekte mit Last über dem Schwellenwert bietet Google ein Formular zur Kontingenterhöhung an; bei angemessener Begründung wird diese genehmigt. Die YouTube Data API hat keine separaten kostenpflichtigen Stufen.

Wie unterscheidet sich die YouTube Data API v3 vom Parsen von HTML-Seiten?

Die API liefert strukturiertes JSON mit einem dokumentierten Schema. Wenn sich Felder ändern, veröffentlicht Google eine Abkündigungsmitteilung mehrere Monate im Voraus. HTML-Parsing bricht bei jedem Seiten-Redesign, erfordert Browser-Emulation und ist gemäß Abschnitt 3.2 der YouTube-Nutzungsbedingungen ausdrücklich untersagt.

Kann ich Daten zu einem privaten Video erhalten?

Mit einem API-Schlüssel nur zu öffentlichen Videos. Für den Zugriff auf private, nicht gelistete und eingeschränkte Videos ist OAuth 2.0 mit Erlaubnis des Eigentümers erforderlich. Technisch ist es derselbe /videos-Endpunkt, jedoch mit einem Access-Token anstelle eines Schlüssels.

Wie erhalte ich meine YouTube-Kanal-ID?

Der zuverlässigste Weg: YouTube Studio → Einstellungen → Kanal → Erweiterte Einstellungen. Dort wird die YouTube-Kanal-ID direkt angezeigt, ohne jegliche API-Anfragen. Alternativ: /channels?part=id&mine=true mit einem OAuth-Token aufrufen. Für Kanäle mit benutzerdefinierten Nutzernamen funktioniert die Methode /channels?part=id&forUsername=NAME nur für solche, die vor 2014 erstellt wurden.

Was tun bei einem „quotaExceeded"-Fehler?

Das tägliche Kontingent wird um 00:00 Uhr Pazifischer Zeit (UTC-8) zurückgesetzt. Temporäre Lösung: Antworten auf Ihrer Seite cachen (Datei, Redis). Für eine dauerhafte Erhöhung: Google Cloud Console → IAM & Verwaltung → Kontingente → YouTube Data API v3 → Anfragen pro Tag → Kontingent bearbeiten.

Wo die YouTube Data API einsetzen: abschließende Zusammenfassung

Wir haben den vollständigen Zyklus behandelt: API-Schlüssel, Aufschlüsselung der Endpunkt-Parameter, Extraktion der Video-ID aus der URL, GET-Anfrage und Parsen der JSON-Antwort. Das Ergebnis ist ein funktionierendes PHP-Skript, das Titel, Statistiken, Dauer und Vorschaubilder jedes öffentlichen Videos in einer Sekunde abruft.

Mögliche nächste Schritte:

  • Video-Karten auf einer Website. Integrieren Sie das Skript in ein WordPress-Backend (save_post-Hook) oder Laravel, und beim Hinzufügen eines YouTube-Links werden die Videoinformationen automatisch abgerufen.
  • Wettbewerbsbeobachtung. Einmal täglich viewCount und likeCount für eine Liste von Kanälen sammeln, und Ihre Dynamik-Tabelle ist fertig.
  • Automatischer Import. Wenn Sie einen Videoblog auf Ihrer eigenen Website betreiben, holen Sie snippet.title und snippet.description als Textentwurf für die Einbettung.

Die YouTube Data API v3 ist ein ausgereiftes, stabiles und kostenloses Werkzeug. Wenn Sie den grundlegenden Aufruf aus diesem Tutorial beherrschen, öffnen Sie die Tür zu Dutzenden weiterer Methoden: Suche, Playlists, Kommentare, Abonnements. 🔗 Offizielle YouTube Data API v3-Dokumentation

Redaktion
RedaktionRedaktionsteam→ All publications

Ein professionelles Team von Autoren und Redakteuren, das auf die Erstellung hochwertiger Inhalte spezialisiert ist.