Obter miniaturas img do Vimeo?

308

Quero obter uma imagem em miniatura para vídeos do Vimeo.

Ao obter imagens do Youtube, eu faço assim:

http://img.youtube.com/vi/HwP5NG-3e8I/2.jpg

Alguma idéia de como fazer para o Vimeo?

Aqui está a mesma pergunta, sem qualquer resposta.

Johan
fonte
3
Você verificou se é legal obter essas imagens para usá-las em seu site? Se não, então é um ponto discutível para começar.
Lothar
12
Sim, é legal - ambos os sites fornecem esses detalhes de uma maneira muito pública, pois eles querem que você use o conteúdo deles! Afinal, todos os vídeos incorporados retornam ao site de hospedagem.
Magnus Smith
1
Se você deseja garantir que sua página não seja dependente do servidor vimeo e o desempenho seja otimizado, sugiro que você faça isso em javascript. A desvantagem é que ele não mostrará o polegar para usuários sem javascript, mas um espaço reservado apropriado com o link deve ser amigável o suficiente. (mudança .xml para .json em sua solicitação de API para vimeo)
Myster
tente esta resposta: stackoverflow.com/a/17156853/146602 - facilita muito a captura de informações / dados sobre qualquer vídeo do vimeo com apenas o URL.
Phirschybar
1
i.vimeocdn.com/video/528073804_200x200.webp dessa maneira, você pode obter uma imagem de vídeo
Pus

Respostas:

361

Nos documentos da API simples do Vimeo :

Fazendo uma solicitação de vídeo

Para obter dados sobre um vídeo específico, use o seguinte URL:

http://vimeo.com/api/v2/video/video_id.output

video_id O ID do vídeo para o qual você deseja informações.

saída Especifique o tipo de saída. Atualmente, oferecemos os formatos JSON, PHP e XML.

Então, obtenha este URL http://vimeo.com/api/v2/video/6271487.xml

    <videos> 
      <video> 
        [skipped]
        <thumbnail_small>http://ts.vimeo.com.s3.amazonaws.com/235/662/23566238_100.jpg</thumbnail_small> 
        <thumbnail_medium>http://ts.vimeo.com.s3.amazonaws.com/235/662/23566238_200.jpg</thumbnail_medium> 
        <thumbnail_large>http://ts.vimeo.com.s3.amazonaws.com/235/662/23566238_640.jpg</thumbnail_large> 
        [skipped]
    </videos>

Analise isso para cada vídeo para obter a miniatura

Aqui está o código aproximado em PHP

<?php

$imgid = 6271487;

$hash = unserialize(file_get_contents("http://vimeo.com/api/v2/video/$imgid.php"));

echo $hash[0]['thumbnail_medium'];  
Fofo
fonte
OK, fixe. Eu não estou familiarizado com isso xml. Como posso obter thumbnail_smallcom php?
Johan
Para obtê-lo com PHP, primeiro use a extensão php em URL como vimeo.com/api/v2/video/6271487.php , você receberá um arquivo, cuja primeira linha parece ser um hash php serializado, use unserialize e depois simplesmente ler as entradas que deseja
Fluffy
1
Obrigado, o URL funciona bem. Além disso, a API acima não funciona; acesse vimeo.com/api para ler sobre isso.
fedmich
5
Você também pode alterar o tamanho e o tipo de arquivo da imagem. Por exemplo, você pode alterar o padrão thumbnail_largede i.vimeocdn.com/video/23566238_640.webp para i.vimeocdn.com/video/23566238_640.png ou i.vimeocdn.com/video/23566238_320.jpg
Michael McGinnis
28
Como a API está morta, essa resposta não é mais válida #
KnF
58

Em javascript (usa jQuery):

function vimeoLoadingThumb(id){    
    var url = "http://vimeo.com/api/v2/video/" + id + ".json?callback=showThumb";

    var id_img = "#vimeo-" + id;

    var script = document.createElement( 'script' );
    script.src = url;

    $(id_img).before(script);
}


function showThumb(data){
    var id_img = "#vimeo-" + data[0].id;
    $(id_img).attr('src',data[0].thumbnail_medium);
}

Para exibi-lo:

<img id="vimeo-{{ video.id_video }}" src="" alt="{{ video.title }}" />
<script type="text/javascript">
  vimeoLoadingThumb({{ video.id_video }});
</script>
Natim
fonte
Muito obrigado por isso, muito útil. Eu acho que há um erro de digitação muito pequeno. Você usa # nas variáveis ​​id_img, mas não tem o # no ID do elemento img. Seu exemplo pressupõe o uso de jQuery também? Troquei o $(id_img).beforee $(id_img).attrpara createElemente um mais básico getElementById(id_img).src, mas não teria conseguido se não fosse o seu exemplo.
Atomicules 13/03/11
3
A questão # é a sintaxe do JQuery, não um bug. Sim, assume o uso de JQuery.
Natim
Ah, ok então. Obrigado pelo esclarecimento. Não uso o JQuery com tanta frequência, mas a resposta ainda foi realmente útil para mim.
Atomicules
1
Este é o jsfiddle testável para o mesmo código: jsfiddle.net/archatas/Tv7GZ
Aidas Bendoraitis
Obrigado @AidasBendoraitis
Natim
45

Você deve analisar a resposta da API do Vimeo. Não há como fazer isso com chamadas de URL (como dailymotion ou youtube).

Aqui está minha solução PHP:

/**
 * Gets a vimeo thumbnail url
 * @param mixed $id A vimeo id (ie. 1185346)
 * @return thumbnail's url
*/
function getVimeoThumb($id) {
    $data = file_get_contents("http://vimeo.com/api/v2/video/$id.json");
    $data = json_decode($data);
    return $data[0]->thumbnail_medium;
}
Erdal G.
fonte
3
Obrigado por isso. Esta foi a minha solução favorita.
Bullyen
44

Usando o jQuery jsonp request:

<script type="text/javascript">
    $.ajax({
        type:'GET',
        url: 'http://vimeo.com/api/v2/video/' + video_id + '.json',
        jsonp: 'callback',
        dataType: 'jsonp',
        success: function(data){
            var thumbnail_src = data[0].thumbnail_large;
            $('#thumb_wrapper').append('<img src="' + thumbnail_src + '"/>');
        }
    });
</script>

<div id="thumb_wrapper"></div>
elatonsev
fonte
1
Eu gostaria de usar isso ... mas e se eu tiver vários vídeos em uma página? Alguma maneira de passar o ID para a chamada? Idealmente, eu gostaria de usar algo como <div id='12345678' class='vimeo_thumb'></div>- e isso seria preenchido com a miniatura img.
Dan
4
A chamada do método pode ser abreviada como$.getJSON('http://vimeo.com/api/v2/video/' + video_id + '.json?callback=?', function (data) {...
Sanghyun Lee 6/08/14
22

Com Ruby, você pode fazer o seguinte, se tiver:

url                      = "http://www.vimeo.com/7592893"
vimeo_video_id           = url.scan(/vimeo.com\/(\d+)\/?/).flatten.to_s               # extract the video id
vimeo_video_json_url     = "http://vimeo.com/api/v2/video/%s.json" % vimeo_video_id   # API call

# Parse the JSON and extract the thumbnail_large url
thumbnail_image_location = JSON.parse(open(vimeo_video_json_url).read).first['thumbnail_large'] rescue nil
Michel Barbosa
fonte
2
Nota: pode ser necessário require 'open-uri'permitir URI aberto para analisar e arquivos.
Kris
Eu tive que adicionar url.scan (/vimeo.com \ / (\ d +) \ /? /). Flatten.to_s.delete ("^ 0-9.") Para obter o ID do vimeo #
Abram
21

Aqui está um exemplo de como fazer a mesma coisa no ASP.NET usando C #. Sinta-se livre para usar uma imagem de captura de erro diferente :)

public string GetVimeoPreviewImage(string vimeoURL)
{
    try
    {
        string vimeoUrl = System.Web.HttpContext.Current.Server.HtmlEncode(vimeoURL);
        int pos = vimeoUrl.LastIndexOf(".com");
        string videoID = vimeoUrl.Substring(pos + 4, 8);

        XmlDocument doc = new XmlDocument();
        doc.Load("http://vimeo.com/api/v2/video/" + videoID + ".xml");
        XmlElement root = doc.DocumentElement;
        string vimeoThumb = root.FirstChild.SelectSingleNode("thumbnail_medium").ChildNodes[0].Value;
        string imageURL = vimeoThumb;
        return imageURL;
    }
    catch
    {
        //cat with cheese on it's face fail
        return "http://bestofepicfail.com/wp-content/uploads/2008/08/cheese_fail.jpg";
    }
}

NOTA: Sua solicitação de API deve ser assim quando solicitada: http://vimeo.com/api/v2/video/32660708.xml

Mtblewis
fonte
Bom, mas o link da API é apenas vimeo.com/api/v2/video/video_id.xml e não "video" na frente do ID do vídeo.
Martin Martin
Encurtou esse código e alterou o parâmetro para aceitar um ID do vimeo em vez do URL completo. (não pode descobrir como MULTILINE o bloco de código) public static string GetVimeoPreviewImage(string id) { try { XmlDocument doc = new XmlDocument(); doc.Load("http://vimeo.com/api/v2/video/" + id + ".xml"); return doc.DocumentElement.FirstChild.SelectSingleNode("thumbnail_medium").ChildNodes[0].Value; } catch { return string.Empty; } }
elkaz
14

A maneira mais fácil de JavaScript que encontrei para obter a miniatura, sem pesquisar o ID do vídeo, está usando:

//Get the video thumbnail via Ajax
$.ajax({
    type:'GET',
    url: 'https://vimeo.com/api/oembed.json?url=' + encodeURIComponent(url),
    dataType: 'json',
    success: function(data) {
        console.log(data.thumbnail_url);
    }
});

Nota: Se alguém precisar obter a miniatura do vídeo relacionada ao ID do vídeo, ele poderá substituí-lo pelo $idID do vídeo e obter um XML com os detalhes do vídeo:

http://vimeo.com/api/v2/video/$id.xml

Exemplo:

http://vimeo.com/api/v2/video/198340486.xml

Fonte

Roy Shoa
fonte
2
Esta é realmente a melhor resposta, pois o Vimeo reprovou a API v2. oEmbed não requer autenticação e retorna uma resposta JSON / XML contendo URLs em miniatura. developer.vimeo.com/apis/oembed
joemaller
1
Roy, como usamos essa chamada ajax ao procurar um vídeo específico por ID?
klewis
@blackhawk Eu não, mas eu pesquisei no google agora e encontrei algo para você, basta substituir o video_id pelo seu $ide você obterá um XML com os detalhes do vídeo (inclua miniaturas). http://vimeo.com/api/v2/video/$id.xml. por exemplo: http://vimeo.com/api/v2/video/198340486.xml. Fonte está aqui: coderwall.com/p/fdrdmg/get-a-thumbnail-from-a-vimeo-video
Roy Shoa
@blackhawk Eu edito minha resposta, você pode vê-la agora. Obrigado!
Roy Shoa 11/01
11

Se você deseja usar miniaturas através de js / jquery no api puro, pode usar esta ferramenta para capturar um quadro do vídeo e pronto! Insira o polegar da URL na fonte que você preferir.

Aqui está uma caneta de código:

http://codepen.io/alphalink/pen/epwZpJ

<img src="https://i.vimeocdn.com/video/531141496_640.jpg"` alt="" />

Aqui está o site para obter miniaturas:

http://video.depone.eu/

alphapilgrim
fonte
1
O site @blackhawk está de volta.
alphapilgrim
Parece que isso obtém um quadro aleatório, não a capa / miniatura oficial que o criador do vídeo selecionou. É bom saber que isso existe, mas acho que vou usar o método API json parse porque não há controle da arte da capa do lado do vimeo.
Squarecandy
9

Usando o URL do Vimeo ( https://player.vimeo.com/video/30572181 ), aqui está o meu exemplo

<!DOCTYPE html>
<html lang="en" xmlns="http://www.w3.org/1999/xhtml">
<head>
    <meta charset="utf-8" />
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <script src="http://code.jquery.com/jquery-latest.min.js" type="text/javascript"></script>
    <title>Vimeo</title>
</head>
<body>
    <div>
        <img src="" id="thumbImg">
    </div>
    <script>
        $(document).ready(function () {
            var vimeoVideoUrl = 'https://player.vimeo.com/video/30572181';
            var match = /vimeo.*\/(\d+)/i.exec(vimeoVideoUrl);
            if (match) {
                var vimeoVideoID = match[1];
                $.getJSON('http://www.vimeo.com/api/v2/video/' + vimeoVideoID + '.json?callback=?', { format: "json" }, function (data) {
                    featuredImg = data[0].thumbnail_large;
                    $('#thumbImg').attr("src", featuredImg);
                });
            }
        });
    </script>
</body>
</html>

Karthikeyan P
fonte
Você é o melhor.
Alexandr Kazakov
7

Parece que a API / V2 está morta.
Para usar a nova API, você precisa registrar seu aplicativo e a base64 codifica o client_ide client_secretcomo um cabeçalho de Autorização.

$.ajax({
    type:'GET',
    url: 'https://api.vimeo.com/videos/' + video_id,
    dataType: 'json',
    headers: {
        'Authorization': 'Basic ' + window.btoa(client_id + ":" + client_secret);
    },
    success: function(data) {
        var thumbnail_src = data.pictures.sizes[2].link;
        $('#thumbImg').attr('src', thumbnail_src);
    }
});

Por segurança, você pode retornar o client_ide client_secretjá codificado do servidor.

Diego Ponciano
fonte
1
base64 não é um hash. Não há nada mais "seguro" na codificação de base64 dos seus dados no servidor do que no lado do cliente. Dito isto, provavelmente é um pouco mais rápido.
precisa saber é o seguinte
7

Essa é uma maneira rápida e astuta de fazer isso, e também uma maneira de escolher um tamanho personalizado.

Eu vou aqui:

http://vimeo.com/api/v2/video/[VIDEO ID].php

Faça o download do arquivo, abra-o e encontre a miniatura de 640 pixels de largura. Ele terá um formato assim:

https://i.vimeocdn.com/video/[LONG NUMBER HERE]_640.jpg

Você pega o link, altera o 640 para - por exemplo - 1400 e acaba com algo assim:

https://i.vimeocdn.com/video/[LONG NUMBER HERE]_1400.jpg

Cole-o na barra de pesquisa do navegador e divirta-se.

Felicidades,

Amendoim
fonte
Este método não funciona. Retorna um arquivo php com VIDEO_ID não encontrado.
stldoug
5
function parseVideo(url) {
    // - Supported YouTube URL formats:
    //   - http://www.youtube.com/watch?v=My2FRPA3Gf8
    //   - http://youtu.be/My2FRPA3Gf8
    //   - https://youtube.googleapis.com/v/My2FRPA3Gf8
    // - Supported Vimeo URL formats:
    //   - http://vimeo.com/25451551
    //   - http://player.vimeo.com/video/25451551
    // - Also supports relative URLs:
    //   - //player.vimeo.com/video/25451551

    url.match(/(http:|https:|)\/\/(player.|www.)?(vimeo\.com|youtu(be\.com|\.be|be\.googleapis\.com))\/(video\/|embed\/|watch\?v=|v\/)?([A-Za-z0-9._%-]*)(\&\S+)?/);

    if (RegExp.$3.indexOf('youtu') > -1) {
        var type = 'youtube';
    } else if (RegExp.$3.indexOf('vimeo') > -1) {
        var type = 'vimeo';
    }

    return {
        type: type,
        id: RegExp.$6
    };
}

function getVideoThumbnail(url, cb) {
    var videoObj = parseVideo(url);
    if (videoObj.type == 'youtube') {
        cb('//img.youtube.com/vi/' + videoObj.id + '/maxresdefault.jpg');
    } else if (videoObj.type == 'vimeo') {
        $.get('http://vimeo.com/api/v2/video/' + videoObj.id + '.json', function(data) {
            cb(data[0].thumbnail_large);
        });
    }
}
Yangshun Tay
fonte
4

Na verdade, o cara que fez essa pergunta postou sua própria resposta.

"O Vimeo parece querer que eu faça uma solicitação HTTP e extraia a URL da miniatura do XML que eles retornam ..."

Os documentos da API do Vimeo estão aqui: http://vimeo.com/api/docs/simple-api

Em resumo, seu aplicativo precisa fazer uma solicitação GET para um URL como o seguinte:

http://vimeo.com/api/v2/video/video_id.output

e analise os dados retornados para obter o URL em miniatura necessário e faça o download do arquivo nesse URL.

Ian Kemp
fonte
4

Eu escrevi uma função em PHP para me permitir isso, espero que seja útil para alguém. O caminho para a miniatura está contido em uma tag de link na página de vídeo. Isso parece fazer o truque para mim.

    $video_url = "http://vimeo.com/7811853"  
    $file = fopen($video_url, "r");
    $filedata = stream_get_contents($file);
    $html_content = strpos($filedata,"<link rel=\"videothumbnail");
    $link_string = substr($filedata, $html_content, 128);
    $video_id_array = explode("\"", $link_string);
    $thumbnail_url = $video_id_array[3];
    echo $thumbnail_url;

Espero que ajude alguém.

Foggson

user342430
fonte
4
function getVimeoInfo($link)
 {
    if (preg_match('~^http://(?:www\.)?vimeo\.com/(?:clip:)?(\d+)~', $link, $match)) 
    {
        $id = $match[1];
    }
    else
    {
        $id = substr($link,10,strlen($link));
    }

    if (!function_exists('curl_init')) die('CURL is not installed!');
    $ch = curl_init();
    curl_setopt($ch, CURLOPT_URL, "http://vimeo.com/api/v2/video/$id.php");
    curl_setopt($ch, CURLOPT_HEADER, 0);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_TIMEOUT, 10);
    $output = unserialize(curl_exec($ch));
    $output = $output[0];
    curl_close($ch);
    return $output;
}`

// na função abaixo, passe o URL da miniatura.

function save_image_local($thumbnail_url)
    {

         //for save image at local server
         $filename = time().'_hbk.jpg';
         $fullpath = '../../app/webroot/img/videos/image/'.$filename;

         file_put_contents ($fullpath,file_get_contents($thumbnail_url));

        return $filename;
    }
chetanspeed511987
fonte
4

Decomposição da resposta de Karthikeyan P para que possa ser usada em uma variedade maior de cenários:

// Requires jQuery

function parseVimeoIdFromUrl(vimeoUrl) {
  var match = /vimeo.*\/(\d+)/i.exec(vimeoUrl);
  if (match)
    return match[1];

  return null;
};

function getVimeoThumbUrl(vimeoId) {
  var deferred = $.Deferred();
  $.ajax(
    '//www.vimeo.com/api/v2/video/' + vimeoId + '.json',
    {
        dataType: 'jsonp',
        cache: true
    }
  )
  .done(function (data) {
    // .thumbnail_small 100x75
    // .thumbnail_medium 200x150
    // 640 wide
        var img = data[0].thumbnail_large;
        deferred.resolve(img);  
    })
  .fail(function(a, b, c) {
    deferred.reject(a, b, c);
  });
  return deferred;
};

Uso

Obtenha um ID do Vimeo a partir de um URL de vídeo do Vimeo:

var vimeoId = parseVimeoIdFromUrl(vimeoUrl);

Obtenha um URL de miniatura do vimeo a partir de um ID do Vimeo:

getVimeoThumbUrl(vimeoIds[0])
.done(function(img) {
    $('div').append('<img src="' + img + '"/>');
});

https://jsfiddle.net/b9chris/nm8L8cc8/1/

Chris Moschini
fonte
4

ATUALIZAÇÃO: Esta solução parou de funcionar a partir de dezembro de 2018.

Eu estava procurando a mesma coisa e parece que a maioria das respostas aqui está desatualizada devido ao fato de a API Vimeo v2 estar obsoleta.

meu php 2 ¢:

$vidID     = 12345 // Vimeo Video ID
$tnLink = json_decode(file_get_contents('https://vimeo.com/api/oembed.json?url=https%3A//vimeo.com/' . $vidID))->thumbnail_url;

Com o exposto acima, você obterá o link para a imagem em miniatura padrão do Vimeo.

Se você quiser usar uma imagem de tamanho diferente, poderá adicionar algo como:

$tnLink = substr($tnLink, strrpos($tnLink, '/') + 1);
$tnLink = substr($tnLink, 0, strrpos($tnLink, '_')); // You now have the thumbnail ID, which is different from Video ID

// And you can use it with link to one of the sizes of crunched by Vimeo thumbnail image, for example:
$tnLink = 'https://i.vimeocdn.com/filter/overlay?src0=https%3A%2F%2Fi.vimeocdn.com%2Fvideo%2F' . $tnLink    . '_1280x720.jpg&src1=https%3A%2F%2Ff.vimeocdn.com%2Fimages_v6%2Fshare%2Fplay_icon_overlay.png';
zee
fonte
Você pode me ajudar com qualquer link de anúncio oficial, onde é mencionado que o v2 vimeo está obsoleto.
Deepak Yadav
3

Se você não precisar de uma solução automatizada, poderá encontrar o URL da miniatura digitando o ID do vimeo aqui: http://video.depone.eu/

Emily Ryan
fonte
Há outra resposta como esta nesta página acima.
precisa saber é o seguinte
2

Eu criei um CodePen que busca as imagens para você.

https://codepen.io/isramv/pen/gOpabXg

HTML

<input type="text" id="vimeoid" placeholder="257314493" value="257314493">
<button id="getVideo">Get Video</button>
<div id="output"></div>

JavaScript:

const videoIdInput = document.getElementById('vimeoid');
const getVideo = document.getElementById('getVideo');
const output = document.getElementById('output');

function getVideoThumbnails(videoid) {
  fetch(`https://vimeo.com/api/v2/video/${videoid}.json`)
  .then(response => {
    return response.text();
  })
  .then(data => {
    const { thumbnail_large, thumbnail_medium, thumbnail_small } = JSON.parse(data)[0];
    const small = `<img src="${thumbnail_small}"/>`;
    const medium = `<img src="${thumbnail_medium}"/>`;
    const large = `<img src="${thumbnail_large}"/>`;
    output.innerHTML = small + medium + large;
  })
  .catch(error => {
    console.log(error);
  });
}

getVideo.addEventListener('click', e => {
  if (!isNaN(videoIdInput.value)) {
    getVideoThumbnails(videoIdInput.value);
  }
});

insira a descrição da imagem aqui

Israel Morales
fonte
1

Se você está procurando uma solução alternativa e pode gerenciar a conta do vimeo de outra maneira, basta adicionar todos os vídeos que deseja exibir em um álbum e usar a API para solicitar os detalhes do álbum - em seguida, mostra todas as miniaturas e links . Não é o ideal, mas pode ajudar.

Ponto final da API (playground)

Convo no Twitter com @vimeoapi

sidonaldson
fonte
Talvez essa não seja a maneira mais eficiente de fazer isso, principalmente se (1) o restante do seu código não depender da API do Vimeo e (2) você tiver a sensação de que suas chamadas à API podem ir além do que o Vimeo possui definido como um limite.
klewis
@blackhawk você perdeu o meu ponto. É alternativa. Se você fizer isso, terá todos os seus vídeos em uma única chamada de API. Você pode armazenar em cache esse lado do servidor, por exemplo.
Sidneyson
1

Você pode dar uma olhada na joia de Matt Hooks. https://github.com/matthooks/vimeo

Ele fornece um invólucro simples do vimeo para a API.

Tudo o que você precisa é armazenar o video_id (e o provedor, se você também estiver fazendo outros sites de vídeo)

Você pode extrair o ID do vídeo do vimeo assim

def 
  get_vimeo_video_id (link)
        vimeo_video_id = nil
        vimeo_regex  = /http:\/\/(www\.)?vimeo.com\/(\d+)($|\/)/
        vimeo_match = vimeo_regex.match(link)


if vimeo_match.nil?
  vimeo_regex  = /http:\/\/player.vimeo.com\/video\/([a-z0-9-]+)/
  vimeo_match = vimeo_regex.match(link)
end

    vimeo_video_id = vimeo_match[2] unless vimeo_match.nil?
    return vimeo_video_id
  end

e se você precisar de tubo você pode achar isso útil

def
 get_youtube_video_id (link)
    youtube_video_id = nil
    youtube_regex  = /^(https?:\/\/)?(www\.)?youtu.be\/([A-Za-z0-9._%-]*)(\&\S+)?/
    youtube_match = youtube_regex.match(link)

if youtube_match.nil?
  youtubecom_regex  = /^(https?:\/\/)?(www\.)?youtube.com\/watch\?v=([A-Za-z0-9._%-]*)(\&\S+)?/
  youtube_match = youtubecom_regex.match(link)
end

youtube_video_id = youtube_match[3] unless youtube_match.nil?
return youtube_video_id
end
Agustin
fonte
0

Para aqueles que ainda querem uma maneira de obter a miniatura apenas via URL, assim como o Youtube, construíram um pequeno aplicativo que a busca apenas com o ID do Vimeo.

https://vumbnail.com/358629078.jpg

Basta conectar o seu ID de vídeo e ele será puxado e armazenado em cache por 24 horas para que ele seja mais rápido.

Se você quiser fazer o seu próprio, pode fazê-lo aqui .

Repo

Sam Carlton
fonte
-3

Para alguém como eu, que está tentando descobrir isso recentemente,

https://i.vimeocdn.com/video/[video_id]_[dimension].webp funciona para mim.

(onde dimension= 200x150 | 640)

novasaint
fonte
1
Bom achado. Isso é realmente limpo.
Ben Harrison
Não grande, exceto o Safari no iOS não exibir o WebP
Gregory Magarshak
9
Parece estar errado - recebo uma foto que não tem nada a ver com o vídeo real. O ID usado no URL do polegar é diferente do ID do vídeo. Se você ligar para a API, receberá esse URL com IDs diferentes. Não há atalho para chamar a API.
Morten Holmgaard
12
Isso não funciona, o video_id e o image_id não são os mesmos. Assim, você obterá uma imagem que não pertence ao vídeo solicitado
Nicolas Azrak
O vídeo Id e Id em miniatura é diferente
Muhammad Hassaan