Jak uzyskać miniaturę wideo YouTube z interfejsu API YouTube?

Możesz użyć YouTube Data API aby pobrać miniatury wideo, podpis, opis, ocenę, statystyki i inne. API w wersji 3 wymaga klucza*. Uzyskaj klucz i utwórz Filmy: lista zapytanie:

https://www.googleapis.com/youtube/v3/videos?key=YOUR_API_KEY&part=snippet&id=VIDEO_ID

Przykładowy kod PHP

$data = file_get_contents("https://www.googleapis.com/youtube/v3/videos?key=YOUR_API_KEY&part=snippet&id=T0Jqdjbed40");
$json = json_decode($data);
var_dump($json->items[0]->snippet->thumbnails);

Wyjście

object(stdClass)#5 (5) {
  ["default"]=>
  object(stdClass)#6 (3) {
    ["url"]=>
    string(46) "https://i.ytimg.com/vi/T0Jqdjbed40/default.jpg"
    ["width"]=>
    int(120)
    ["height"]=>
    int(90)
  }
  ["medium"]=>
  object(stdClass)#7 (3) {
    ["url"]=>
    string(48) "https://i.ytimg.com/vi/T0Jqdjbed40/mqdefault.jpg"
    ["width"]=>
    int(320)
    ["height"]=>
    int(180)
  }
  ["high"]=>
  object(stdClass)#8 (3) {
    ["url"]=>
    string(48) "https://i.ytimg.com/vi/T0Jqdjbed40/hqdefault.jpg"
    ["width"]=>
    int(480)
    ["height"]=>
    int(360)
  }
  ["standard"]=>
  object(stdClass)#9 (3) {
    ["url"]=>
    string(48) "https://i.ytimg.com/vi/T0Jqdjbed40/sddefault.jpg"
    ["width"]=>
    int(640)
    ["height"]=>
    int(480)
  }
  ["maxres"]=>
  object(stdClass)#10 (3) {
    ["url"]=>
    string(52) "https://i.ytimg.com/vi/T0Jqdjbed40/maxresdefault.jpg"
    ["width"]=>
    int(1280)
    ["height"]=>
    int(720)
  }
}

* oprócz tego, że potrzebujesz klucza, możesz zostać poproszony o informacje rozliczeniowe w zależności od liczby żądań API, które planujesz wykonać. Jednak kilka milionów zapytania dziennie są bezpłatne.

Artykuł źródłowy .

To, co powiedział Asaph, jest słuszne. Jednak nie każdy film na YouTube zawiera wszystkie dziewięć miniaturek, ale dla każdego filmu jest siedem miniaturek. Są to:

(Rozmiar obrazu zależy od wideo.)

• Miniaturka tła odtwarzacza (480x360 pikseli)
  https://i1.ytimg.com/vi/G0wGs3useV8/0.jpg

• Start Miniaturka (120x90 pikseli)
  https://i1.ytimg.com/vi/G0wGs3useV8/1.jpg

• Miniatura Środkowa (120x90 pikseli)
  https://i1.ytimg.com/vi/G0wGs3useV8/2.jpg

• Miniaturka końcowa (120x90 piksele)
  https://i1.ytimg.com/vi/G0wGs3useV8/3.jpg

• Wysokiej Jakości Miniaturka (480x360 pikseli)
  https://i1.ytimg.com/vi/G0wGs3useV8/hqdefault.jpg

• Miniaturka średniej jakości (320x180 pikseli)
  https://i1.ytimg.com/vi/G0wGs3useV8/mqdefault.jpg

• Miniaturka o normalnej jakości (120x90 pikseli)
  https://i1.ytimg.com/vi/G0wGs3useV8/default.jpg

I dodatkowo, następne dwie miniaturki mogą lub nie mogą istnieć. Do filmów HQ istnieją.

• Miniaturka w standardowej rozdzielczości (640x480 pikseli)
  https://i1.ytimg.com/vi/G0wGs3useV8/sddefault.jpg

• Maksymalna Rozdzielczość Miniaturki (1920x1080 pikseli)
  https://i1.ytimg.com/vi/G0wGs3useV8/maxresdefault.jpg

Możesz pobrać skrypty JavaScript i PHP do pobierania miniaturek i innych YouTube informacje w

• jak uzyskać informacje wideo YouTube z PHP
• Pobierz szczegóły wideo z YouTube za pomocą JavaScript-JSON & API v2

Użyj również narzędzia Generator informacji wideo YouTube , aby uzyskać wszystkie informacje o filmie z YouTube, przesyłając URL lub video ID.

W YouTube API V3 możemy również użyć tych adresów URL do uzyskania miniaturek... Są klasyfikowane na podstawie ich jakości.

https://i1.ytimg.com/vi/<insert-youtube-video-id-here>/default.jpg -   default
https://i1.ytimg.com/vi/<insert-youtube-video-id-here>/mqdefault.jpg - medium 
https://i1.ytimg.com/vi/<insert-youtube-video-id-here>/hqdefault.jpg - high
https://i1.ytimg.com/vi/<insert-youtube-video-id-here>/sddefault.jpg - standard

I dla maksymalnej rozdzielczości..

https://i1.ytimg.com/vi/<insert-youtube-video-id-here>/maxresdefault.jpg

Jedną z zalet tych adresów URL nad adresami URL w pierwszej odpowiedzi jest to, że te adresy URL nie są blokowane przez zapory sieciowe.

Jeśli chcesz, aby największy obraz z YouTube dla określonego identyfikatora wideo, adres URL powinien być mniej więcej taki:

http://i3.ytimg.com/vi/SomeVideoIDHere/0.jpg

Za pomocą interfejsu API można wybrać domyślną miniaturę obrazu. Prosty kod powinien być mniej więcej taki:

//Grab the default thumbnail image
$attrs = $media->group->thumbnail[1]->attributes();
$thumbnail = $attrs['url'];
$thumbnail = substr($thumbnail, 0, -5);
$thumb1 = $thumbnail."default.jpg";

// Grab the third thumbnail image
$thumb2 = $thumbnail."2.jpg";

// Grab the fourth thumbnail image.
$thumb3 = $thumbnail."3.jpg";

// Using simple cURL to save it your server.
// You can extend the cURL below if you want it as fancy, just like
// the rest of the folks here.

$ch = curl_init ("$thumb1");
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_BINARYTRANSFER,1);
$rawdata = curl_exec($ch);
curl_close($ch);

// Using fwrite to save the above
$fp = fopen("SomeLocationInReferenceToYourScript/AnyNameYouWant.jpg", 'w');

// Write the file
fwrite($fp, $rawdata);

// And then close it.
fclose($fp);

Jeśli chcesz pozbyć się "czarnych pasków" i zrobić to tak, jak robi to YouTube, możesz użyć :

https://i.ytimg.com/vi_webp/<video id>/mqdefault.webp

A jeśli nie możesz użyć rozszerzenia .webp możesz to zrobić tak :

https://i.ytimg.com/vi/<video id>/mqdefault.jpg

Jeśli potrzebujesz wersji bezskalowanej, użyj maxresdefault zamiast mqdefault.

Uwaga: nie jestem pewien proporcji, jeśli planujesz użyć maxresdefault.

Zrobiłem funkcję, aby pobierać tylko istniejące obrazy z YouTube

function youtube_image($id) {
    $resolution = array (
        'maxresdefault',
        'sddefault',
        'mqdefault',
        'hqdefault',
        'default'
    );

    for ($x = 0; $x < sizeof($resolution); $x++) {
        $url = '//img.youtube.com/vi/' . $id . '/' . $resolution[$x] . '.jpg';
        if (get_headers($url)[0] == 'HTTP/1.0 200 OK') {
            break;
        }
    }
    return $url;
}

W YouTube Data API v3, możesz pobrać miniatury wideo za pomocą funkcji videos->list. Z fragmentu .miniaturki.(klucz) , możesz wybrać domyślną, średnią lub wysoką rozdzielczość miniaturki i uzyskać jej szerokość, wysokość i adres URL.

Możesz również zaktualizować miniatury za pomocą funkcji thumbnails->set .

Przykłady można znaleźć w projekcie YouTube API Samples. (PHP .)

Możesz uzyskać wpis Wideo , który zawiera adres URL do miniatury filmu. W linku jest przykładowy kod. Lub, jeśli chcesz przeanalizować XML, jest informacja tutaj . Zwracany XML zawiera element media:thumbnail, który zawiera adres URL miniatury.

// Get image form video URL
$url = $video['video_url'];

$urls = parse_url($url);

//Expect the URL to be http://youtu.be/abcd, where abcd is the video ID
if ($urls['host'] == 'youtu.be') :

    $imgPath = ltrim($urls['path'],'/');

//Expect the URL to be http://www.youtube.com/embed/abcd
elseif (strpos($urls['path'],'embed') == 1) :

    $imgPath = end(explode('/',$urls['path']));

//Expect the URL to be abcd only
elseif (strpos($url,'/') === false):

    $imgPath = $url;

//Expect the URL to be http://www.youtube.com/watch?v=abcd
else :

    parse_str($urls['query']);

    $imgPath = $v;

endif;

YouTube jest własnością Google i Google lubi mieć rozsądną liczbę obrazów dla różnych rozmiarów ekranu, stąd jego obrazy są przechowywane w różnych rozmiarach, oto przykład, jak twoja Miniatura jak będzie on jak

Miniaturka niskiej jakości:

http://img.youtube.com/vi/<YouTube_Video_ID_HERE>/sddefault.jpg

Miniaturka średniej jakości:

http://img.youtube.com/vi/<YouTube_Video_ID_HERE>/mqdefault.jpg

Wysokiej Jakości miniaturka:

http://img.youtube.com/vi/<YouTube_Video_ID_HERE>/hqdefault.jpg

Maksymalna jakość miniaturki:

http://img.youtube.com/vi/<YouTube_Video_ID_HERE>/maxresdefault.jpg

YOUTUBE API WERSJA 3 * * URUCHOMIENIE W 2 MINUTY * *

Jeśli wszystko, co chcesz zrobić, to przeszukać YouTube i uzyskać powiązane właściwości:

1. Get a PUBLIC API -- Ten Link daje dobry kierunek

2.Użyj poniższego ciągu zapytania. Zapytanie (oznaczone przez q=) w ciągu adresu url to stackoverflow na przykład. YouTube wyśle Ci odpowiedź w formacie json, w której możesz przeanalizować miniaturę, fragment, autora, itd.

https://www.googleapis.com/youtube/v3/search?part=id%2Csnippet&maxResults=50&q=stackoverflow&key=YOUR_API_KEY_HERE

Użycie:

https://www.googleapis.com/youtube/v3/videoCategories?part=snippet,id&maxResults=100&regionCode=us&key=**Your YouTube ID**

Powyżej jest link. Korzystając z tego, można znaleźć cechy YouTube filmów. Po znalezieniu cech można uzyskać filmy z wybranej kategorii. Następnie możesz znaleźć wybrane obrazy wideo za pomocą odpowiedź Asaph.

Wypróbuj powyższe podejście i możesz przeanalizować wszystko z interfejsu API YouTube .

Użyłem miniaturek YouTube w ten sposób:

$url = 'http://img.youtube.com/vi/' . $youtubeId . '/0.jpg';
$img = dirname(__FILE__) . '/youtubeThumbnail_'  . $youtubeId . '.jpg';
file_put_contents($img, file_get_contents($url));

Pamiętaj YouTube zapobiega dołączaniu obrazów bezpośrednio z ich serwera

Znalazłem to sprytne narzędzie, które pozwala na tworzenie obrazu za pomocą przycisku YouTube play umieszczonego nad obrazem:

• zainstalowany na serwerze do skryptów: https://github.com/halgatewood/youtube-thumbnail-enhancer

Aby dodać/rozszerzyć podane rozwiązania, uważam, że należy zauważyć, że ponieważ sam miałem ten problem, można rzeczywiście pobrać wiele treści wideo z YouTube, w tym przypadku miniatur, za pomocą jednego żądania HTTP: {]}

Używając klienta Rest, w tym przypadku HTTPFUL, możesz zrobić coś takiego:

<?php
header("Content-type", "application/json");

//download the httpfull.phar file from http://phphttpclient.com
include("httpful.phar");

$youtubeVidIds= array("nL-rk4bgJWU", "__kupr7KQos", "UCSynl4WbLQ", "joPjqEGJGqU", "PBwEBjX3D3Q");


$response = \Httpful\Request::get("https://www.googleapis.com/youtube/v3/videos?key=YourAPIKey4&part=snippet&id=".implode (",",$youtubeVidIds)."")

->send();

print ($response);

?>

Prosta funkcja php, którą stworzyłem dla miniaturki youtube, a typy to

• default
• hqdefault
• mqdefault
• sddefault
• Maxresdefault]}

  function get_youtube_thumb($link,$type){
  
      $video_id = explode("?v=", $link); 
          if (empty($video_id[1])){
             $video_id = explode("/v/", $link); 
             $video_id = explode("&", $video_id[1]); 
             $video_id = $video_id[0];
          }
      $thumb_link = "";
      if($type == 'default' || $type == 'hqdefault' || $type == 'mqdefault' || $type == 'sddefault' || $type == 'maxresdefault'){
  
          $thumb_link = 'http://img.youtube.com/vi/'.$video_id.'/'.$type.'.jpg';
  
      }elseif($type == "id"){
          $thumb_link = $video_id;
      }
      return $thumb_link;}
  

Inną dobrą alternatywą byłoby użycie oEmbed API, które jest obsługiwane przez YouTube.

Po prostu dodaj swój adres URL YouTube do oEmbed url, a otrzymasz JSON zawierający miniaturę i kod html do osadzania.

Przykład:

http://www.youtube.com/oembed?format=json&url=http%3A//youtube.com/watch%3Fv%3DDLzxrzFCyOs

Da ci:

{
  thumbnail_url: "https://i.ytimg.com/vi/DLzxrzFCyOs/hqdefault.jpg",
  width: 459,
  author_name: "AllKindsOfStuff",
  version: "1.0",
  author_url: "https://www.youtube.com/channel/UCLNd5EtH77IyN1frExzwPRQ",
  thumbnail_width: 480,
  type: "video",
  provider_url: "https://www.youtube.com/",
  html: "<iframe width="459" height="344" src="https://www.youtube.com/embed/DLzxrzFCyOs?feature=oembed" frameborder="0" allowfullscreen></iframe>",
  title: "Some title bla bla foo bar",
  thumbnail_height: 360,
  provider_name: "YouTube",
  height: 344
}

Przeczytaj dokumentację, aby uzyskać więcej Informacji .

Jeśli używasz publicznego api, najlepszym sposobem na to jest użycie instrukcji if.

Jeśli film jest publiczny lub Niepubliczny, ustawiasz miniaturę za pomocą metody url. Jeśli film jest prywatny, Użyj interfejsu api, aby uzyskać miniaturę.

<?php
if($video_status == 'unlisted'){
$video_thumbnail = 'http://img.youtube.com/vi/'.$video_url.'/mqdefault.jpg';
$video_status = '<i class="fa fa-lock"></i>&nbsp;Unlisted';
}
elseif($video_status == 'public'){
$video_thumbnail = 'http://img.youtube.com/vi/'.$video_url.'/mqdefault.jpg';
$video_status = '<i class="fa fa-eye"></i>&nbsp;Public';
}
elseif($video_status == 'private'){
$video_thumbnail = $playlistItem['snippet']['thumbnails']['maxres']['url'];
$video_status = '<i class="fa fa-lock"></i>&nbsp;Private';
}

YouTube Data API

YouTube dostarcza nam 4 wygenerowane obrazy dla każdego filmu za pośrednictwem Data API (v3), dla Ex -

1. Https://i.ytimg.com/vi/V_zwalcR8DU/maxresdefault.jpg

2. Https://i.ytimg.com/vi/V_zwalcR8DU/sddefault.jpg

3. Https://i.ytimg.com/vi/V_zwalcR8DU/hqdefault.jpg

4. Https://i.ytimg.com/vi/V_zwalcR8DU/mqdefault.jpg

Uzyskanie dostępu do zdjęć poprzez API

1. najpierw pobierz publiczny klucz API na Google API Console .
2. zgodnie z odniesieniem do miniatur YouTube w dokumentacji API , musisz uzyskać dostęp do zasobów na snippet.miniaturki.

3. Jak na to, musisz sformułować swój adres URL w ten sposób -

   Www.googleapis.com/youtube/v3/videos?part=snippet&id=yourVideoId & key=yourApiKey

Teraz Zmień yourVideoId i yourApiKey na odpowiednie video-id i API-key i jego odpowiedź będzie wyjściem JSON dostarczającym 4 Linki w miniaturach zmiennej snippet (jeśli wszystkie są dostępne).

Myślę, że są one wiele odpowiedzi na miniaturkę, ale chcę dodać kilka innych adresów URL, aby uzyskać miniaturkę youtube bardzo łatwo. Biorę tylko SMS-a z odpowiedzi Asapha. Oto kilka adresów URL, aby uzyskać miniatury youtube

https://ytimg.googleusercontent.com/vi/<insert-youtube-video-id-here>/default.jpg

Dla wysokiej jakości wersji miniaturki użyj adresu URL podobnego do tego:

https://ytimg.googleusercontent.com/vi/<insert-youtube-video-id-here>/hqdefault.jpg

https://ytimg.googleusercontent.com/vi/<insert-youtube-video-id-here>/mqdefault.jpg

Dla standardowej wersji miniaturki użyj url podobny do tego:

https://ytimg.googleusercontent.com/vi/<insert-youtube-video-id-here>/sddefault.jpg

Dla wersji o maksymalnej rozdzielczości miniaturki użyj adresu URL podobnego do tego:

https://ytimg.googleusercontent.com/vi/<insert-youtube-video-id-here>/maxresdefault.jpg

Możesz pobrać identyfikator wideo z adresu URL filmu YouTube za pomocą parse_url ,parse_str, a następnie wstaw do predykcyjnych adresów URL dla obrazów. Dzięki YouTube za predykcyjne adresy URL

$videoUrl = "https://www.youtube.com/watch?v=8zy7wGbQgfw";
parse_str( parse_url( $videoUrl, PHP_URL_QUERY ), $my_array_of_vars );
$ytID = $my_array_of_vars['v']; //gets video ID

print "https://img.youtube.com/vi/<?php print $ytID?>/maxresdefault.jpg";
print "https://img.youtube.com/vi/<?php print $ytID?>/mqdefault.jpg";
print "https://img.youtube.com/vi/<?php print $ytID?>/hqdefault.jpg";
print "https://img.youtube.com/vi/<?php print $ytID?>/sddefault.jpg";
print "https://img.youtube.com/vi/<?php print $ytID?>/default.jpg";

Możesz użyć tego narzędzia do generowania miniaturek YouTube

Https://codeatools.com/get-youtube-video-thumbnails

    function get_video_thumbnail( $src ) {
            $url_pieces = explode('/', $src);
            if( $url_pieces[2] == 'dai.ly'){
                $id = $url_pieces[3];
                $hash = json_decode(file_get_contents('https://api.dailymotion.com/video/'.$id.'?fields=thumbnail_large_url'), TRUE);
                $thumbnail = $hash['thumbnail_large_url'];
            }else if($url_pieces[2] == 'www.dailymotion.com'){
                $id = $url_pieces[4];
                $hash = json_decode(file_get_contents('https://api.dailymotion.com/video/'.$id.'?fields=thumbnail_large_url'), TRUE);
                $thumbnail = $hash['thumbnail_large_url'];
            }else if ( $url_pieces[2] == 'vimeo.com' ) { // If Vimeo
                $id = $url_pieces[3];
                $hash = unserialize(file_get_contents('http://vimeo.com/api/v2/video/' . $id . '.php'));
                $thumbnail = $hash[0]['thumbnail_large'];
            } elseif ( $url_pieces[2] == 'youtu.be' ) { // If Youtube
                $extract_id = explode('?', $url_pieces[3]);
                $id = $extract_id[0];
                $thumbnail = 'http://img.youtube.com/vi/' . $id . '/mqdefault.jpg';
            }else if ( $url_pieces[2] == 'player.vimeo.com' ) { // If Vimeo
                $id = $url_pieces[4];
                $hash = unserialize(file_get_contents('http://vimeo.com/api/v2/video/' . $id . '.php'));
                $thumbnail = $hash[0]['thumbnail_large'];
            } elseif ( $url_pieces[2] == 'www.youtube.com' ) { // If Youtube
                $extract_id = explode('=', $url_pieces[3]);
                $id = $extract_id[1];
                $thumbnail = 'http://img.youtube.com/vi/' . $id . '/mqdefault.jpg';
            } else{
                $thumbnail = tim_thumb_default_image('video-icon.png', null, 147, 252);
            }
            return $thumbnail;
        }

get_video_thumbnail('https://vimeo.com/154618727');
get_video_thumbnail('https://www.youtube.com/watch?v=SwU0I7_5Cmc');
get_video_thumbnail('https://youtu.be/pbzIfnekjtM');
get_video_thumbnail('http://www.dailymotion.com/video/x5thjyz');

Najlepsza odpowiedź zoptymalizowana do użytku ręcznego. Video ID token bez separatorów umożliwia wybranie za pomocą podwójnego kliknięcia.

Każdy film na YouTube ma 4 wygenerowane obrazy. Są one przewidywalnie sformatowane w następujący sposób:

https://img.youtube.com/vi/YOUTUBEVIDEOID/0.jpg
https://img.youtube.com/vi/YOUTUBEVIDEOID/1.jpg
https://img.youtube.com/vi/YOUTUBEVIDEOID/2.jpg
https://img.youtube.com/vi/YOUTUBEVIDEOID/3.jpg

Pierwszy z nich to pełnowymiarowy obrazek, a pozostałe to miniaturki. Domyślna miniaturka obrazu (np. jeden z 1.jpg, 2.jpg, 3.jpg) jest:

https://img.youtube.com/vi/YOUTUBEVIDEOID/default.jpg

Dla wysokiej jakości wersji miniaturki użyj adresu URL podobnego do to:

https://img.youtube.com/vi/YOUTUBEVIDEOID/hqdefault.jpg

https://img.youtube.com/vi/YOUTUBEVIDEOID/mqdefault.jpg

W standardowej wersji miniaturki użyj adresu URL podobnego do tego:

https://img.youtube.com/vi/YOUTUBEVIDEOID/sddefault.jpg

Dla wersji o maksymalnej rozdzielczości miniaturki użyj adresu URL podobnego do tego:

https://img.youtube.com/vi/YOUTUBEVIDEOID/maxresdefault.jpg

Wszystkie powyższe adresy URL są również dostępne przez http. Dodatkowo, nieco krótsza nazwa hosta i3.ytimg.com działa zamiast img.youtube.com w przykładowych adresach URL powyżej.

Alternatywnie, możesz użyć YouTube Data API (v3) aby uzyskać miniaturki zdjęć.

Metoda 1:

Możesz znaleźć wideo youtube Wszystkie informacje za pomocą strony json, która ma nawet " thumbnail_url" http://www.youtube.com/oembed?format=json&url={your video url goes here}

Like final url look + PHP test code

$data = file_get_contents("https://www.youtube.com/oembed?format=json&url=https://www.youtube.com/watch?v=_7s-6V_0nwA");
$json = json_decode($data);
var_dump($json); 

Wyjście

object(stdClass)[1]
  public 'width' => int 480
  public 'version' => string '1.0' (length=3)
  public 'thumbnail_width' => int 480
  public 'title' => string 'how to reminder in window as display message' (length=44)
  public 'provider_url' => string 'https://www.youtube.com/' (length=24)
  public 'thumbnail_url' => string 'https://i.ytimg.com/vi/_7s-6V_0nwA/hqdefault.jpg' (length=48)
  public 'author_name' => string 'H2 ZONE' (length=7)
  public 'type' => string 'video' (length=5)
  public 'author_url' => string 'https://www.youtube.com/channel/UC9M35YwDs8_PCWXd3qkiNzg' (length=56)
  public 'provider_name' => string 'YouTube' (length=7)
  public 'height' => int 270
  public 'html' => string '<iframe width="480" height="270" src="https://www.youtube.com/embed/_7s-6V_0nwA?feature=oembed" frameborder="0" allow="autoplay; encrypted-media" allowfullscreen></iframe>' (length=171)
  public 'thumbnail_height' => int 360

Po szczegóły Możesz również zobaczyć https://www.youtube.com/watch?v=mXde7q59BI8 Video tutorial 1

Metoda 2: korzystanie z youtube img link https://img.youtube.com/vi / "Wstaw-youtube-video-id-tutaj" /default.jpg

Metoda 3: korzystanie z kodu źródłowego przeglądarki do pobierania miniaturek za pomocą linku URL wideo - przejdź do kodu źródłowego wideo i wyszukaj miniaturkę Teraz możesz użyć tego adresu url do Twój kod sorce: {img src="https://img.youtube.com/vi /" Wstaw-youtube-video-id-tutaj "/default.jpg"}

Po szczegóły Możesz również zobaczyć http://hzonesp.com/php/get-youtube-video-thumbnail-using-id / lub https://www.youtube.com/watch?v=9f6E8MeM6PI Video tutorial 2

Oto prosta funkcja, którą stworzyłem, aby uzyskać miniatury, jest łatwa do zrozumienia i użycia. $link jest linkiem youtube skopiowanym dokładnie tak, jak jest w przeglądarce, na przykład https://www.youtube.com/watch?v=BQ0mxQXmLsk

    function get_youtube_thumb($link){
    $new=str_replace('https://www.youtube.com/watch?v=','', $link);
    $thumbnail='https://img.youtube.com/vi/'.$new.'/0.jpg';
    return $thumbnail;
}

Użyj tego - img.youtube.com/vi/YouTubeID/ImageFormat.jpg tutaj formaty obrazu są różne jak default, hqdefault, maxresdefault.

To jest moje rozwiązanie po stronie klienta, które nie wymaga klucza API.

YouTube.parse('https://www.youtube.com/watch?v=P3DGwyl0mJQ').then(_ => console.log(_))

Kod:

import { parseURL, parseQueryString } from './url'
import { getImageSize } from './image'

const PICTURE_SIZE_NAMES = [
    // 1280 x 720.
    // HD aspect ratio.
    'maxresdefault',
    // 629 x 472.
    // non-HD aspect ratio.
    'sddefault',
    // For really old videos not having `maxresdefault`/`sddefault`.
    'hqdefault'
]

// - Supported YouTube URL formats:
//   - http://www.youtube.com/watch?v=My2FRPA3Gf8
//   - http://youtu.be/My2FRPA3Gf8
export default
{
    parse: async function(url)
    {
        // Get video ID.
        let id
        const location = parseURL(url)
        if (location.hostname === 'www.youtube.com') {
            if (location.search) {
                const query = parseQueryString(location.search.slice('/'.length))
                id = query.v
            }
        } else if (location.hostname === 'youtu.be') {
            id = location.pathname.slice('/'.length)
        }

        if (id) {
            return {
                source: {
                    provider: 'YouTube',
                    id
                },
                picture: await this.getPicture(id)
            }
        }
    },

    getPicture: async (id) => {
        for (const sizeName of PICTURE_SIZE_NAMES) {
            try {
                const url = getPictureSizeURL(id, sizeName)
                return {
                    type: 'image/jpeg',
                    sizes: [{
                        url,
                        ...(await getImageSize(url))
                    }]
                }
            } catch (error) {
                console.error(error)
            }
        }
        throw new Error(`No picture found for YouTube video ${id}`)
    },

    getEmbeddedVideoURL(id, options = {}) {
        return `https://www.youtube.com/embed/${id}`
    }
}

const getPictureSizeURL = (id, sizeName) => `https://img.youtube.com/vi/${id}/${sizeName}.jpg`

Użyteczność image.js:

// Gets image size.
// Returns a `Promise`.
function getImageSize(url)
{
    return new Promise((resolve, reject) =>
    {
        const image = new Image()
        image.onload = () => resolve({ width: image.width, height: image.height })
        image.onerror = reject
        image.src = url
    })
}

Użyteczność url.js:

// Only on client side.
export function parseURL(url)
{
    const link = document.createElement('a')
    link.href = url
    return link
}

export function parseQueryString(queryString)
{
    return queryString.split('&').reduce((query, part) =>
    {
        const [key, value] = part.split('=')
        query[decodeURIComponent(key)] = decodeURIComponent(value)
        return query
    },
    {})
}

public const string tubeThumb = "http://i.ytimg.com/vi/[id]/hqdefault.jpg";
vid.Thumbnail = tubeThumb.Replace("[id]", vid.VideoID);

Zapisz plik jako .js

  var maxVideos = 5;
  $(document).ready(function(){
  $.get(
    "https://www.googleapis.com/youtube/v3/videos",{
      part: 'snippet,contentDetails',
      id:'your_video_id',
      kind: 'youtube#videoListResponse',
      maxResults: maxVideos,
      regionCode: 'IN',
      key: 'Your_API_KEY'},
      function(data){
        var output;
        $.each(data.items, function(i, item){
          console.log(item);
                thumb = item.snippet.thumbnails.high.url;
          output = '<div id="img"><img src="' + thumb + '"></div>';
          $('#thumbnail').append(output);
        })
        
      }
    );
}); 

.main{
 width:1000px;
 margin:auto;
}
#img{
float:left;
display:inline-block;
margin:5px;
}

<!DOCTYPE html>
<html>
<head>
  <title>Thumbnails</title>
  <script src="//ajax.googleapis.com/ajax/libs/jquery/1.10.2/jquery.min.js" type="text/javascript"></script>
</head>
<body>
<div class="main">
 <ul id="thumbnail"> </ul>
</div>
</body>
</html>