Se eu tiver um URL de vídeo do YouTube, existe alguma maneira de usar PHP e cURL para obter a miniatura associada da API do YouTube?

Cada vídeo do YouTube tem quatro imagens geradas. Eles estão previsivelmente formatados da seguinte maneira:

https://img.youtube.com/vi/<insert-youtube-video-id-here>/0.jpg
https://img.youtube.com/vi/<insert-youtube-video-id-here>/1.jpg
https://img.youtube.com/vi/<insert-youtube-video-id-here>/2.jpg
https://img.youtube.com/vi/<insert-youtube-video-id-here>/3.jpg

O primeiro da lista é uma imagem em tamanho real e outras são miniaturas. A imagem em miniatura padrão (ou seja, um dos 1.jpg, 2.jpg, 3.jpg) é:

https://img.youtube.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://img.youtube.com/vi/<insert-youtube-video-id-here>/hqdefault.jpg

Há também uma versão de miniatura de qualidade média, usando um URL semelhante ao HQ:

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

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

https://img.youtube.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://img.youtube.com/vi/<insert-youtube-video-id-here>/maxresdefault.jpg

Todos os URLs acima também estão disponíveis via HTTP. Além disso, o nome do host um pouco menor i3.ytimg.comfunciona no lugar deimg.youtube.com URLs de exemplo acima.

Como alternativa, você pode usar a API de dados do YouTube (v3) para obter imagens em miniatura.

Você pode usar a API de dados do YouTube para recuperar miniaturas de vídeos, legendas, descrição, classificação, estatísticas e muito mais. A API versão 3 requer uma chave *. Obtenha a chave e crie um vídeo: pedido de lista :

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

* Além de precisar de uma chave, você pode ser solicitado a fornecer informações de cobrança, dependendo do número de solicitações de API que planeja fazer. No entanto, poucos milhões de solicitações por dia são gratuitas.

Artigo de origem .

O que Asaph disse está certo. No entanto, nem todos os vídeos do YouTube contêm todas as nove miniaturas. Além disso, o tamanho da imagem das miniaturas depende do vídeo (os números abaixo são baseados em um).

Existem sete miniaturas garantidas:

| Thumbnail Name      | Size (px) | URL                                              |
|---------------------|-----------|--------------------------------------------------|
| Player Background   | 480x360   | https://i1.ytimg.com/vi/<VIDEO ID>/0.jpg         |
| Start               | 120x90    | https://i1.ytimg.com/vi/<VIDEO ID>/1.jpg         |
| Middle              | 120x90    | https://i1.ytimg.com/vi/<VIDEO ID>/2.jpg         |
| End                 | 120x90    | https://i1.ytimg.com/vi/<VIDEO ID>/3.jpg         |
| High Quality        | 480x360   | https://i1.ytimg.com/vi/<VIDEO ID>/hqdefault.jpg |
| Medium Quality      | 320x180   | https://i1.ytimg.com/vi/<VIDEO ID>/mqdefault.jpg |
| Normal Quality      | 120x90    | https://i1.ytimg.com/vi/<VIDEO ID>/default.jpg   |

Além disso, as outras duas miniaturas podem ou não existir. A presença deles provavelmente se baseia na qualidade do vídeo.

| Thumbnail Name      | Size (px) | URL                                                  |
|---------------------|-----------|------------------------------------------------------|
| Standard Definition | 640x480   | https://i1.ytimg.com/vi/<VIDEO ID>/sddefault.jpg     |
| Maximum Resolution  | 1920x1080 | https://i1.ytimg.com/vi/<VIDEO ID>/maxresdefault.jpg |

Você pode encontrar scripts JavaScript e PHP para recuperar miniaturas e outras informações do YouTube em:

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

Você também pode usar a ferramenta Gerador de informações de vídeo do YouTube para obter todas as informações sobre um vídeo do YouTube enviando um URL ou ID de vídeo.

Na API V3 do YouTube, também podemos usar esses URLs para obter miniaturas ... Eles são classificados com base em 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

Uma vantagem desses URLs sobre os URLs na primeira resposta é que esses URLs não são bloqueados por firewalls.

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

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

Usando a API, você pode pegar a imagem em miniatura padrão. Código simples deve ser algo como isto:

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

Se você quiser se livrar das "barras pretas" e fazê-lo como o YouTube, você pode usar:

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

E se você não pode usar a .webpextensão do arquivo, pode fazê-lo assim:

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

Além disso, se você precisar da versão sem escala, use em maxresdefaultvez demqdefault .

Nota: não tenho certeza sobre a proporção, se você planeja usar maxresdefault.

Eu criei uma função para buscar apenas imagens existentes do 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;
}

Na API de dados do YouTube v3 , você pode obter as miniaturas de vídeos com a função videos-> list . No snippet.thumbnails. (Chave) , você pode escolher a miniatura padrão, média ou alta resolução, e obter sua largura, altura e URL.

Você também pode atualizar as miniaturas com as miniaturas-> definir a funcionalidade.

Por exemplo, você pode conferir o projeto Amostras da API do YouTube . ( PHP ).

Você pode obter a entrada de vídeo que contém o URL para a miniatura do vídeo. Há um código de exemplo no link. Ou, se você deseja analisar o XML, há informações aqui . O XML retornado possui um media:thumbnailelemento 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 é de propriedade do Google e o Google gosta de ter um número razoável de imagens para diferentes tamanhos de tela, portanto, suas imagens são armazenadas em tamanhos diferentes. Aqui está um exemplo de como será sua miniatura:

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

API 3 do YouTube, versão 3, em funcionamento em 2 minutos

Se tudo o que você deseja fazer é pesquisar no YouTube e obter propriedades associadas:

1. Obter uma API pública - Este link fornece uma boa direção

2. Use a string de consulta abaixo. A consulta de pesquisa (indicada por q = ) na cadeia de URL é stackoverflow para fins de exemplo. O YouTube enviará de volta uma resposta JSON, onde você poderá analisar Miniatura, Snippet, Autor, etc.

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

Outra boa alternativa seria usar o oEmbed API que é suportada pelo YouTube.

Você simplesmente adiciona seu URL do YouTube ao URL incorporado e receberá um JSON incluindo uma miniatura e o código HTML para incorporação.

Exemplo:

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

Daria a você:

{
  "height":270,
  "width":480,
  "title":"example video for 2020",
  "thumbnail_width":480,
  "html":"...",
  "thumbnail_height":360,
  "version":"1.0",
  "provider_name":"YouTube",
  "author_url":"https:\/\/www.youtube.com\/channel\/UCza6VSQUzCON- AzlsrOLwaA",
  "thumbnail_url":"https:\/\/i.ytimg.com\/vi\/xUeJdWYdMmQ\/hqdefault.jpg",
  "author_name":"Pokics",
  "provider_url":"https:\/\/www.youtube.com\/",
  "type":"video"
}

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

Usar:

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

Acima está o link. Com isso, você pode encontrar as características dos vídeos do YouTube. Depois de encontrar as características, você pode obter vídeos da categoria selecionada. Depois disso, você poderá encontrar imagens de vídeo selecionadas usando a resposta do Asaph .

Experimente a abordagem acima e você pode analisar tudo da API do YouTube .

Eu usei as miniaturas do YouTube desta maneira:

$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 de que o YouTube impede a inclusão de imagens diretamente do servidor.

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

• Instalado no servidor para criação de scripts: https://github.com/halgatewood/youtube-thumbnail-enhancer

Apenas para adicionar / expandir as soluções fornecidas, sinto que é necessário observar que, como eu também tive esse problema, é possível capturar vários conteúdos de vídeos do YouTube, neste caso, miniaturas, com uma solicitação HTTP:

Usando um Rest Client, 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);

?>

API de dados do YouTube

O YouTube fornece as quatro imagens geradas para cada vídeo por meio da API de dados (v3), por exemplo,

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

Obtendo acesso às imagens por meio da API

1. Primeiro, obtenha sua chave de API pública no Google API Console .
2. De acordo com a referência de miniaturas do YouTube na documentação da API , você precisa acessar os recursos em snippet.thumbnails.

3. De acordo com isso, você precisa colocar seu URL da seguinte maneira:

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

Agora altere seu ID de vídeo e sua chave de API para o respectivo ID de vídeo e chave de API e sua resposta será uma saída JSON, fornecendo os quatro links nas miniaturas da variável de snippet (se todos estiverem disponíveis).

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 os URLs preditivos das imagens. Graças ao YouTube pelos 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/$ytID/maxresdefault.jpg";
print "https://img.youtube.com/vi/$ytID/mqdefault.jpg";
print "https://img.youtube.com/vi/$ytID/hqdefault.jpg";
print "https://img.youtube.com/vi/$ytID/sddefault.jpg";
print "https://img.youtube.com/vi/$ytID/default.jpg";

Você pode usar esta ferramenta para gerar miniaturas do YouTube

https://tools.tutsplanet.com/index.php/get-youtube-video-thumbnails

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

• padrã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;}

Se você estiver usando a API pública, a melhor maneira de fazer isso é usando if instruções.

Se o vídeo for público ou não listado, defina a miniatura usando o método URL. Se o vídeo for privado, você usará 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';
    }

Acho que são muitas as respostas para miniaturas, mas quero adicionar outros URLs para obter as miniaturas do YouTube com muita facilidade. Estou apenas pegando um texto da resposta de Asaph. Aqui estão alguns URLs para obter 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

Há também uma versão de miniatura de qualidade média, usando um URL semelhante à alta qualidade:

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

Para a versão de definição padrão da miniatura, use 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

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

Aqui está a melhor resposta otimizada para uso manual. O token de ID do vídeo sem separadores permite a seleção com um clique duplo.

Cada vídeo do YouTube tem quatro imagens geradas. Eles estão previsivelmente formatados da seguinte maneira:

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 em tamanho real e outras são miniaturas. (. Ie um dos imagem em miniatura padrão 1.jpg, 2.jpg, 3.jpg) é:

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

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

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

Há também uma versão de miniatura de qualidade média, usando um URL semelhante ao HQ:

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

Para a versão de definição padrã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 também estão disponíveis via HTTP. Além disso, o nome do host um pouco menor i3.ytimg.comfunciona no lugar dosimg.youtube.com URLs de exemplo acima.

Como alternativa, você pode usar a API de dados do YouTube (v3) para obter imagens em miniatura.

Método 1:

Você pode encontrar todas as informações de um vídeo do YouTube com uma página JSON que possui até "thumbnail_url", http://www.youtube.com/oembed?format=json&url= {o URL do seu vídeo está aqui}

Como aparência final do URL + código de teste PHP

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

Resultado

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 obter detalhes, você também pode ver Como obter uma miniatura de vídeo do YouTube usando id ou https://www.youtube.com/watch?v=mXde7q59BI8 tutorial em vídeo 1

Método 2:

Usando o link da imagem do YouTube, https://img.youtube.com/vi/ "insert-youtube-video-id-here" /default.jpg

Método 3:

Usando o código-fonte do navegador para obter miniaturas usando o link do URL do vídeo - vá para o código-fonte do vídeo e pesquise miniaturl. Agora você pode usar este URL no seu código-fonte:

{img src="https://img.youtube.com/vi/"insert-youtube-video-id-here"/default.jpg"}

Para obter detalhes, você também pode ver Como obter uma miniatura de vídeo do YouTube usando id ou https://www.youtube.com/watch?v=9f6E8MeM6PI tutorial em vídeo 2

Usar img.youtube.com/vi/YouTubeID/ImageFormat.jpg

Aqui, os formatos de imagem são diferentes, como padrão, hqdefault, maxresdefault.

Esta é a minha solução necessária sem chave de API do lado do cliente.

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`

Utilitário 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
    })
}

Utilitário 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
    },
    {})
}

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

Salve esse código no arquivo .php vazio e teste-o.

<img src="<?php echo youtube_img_src('9bZkp7q19f0', 'high');?>" />
<?php
// Get a YOUTUBE video thumb image's source url for IMG tag "src" attribute:
// $ID = YouYube video ID (string)
// $size = string (default, medium, high or standard)
function youtube_img_src ($ID = null, $size = 'default') {
    switch ($size) {
        case 'medium':
            $size = 'mqdefault';
            break;
        case 'high':
            $size = 'hqdefault';
            break;
        case 'standard':
            $size = 'sddefault';
            break;
        default:
            $size = 'default';
            break;
    }
    if ($ID) {
        return sprintf('https://img.youtube.com/vi/%s/%s.jpg', $ID, $size);
    }
    return 'https://img.youtube.com/vi/ERROR/1.jpg';
}

Obrigado.

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