Obtenez des vignettes img de Vimeo?

308

Je souhaite obtenir une vignette pour les vidéos de Vimeo.

Lorsque j'obtiens des images de Youtube, je fais juste ceci:

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

Une idée de comment faire pour Vimeo?

Voici la même question, sans aucune réponse.

Johan
la source
3
Avez-vous vérifié s'il est légal pour vous que ces images soient utilisées sur votre site? Sinon, c'est un point discutable pour commencer.
lothar
12
Oui, c'est légal - les deux sites Web fournissent ces informations de manière très publique, car ils veulent que vous utilisiez leur contenu! Après tout, toutes les vidéos intégrées renvoient vers le site d'hébergement.
Magnus Smith,
1
Si vous voulez vous assurer que votre page ne dépend pas du serveur vimeo et que les performances sont optimisées, je vous suggère de le faire en javascript. L'inconvénient est qu'il ne montrera pas le pouce pour les utilisateurs sans javascript, mais un espace réservé approprié avec le lien devrait être assez convivial. (changez .xml en .json sur votre demande d'api en vimeo)
Myster
essayez cette réponse: stackoverflow.com/a/17156853/146602 - il est très facile de récupérer des informations / données sur toute vidéo vimeo n'ayant que l'URL.
phirschybar
1
i.vimeocdn.com/video/528073804_200x200.webp de cette façon, vous pouvez obtenir une image vidéo
Pus

Réponses:

361

À partir des documents de l'API Vimeo Simple :

Faire une demande de vidéo

Pour obtenir des données sur une vidéo spécifique, utilisez l'URL suivante:

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

video_id L'ID de la vidéo pour laquelle vous souhaitez obtenir des informations.

sortie Spécifiez le type de sortie. Nous proposons actuellement des formats JSON, PHP et XML.

Donc, obtenir cette 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>

Analyser cela pour chaque vidéo pour obtenir la miniature

Voici le code approximatif en PHP

<?php

$imgid = 6271487;

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

echo $hash[0]['thumbnail_medium'];  
Duveteux
la source
OK bien. Je ne suis pas familier xmlcependant. Comment puis - je obtenir thumbnail_smallavec php?
Johan
Pour l'obtenir avec PHP, utilisez d'abord l'extension php dans une URL comme vimeo.com/api/v2/video/6271487.php , vous recevrez un fichier, dont la première ligne semble être un hachage php sérialisé, utilisez unserialize puis lisez simplement les entrées que vous voulez
Fluffy
1
Merci, l'URL fonctionne bien. aussi, l'API ci-dessus ne fonctionne pas, alors allez sur vimeo.com/api pour en savoir plus.
fedmich
5
Vous pouvez également modifier la taille et le type de fichier image. Par exemple, vous pouvez modifier la valeur thumbnail_largepar défaut de i.vimeocdn.com/video/23566238_640.webp à i.vimeocdn.com/video/23566238_640.png ou i.vimeocdn.com/video/23566238_320.jpg
Michael McGinnis
28
Comme l'API est morte, cette réponse n'est plus valide
KnF
58

En javascript (utilise 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);
}

Pour l'afficher:

<img id="vimeo-{{ video.id_video }}" src="" alt="{{ video.title }}" />
<script type="text/javascript">
  vimeoLoadingThumb({{ video.id_video }});
</script>
Natim
la source
Merci beaucoup pour cela, très utile. Je pense qu'il y a une très petite faute de frappe. Vous utilisez # dans les variables id_img, mais vous n'avez pas le # dans l'id de l'élément img. Votre exemple suppose-t-il également l'utilisation de jQuery? Je troqué le $(id_img).beforeet $(id_img).attrpour createElementet un plus basique getElementById(id_img).src, mais je n'ai pas du tout si ce n'était pas pour votre exemple.
atomicules
3
La question # est que la syntaxe JQuery n'est pas un bug. Oui, cela suppose l'utilisation de JQuery.
Natim
Ah, ok alors. Merci pour la clarification. Je n'utilise pas JQuery aussi souvent, mais la réponse m'a toujours été très utile.
atomicules
1
Ceci est le jsfiddle testable pour le même code: jsfiddle.net/archatas/Tv7GZ
Aidas Bendoraitis
Merci @AidasBendoraitis
Natim
45

Vous devez analyser la réponse de l'API de Vimeo. Il n'y a aucun moyen d'y accéder avec des appels URL (comme dailymotion ou youtube).

Voici ma solution 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.
la source
3
Merci pour ça. C'était ma solution préférée.
Bullyen
44

Utilisation de la requête jQuery jsonp:

<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
la source
1
J'aimerais l'utiliser ... mais que faire si j'ai plusieurs vidéos sur une page? Est-il possible de transmettre l'identifiant à l'appel? Idéalement, j'aimerais utiliser quelque chose comme <div id='12345678' class='vimeo_thumb'></div>- et cela serait rempli avec la vignette img.
Dan
4
L'appel de méthode peut être raccourci comme$.getJSON('http://vimeo.com/api/v2/video/' + video_id + '.json?callback=?', function (data) {...
Sanghyun Lee
22

Avec Ruby, vous pouvez faire ce qui suit si vous avez, disons:

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
la source
2
Remarque: vous devrez peut-être require 'open-uri'autoriser open à analyser les URI ainsi que les fichiers.
Kris
J'ai dû ajouter url.scan (/vimeo.com \ / (\ d +) \ /? /). Flatten.to_s.delete ("^ 0-9.") Pour obtenir l'ID vimeo #
Abram
21

Voici un exemple de la façon de faire la même chose dans ASP.NET en utilisant C #. N'hésitez pas à utiliser une image de capture d'erreur différente :)

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

REMARQUE: Votre demande d'API devrait ressembler à ce qui est demandé: http://vimeo.com/api/v2/video/32660708.xml

Mtblewis
la source
Bien , mais le lien API est uniquement vimeo.com/api/v2/video/video_id.xml et non "vidéo" devant l'ID vidéo.
Martin
Raccourci ce code et a changé le paramètre pour accepter un identifiant vimeo au lieu de l'URL complète. (impossible de comprendre comment multiligner le bloc de code) 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

La méthode JavaScript la plus simple que j'ai trouvée pour obtenir la miniature, sans rechercher l'ID de la vidéo, utilise:

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

Remarque: Si quelqu'un a besoin d'obtenir la vignette vidéo liée à l'ID vidéo, il peut remplacer le $idpar l'ID vidéo et obtenir un XML avec les détails de la vidéo:

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

Exemple:

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

La source

Roy Shoa
la source
2
C'est vraiment la meilleure réponse puisque Vimeo a déprécié l'API v2. oEmbed ne nécessite pas d'authentification et renvoie une réponse JSON / XML contenant des URL de vignettes. developer.vimeo.com/apis/oembed
joemaller
1
Roy, comment utilisons-nous cet appel ajax lors de la recherche d'une vidéo spécifique par ID?
klewis
@blackhawk Je ne le fais pas, mais je le recherche sur Google maintenant et j'ai trouvé quelque chose pour vous, remplacez simplement le video_id par votre $idet vous obtiendrez un XML avec les détails de la vidéo (y compris les miniatures). http://vimeo.com/api/v2/video/$id.xml. par exemple: http://vimeo.com/api/v2/video/198340486.xml. La source est ici: coderwall.com/p/fdrdmg/get-a-thumbnail-from-a-vimeo-video
Roy Shoa
@blackhawk Je modifie ma réponse, vous pouvez la voir maintenant. Merci!
Roy Shoa
11

Si vous souhaitez utiliser la miniature via pure js / jquery no api, vous pouvez utiliser cet outil pour capturer une image de la vidéo et le tour est joué! Insérez le pouce de l'url dans la source que vous aimez.

Voici un stylo code:

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

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

Voici le site pour obtenir la vignette:

http://video.depone.eu/

alphapilgrim
la source
1
Le site @blackhawk est de retour.
alphapilgrim
On dirait que cela obtient une image aléatoire, pas la couverture / miniature officielle que le créateur de la vidéo a sélectionnée. C'est bien de savoir que cela existe, mais je pense que j'utiliserai la méthode d'analyse json de l'API car il n'y a aucun contrôle sur la pochette du côté vimeo avec cela.
squarecandy
9

En utilisant l'url Vimeo ( https://player.vimeo.com/video/30572181 ), voici mon exemple

<!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
la source
Tu es le meilleur.
Alexandr Kazakov
7

Il semble que api / v2 soit mort.
Pour utiliser la nouvelle API, vous devez enregistrer votre application et coder en base64 le client_idet en client_secrettant qu'en-tête d'autorisation.

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

Pour des raisons de sécurité, vous pouvez renvoyer le client_idet client_secretdéjà encodé depuis le serveur.

Diego Ponciano
la source
1
base64 n'est pas un hachage. Il n'y a rien de plus «sécurisé» dans le codage en base64 de vos données sur le serveur que dans le codage côté client. Cela dit, c'est probablement un peu plus rapide.
Sumurai8
7

C'est une façon astucieuse et rapide de le faire, et aussi un moyen de choisir une taille personnalisée.

Je vais ici:

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

Téléchargez le fichier, ouvrez-le et trouvez la vignette de 640 pixels de large, il aura un format comme celui-ci:

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

Vous prenez le lien, changez le 640 pour - par exemple - 1400, et vous vous retrouvez avec quelque chose comme ceci:

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

Collez-le sur la barre de recherche de votre navigateur et profitez-en.

À votre santé,

Cacahuètes
la source
Cette méthode ne fonctionne pas. Renvoie un fichier php avec VIDEO_ID introuvable.
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
la source
4

En fait, le gars qui a posé cette question a publié sa propre réponse.

"Vimeo semble vouloir que je fasse une requête HTTP et que j'extrait l'URL de la vignette du XML qu'ils renvoient ..."

Les documents de l'API Vimeo sont ici: http://vimeo.com/api/docs/simple-api

En bref, votre application doit effectuer une demande GET vers une URL comme celle-ci:

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

et analysez les données retournées pour obtenir l'URL miniature dont vous avez besoin, puis téléchargez le fichier à cette URL.

Ian Kemp
la source
4

J'ai écrit une fonction en PHP pour me permettre cela, j'espère que cela sera utile à quelqu'un. Le chemin d'accès à la miniature est contenu dans une balise de lien sur la page vidéo. Cela semble faire l'affaire pour moi.

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

J'espère que cela aide n'importe qui.

Foggson

user342430
la source
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;
}`

// à la fonction ci-dessous, passez l'url de la vignette.

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
la source
4

Décomposer la réponse de Karthikeyan P afin qu'elle puisse être utilisée dans un plus large éventail de scénarios:

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

Usage

Obtenez un identifiant Vimeo à partir d'une URL de vidéo Vimeo:

var vimeoId = parseVimeoIdFromUrl(vimeoUrl);

Obtenez une URL de vignette vimeo à partir d'un identifiant Vimeo:

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

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

Chris Moschini
la source
4

METTRE À JOUR: Cette solution a cessé de fonctionner en décembre 2018.

Je cherchais la même chose et il semble que la plupart des réponses ici soient obsolètes en raison de la dépréciation de l'API Vimeo v2.

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

avec ce qui précède, vous obtiendrez le lien vers l'image miniature par défaut de Vimeo.

Si vous souhaitez utiliser une image de taille différente, vous pouvez ajouter quelque chose comme:

$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
la source
S'il vous plaît, pouvez-vous m'aider avec un lien d'annonce officiel où il est mentionné que v2 vimeo est obsolète.
Deepak Yadav
3

Si vous n'avez pas besoin d'une solution automatisée, vous pouvez trouver l'URL miniature en entrant l'ID vimeo ici: http://video.depone.eu/

Emily Ryan
la source
Il y a une autre réponse comme celle-ci sur cette page ci-dessus.
alphapilgrim
2

J'ai créé un CodePen qui récupère les images pour vous.

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

entrez la description de l'image ici

Israel Morales
la source
1

Si vous cherchez une solution alternative et pouvez gérer le compte vimeo il y a une autre façon, vous ajoutez simplement chaque vidéo que vous souhaitez montrer dans un album puis utilisez l'API pour demander les détails de l'album - il affiche alors toutes les vignettes et les liens . Ce n'est pas idéal mais pourrait aider.

Point de terminaison API (aire de jeux)

Convo Twitter avec @vimeoapi

sidonaldson
la source
Ce n'est peut-être pas la façon la plus efficace de s'y prendre, surtout si (1) le reste de votre code ne dépend pas de l'API Vimeo, et (2) vous avez un bon sentiment que vos appels API peuvent aller au-delà de ce que Vimeo a fixé comme limite.
klewis
@blackhawk vous avez manqué mon point. C'est une alternative. Si vous faites cela, vous avez toutes vos vidéos en un seul appel API. Vous pouvez mettre en cache ce côté serveur par exemple.
sidonaldson
1

Vous voudrez peut-être jeter un œil au joyau de Matt Hooks. https://github.com/matthooks/vimeo

Il fournit un simple wrapper vimeo pour l'api.

Tout ce dont vous avez besoin est de stocker le video_id (et le fournisseur si vous faites également d'autres sites vidéo)

Vous pouvez extraire l'identifiant vidéo vimeo comme ceci

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

et si vous avez besoin de votre tube, vous pourriez trouver cela utile

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
la source
0

Pour ceux qui veulent toujours un moyen d'obtenir la miniature via URL uniquement, tout comme Youtube, a construit une petite application qui la récupère avec juste l'ID Vimeo.

https://vumbnail.com/358629078.jpg

Il vous suffit de brancher votre ID vidéo et il le tirera et le mettra en cache pendant 24 heures pour qu'il serve rapidement.

Si vous voulez faire tourner le vôtre, vous pouvez le faire ici .

Repo

Sam Carlton
la source
-3

Pour quelqu'un comme moi qui essaie de comprendre cela récemment,

https://i.vimeocdn.com/video/[video_id]_[dimension].webp travaille pour moi.

(où dimension= 200x150 | 640)

novasaint
la source
1
Belle trouvaille. C'est vraiment propre.
Ben Harrison
Super sauf safari sur iOS n'affiche pas le webp
Gregory Magarshak
9
Cela semble être faux - j'obtiens une image qui n'a rien à voir avec la vidéo réelle. L'ID utilisé dans l'URL du pouce est différent de l'ID vidéo - si vous appelez l'API, vous obtiendrez cette URL avec des ID différents. Il n'y a pas de raccourci pour appeler l'API.
Morten Holmgaard
12
Cela ne fonctionne pas, video_id et image_id ne sont pas les mêmes. Ainsi, vous obtiendrez une image qui n'appartient pas à la vidéo que vous avez demandée
Nicolas Azrak
La vidéo Id et Id dans la miniature est différente
Muhammad Hassaan