Como posso obter uma miniatura de vídeo do YouTube da API do YouTube?

Pode usar API de dados do YouTube para obter as miniaturas de Vídeo, Legenda, descrição, classificação, estatísticas e muito mais. A versão 3 da API requer uma chave*. Obter a chave e criar um Vídeos: lista pedido:

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

Exemplo de código 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);

Resultado

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)
  }
}

* não só que você precisa de uma chave, você pode ser solicitado para informações de faturamento, dependendo do número de pedidos de API que você planeja fazer. No entanto, poucos milhões os pedidos por dia são gratuitos.

Artigo de Base

(O tamanho da imagem depende do vídeo.)

• Miniatura De Fundo do leitor (480x360 pixels)
  https://i1.ytimg.com/vi/G0wGs3useV8/0.jpg

• Iniciar a miniatura (120x90 pixels)
  https://i1.ytimg.com/vi/G0wGs3useV8/1.jpg

• Miniatura do meio (120x90 pixels)
  https://i1.ytimg.com/vi/G0wGs3useV8/2.jpg

• Miniatura Final (120x90 pixels)
  https://i1.ytimg.com/vi/G0wGs3useV8/3.jpg

• Miniatura de alta qualidade (480x360 pixels)
  https://i1.ytimg.com/vi/G0wGs3useV8/hqdefault.jpg

• Miniatura de qualidade média (320x180 pixels)
  https://i1.ytimg.com/vi/G0wGs3useV8/mqdefault.jpg

• Miniatura de qualidade Normal (120x90 pixels)
  https://i1.ytimg.com/vi/G0wGs3useV8/default.jpg

E adicionalmente, as duas miniaturas seguintes podem ou não existir. Para vídeos de QG eles existem.

• Miniatura da definição-padrão (640x480 pixels)
  https://i1.ytimg.com/vi/G0wGs3useV8/sddefault.jpg

• Miniatura De Resolução Máxima (1920x1080 pixels)
  https://i1.ytimg.com/vi/G0wGs3useV8/maxresdefault.jpg

Você pode obter os scripts JavaScript e PHP para obter as miniaturas e outras Informações do YouTube em

• Como obter informações de vídeo do YouTube com PHP
• obter detalhes de vídeo do YouTube usando JavaScript-JSON & API v2

Também use a ferramenta Gerador de informação de vídeo do YouTube para obter todas as informação de um vídeo do YouTube através do envio de um URL {[70] } ou ID de vídeo.

Na API v3 do YouTube também podemos usar estes URLs para obter miniaturas... São classificados com base na sua qualidade.

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

E para a resolução máxima..

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

Se você quer a maior imagem do YouTube para um ID de vídeo específico, então o URL deve ser algo como isto:

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

Se usar a API, poderá apanhar a imagem predefinida da miniatura. Código simples deve ser algo assim:

//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);

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

E se você não pode usar .webp Extensão você pode fazê-lo assim:

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

Também, se precisar da versão sem escala use maxresdefault em vez de mqdefault.

Nota: Não tenho a certeza quanto às proporções se planeia usar maxresdefault.

Fiz uma função para apenas obter imagens existentes no 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;
}

In YouTube Data API v3 , you can get video's thumbnails with the videos->list function. De um trecho.miniatura.(chave) , você pode escolher a miniatura de resolução predefinida, média ou alta, e obter a sua largura, altura e URL.

Você também pode actualizar as miniaturas com a funcionalidade thumbnails->set.

Por exemplo, você pode verificar o YouTube API Samples projeto. (PHP ones .)

Poderá obter o item de vídeo que contém o URL da miniatura do vídeo. Há um código de exemplo no link. Ou, se você quiser processar XML, há informação AQUI . O XML devolvido tem um elemento media:thumbnail, que contém o URL da miniatura.

// 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;

O YouTube é propriedade do Google e o Google gosta de ter um número razoável de imagens para diferentes tamanhos de tela, portanto, as suas imagens são armazenadas em diferentes tamanhos, aqui está um exemplo de como a sua miniatura como ele vai gostar

Miniatura de baixa qualidade:

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

Miniatura de qualidade média:

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

Miniatura de alta qualidade:

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

Miniatura de Qualidade Máxima:

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

YOUTUBE API VERSION 3 * * UP AND RUNNING IN 2 MINUTES * *

Se tudo o que queres fazer é procurar no YouTube e obter propriedades associadas:

1. Obter uma API pública -- esta ligação dá uma boa direcção

2.Usar o texto abaixo da pesquisa. A pesquisa (denotada por q=) no texto url é stackoverflow para fins de exemplo. YouTube irá então enviar-lhe de volta uma resposta json onde você pode então processar para Thumbnail, excerto, Autor, etc.

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

Utilizar:

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

Acima está a ligação. Usando isso, você pode encontrar as características do YouTube de vídeos. Depois de encontrar Características, Você pode obter vídeos da categoria selecionada. Depois disso, você pode encontrar imagens de vídeo selecionadas usando resposta de Asaph.

Tente a abordagem acima e você pode analisar tudo a partir do YouTube API .

Usei as miniaturas do YouTube desta forma:

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

Lembre-se que o YouTube impede de incluir imagens directamente do seu servidor

Encontrei esta ferramenta nifty que lhe permite criar a imagem com o botão de reprodução do YouTube colocado sobre a imagem:

• instalado no servidor para programar: https://github.com/halgatewood/youtube-thumbnail-enhancer

Apenas para adicionar/expandir as soluções dadas, eu sinto que é necessário notar que, como eu tinha este mesmo problema, pode realmente pegar vários vídeos do YouTube de conteúdo, neste caso, miniaturas, com um pedido de HTTP:

Usando um cliente de descanso, neste caso, HTTPFUL, você pode fazer algo assim:

<?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);

?>

Uma simples função php que criei para a miniatura do youtube e os tipos são

• predefinição
• 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;}
  

Outra boa alternativa seria usar a APIoEmbed que é suportada pelo YouTube.

Você simplesmente adiciona o seu Url do YouTube ao url oEmbed e receberá um JSON, incluindo uma miniatura e o código html para incorporar.

Exemplo:

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

Dar-te-ia:

{
  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
}

Leia a documentação para mais informações.

Se o vídeo for público ou não listado, você define a miniatura usando o método url. Se o vídeo for privado, você usa a api para obter a miniatura.

<?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';
}

API de dados do YouTube

O YouTube fornece-nos as 4 imagens geradas para cada vídeo através da API de dados (v3), para 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

1. primeiro obtenha a sua chave de API pública na consola de API do Google .
2. de acordo com a referência da miniatura do YouTube na documentação da API , você precisa acessar os recursos no excerto.miniatura.

3. De acordo com isto, você precisa colocar a sua URL assim -

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

Eu acho que eles são uma grande resposta para a miniatura, mas eu quero adicionar alguns outros urls para obter a miniatura do youtube muito facilmente. Só estou a receber uma mensagem da resposta do Asaph. Aqui estão alguns url para obter as miniaturas do youtube

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

Para a versão de alta qualidade da miniatura use um url semelhante a este:

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

Existe também uma versão de qualidade média da miniatura, usando um url semelhante ao HQ:

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

Para a versão-padrão da definição da miniatura, usar um url semelhante a este:

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

Para a versão de resolução máxima da miniatura, use um url semelhante a este:

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

Você pode obter o ID do vídeo a partir do url do vídeo do YouTube usando parse_url ,parse_str e depois inserir nos urls preditivos para imagens. Agradecimentos ao YouTube para os URLs preditivos

$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";

Pode usar esta ferramenta para gerar as miniaturas do 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');

Resposta superior optimizada para uso manual. O item de ID de vídeo sem separadores activa a selecção com um duplo-click.

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

O primeiro da lista é uma imagem de tamanho completo e outros são imagens de miniaturas. A imagem da miniatura por omissão (ie. um dos 1.jpg, 2.jpg, 3.jpg) riz:

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

Para a versão de alta qualidade da miniatura use um url semelhante ao isto:

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

Existe também uma versão de qualidade média da miniatura, usando um url semelhante ao HQ:

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

Para a versão-padrão da definição da miniatura, use um url semelhante a este:

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

Para a versão de resolução máxima da miniatura, use um url semelhante a este:

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

Todos os urls acima estão disponíveis em http também. Adicionalmente, o nome da máquina um pouco mais curto i3.ytimg.com funciona no lugar de img.youtube.com nos urls de exemplo acima.

Em alternativa, pode usar a API de dados do YouTube (v3) para obter imagens de miniaturas.

Método 1:

Você pode encontrar o vídeo do youtube todas as informações com a página json que tem até"thumbnail_url" http://www.youtube.com/oembed?format=json&url = {o seu url de vídeo vai para aqui}

Tipo url final 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); 

Saída

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

Para mais pormenores, também pode ver https://www.youtube.com/watch?v=mXde7q59BI8 tutorial de vídeo 1

Método 2: usar o IMG do youtube link https://img.youtube.com/vi / "insert-youtube-video-id-here"/default.jpg

Método 3: usar o código-fonte do navegador para obter a miniatura com a ligação de url do vídeo - ir para o código fonte de vídeo e procurar por thumbnailurl Agora você pode usar este url em o teu código de sorce: {img src="https://img.youtube.com/vi /" insert-youtube-video-id-here"/default.jpg "

Para mais detalhes, também pode ver http://hzonesp.com/php/get-youtube-video-thumbnail-using-id/ ou https://www.youtube.com/watch?v=9f6E8MeM6PI tutorial de vídeo 2

Aqui está uma função simples que eu criei para obter as miniaturas, é fácil de entender e usar. $link é o link do youtube copiado exatamente como está no navegador , por exemplo 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;
}

Usa isto ... img.youtube.com/vi/YouTubeID/ImageFormat.jpg aqui os formatos de imagem são diferentes como default, hqdefault, maxresdefault.

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

O código:

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`

Utilidade 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
    })
}

Utilidade 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);

Gravar o ficheiro como .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>