Img Thumbnails von Vimeo bekommen?

308

Ich möchte ein Miniaturbild für Videos von Vimeo erhalten.

Wenn ich Bilder von Youtube bekomme, mag ich das einfach so:

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

Irgendeine Idee, wie man es für Vimeo macht?

Hier ist die gleiche Frage ohne Antwort.

Johan
quelle
3
Haben Sie überprüft, ob es für Sie legal ist, diese Bilder auf Ihrer Website zu verwenden? Wenn nicht, dann ist es zunächst ein strittiger Punkt.
Lothar
12
Ja, es ist legal - beide Websites stellen diese Details auf sehr öffentliche Weise zur Verfügung, da sie möchten, dass Sie ihre Inhalte verwenden! Alle eingebetteten Videos verlinken schließlich wieder auf die Hosting-Site.
Magnus Smith
1
Wenn Sie sicherstellen möchten, dass Ihre Seite nicht vom Vimeo-Server abhängig ist und die Leistung optimiert wird, empfehlen wir Ihnen, dies in Javascript zu tun. Der Nachteil ist, dass der Daumen für Benutzer ohne Javascript nicht angezeigt wird, aber ein geeigneter Platzhalter mit dem Link sollte freundlich genug sein. (Ändern Sie .xml in .json auf Ihrer API-Anfrage an vimeo)
Myster
Versuchen Sie diese Antwort: stackoverflow.com/a/17156853/146602 - macht es sehr einfach, Informationen / Daten zu jedem Vimeo-Video abzurufen , das nur die URL enthält.
Phirschybar
1
i.vimeocdn.com/video/528073804_200x200.webp Auf diese Weise erhalten Sie ein Videobild
Eiter

Antworten:

361

Aus den Vimeo Simple API-Dokumenten :

Eine Videoanfrage stellen

Verwenden Sie die folgende URL, um Daten zu einem bestimmten Video abzurufen:

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

video_id Die ID des Videos, für das Sie Informationen wünschen.

Ausgabe Geben Sie den Ausgabetyp an. Derzeit bieten wir JSON-, PHP- und XML-Formate an.

Erhalten Sie also diese 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>

Analysieren Sie dies für jedes Video, um die Miniaturansicht zu erhalten

Hier ist der ungefähre Code in PHP

<?php

$imgid = 6271487;

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

echo $hash[0]['thumbnail_medium'];  
Flauschige
quelle
OK gut. Ich bin allerdings nicht vertraut xml. Wie kann ich thumbnail_smallmit php?
Johan
Um es mit PHP zu bekommen, verwenden Sie zuerst die PHP-Erweiterung in einer URL wie vimeo.com/api/v2/video/6271487.php . Sie erhalten eine Datei, deren erste Zeile ein serialisierter PHP-Hash zu sein scheint. Verwenden Sie unserialize und dann lesen Sie einfach die Einträge, die Sie wollen
Fluffy
1
Danke, die URL funktioniert gut. Außerdem funktioniert die oben genannte API nicht. Gehen Sie daher zu vimeo.com/api , um mehr darüber zu erfahren .
Fedmich
5
Sie können auch die Bildgröße und den Bilddateityp ändern. Beispielsweise können Sie die Standardeinstellung thumbnail_largevon i.vimeocdn.com/video/23566238_640.webp in i.vimeocdn.com/video/23566238_640.png oder i.vimeocdn.com/video/23566238_320.jpg ändern
Michael McGinnis
28
Da die API tot ist, ist diese Antwort nicht mehr gültig
KnF
58

In Javascript (verwendet 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);
}

So zeigen Sie es an:

<img id="vimeo-{{ video.id_video }}" src="" alt="{{ video.title }}" />
<script type="text/javascript">
  vimeoLoadingThumb({{ video.id_video }});
</script>
Natim
quelle
Vielen Dank dafür, sehr hilfreich. Ich denke, es gibt einen sehr kleinen Tippfehler. Sie verwenden # in den Variablen id_img, haben aber das # nicht in der ID des img-Elements. Nimmt Ihr Beispiel auch die Verwendung von jQuery an? Ich habe das $(id_img).beforeund $(id_img).attrfür createElementund ein grundlegenderes ausgetauscht getElementById(id_img).src, hätte es aber ohne Ihr Beispiel überhaupt nicht bekommen.
Atomicules
3
Die # Frage ist, dass die JQuery-Syntax kein Fehler ist. Ja, es wird die Verwendung von JQuery vorausgesetzt.
Natim
Ah, ok dann. Danke für die Klarstellung. Ich benutze JQuery nicht so oft, aber die Antwort war für mich immer noch sehr nützlich.
Atomicules
1
Dies ist die testbare jsfiddle für den gleichen Code: jsfiddle.net/archatas/Tv7GZ
Aidas Bendoraitis
Vielen Dank @AidasBendoraitis
Natim
45

Sie sollten die Antwort der Vimeo-API analysieren. Bei URL-Aufrufen (wie Dailymotion oder Youtube) gibt es keine Möglichkeit dazu.

Hier ist meine PHP-Lösung:

/**
 * 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.
quelle
3
Danke dafür. Dies war meine Lieblingslösung.
Bullyen
44

Verwenden der jQuery-Jsonp-Anforderung:

<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
quelle
1
Ich würde das gerne verwenden ... aber was ist, wenn ich mehrere Videos auf einer Seite habe? Gibt es eine Möglichkeit, die ID an den Anruf weiterzuleiten? Idealerweise würde ich gerne so etwas verwenden <div id='12345678' class='vimeo_thumb'></div>- und das würde mit dem Miniaturbild img gefüllt werden.
Dan
4
Der Methodenaufruf kann wie $.getJSON('http://vimeo.com/api/v2/video/' + video_id + '.json?callback=?', function (data) {...
folgt
22

Mit Ruby können Sie Folgendes tun, wenn Sie beispielsweise Folgendes haben:

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
quelle
2
Hinweis: Möglicherweise müssen Sie require 'open-uri'das Öffnen zulassen, um URIs und Dateien zu analysieren.
Kris
Ich musste url.scan (/vimeo.com \ / (\ d +) \ /? /). Flatten.to_s.delete ("^ 0-9.") Hinzufügen, um die vimeo ID #
Abram
21

Hier ist ein Beispiel, wie Sie dasselbe in ASP.NET mit C # tun können. Fühlen Sie sich frei, ein anderes Fehlerfangbild zu verwenden :)

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

HINWEIS: Ihre API-Anfrage sollte auf Anfrage folgendermaßen aussehen: http://vimeo.com/api/v2/video/32660708.xml

Mtblewis
quelle
Schön, aber der API-Link lautet nur vimeo.com/api/v2/video/video_id.xml und nicht "Video" vor der Video-ID.
Martin
Kürzte diesen Code und änderte den Parameter so, dass anstelle der vollständigen URL eine Vimeo-ID akzeptiert wurde. (kann nicht herausfinden, wie man den Codeblock mehrzeilig macht) 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

Der einfachste JavaScript-Weg, den ich gefunden habe, um das Miniaturbild zu erhalten, ohne nach der Video-ID zu suchen, ist:

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

Hinweis: Wenn jemand die Miniaturansicht des Videos in Bezug auf die Video-ID erhalten möchte, kann er diese durch $iddie Video-ID ersetzen und eine XML-Datei mit den Videodetails abrufen:

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

Beispiel:

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

Quelle

Roy Shoa
quelle
2
Dies ist wirklich die beste Antwort, da Vimeo die v2-API abgelehnt hat. oEmbed erfordert keine Authentifizierung und gibt eine JSON / XML-Antwort mit Miniaturansichten zurück. developer.vimeo.com/apis/oembed
joemaller
1
Roy, wie verwenden wir diesen Ajax-Aufruf, wenn wir nach einem bestimmten Video anhand der ID suchen?
Klewis
@blackhawk Ich nicht, aber ich google es jetzt und habe etwas für Sie gefunden. Ersetzen Sie einfach die video_id durch Ihre $idund Sie erhalten eine XML mit den Videodetails (einschließlich Miniaturansichten). http://vimeo.com/api/v2/video/$id.xml. zum Beispiel : http://vimeo.com/api/v2/video/198340486.xml. Quelle ist hier: coderwall.com/p/fdrdmg/get-a-thumbnail-from-a-vimeo-video
Roy Shoa
@blackhawk Ich bearbeite meine Antwort, du kannst sie jetzt sehen. Vielen Dank!
Roy Shoa
11

Wenn Sie Thumbnail über pure js / jquery no api verwenden möchten, können Sie mit diesem Tool einen Frame aus dem Video und voila aufnehmen! Geben Sie den URL-Daumen in die Quelle ein, die Sie mögen.

Hier ist ein Codestift:

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

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

Hier ist die Seite, um ein Miniaturbild zu erhalten:

http://video.depone.eu/

alphapilgrim
quelle
1
@blackhawk Seite ist wieder da.
Alphapilgrim
Es sieht so aus, als würde dies einen zufälligen Frame erhalten, nicht das offizielle Cover / Thumbnail, das der Videoersteller ausgewählt hat. Gut zu wissen, dass es das gibt, aber ich denke, ich werde die API-JSON-Analysemethode verwenden, da dies keine Kontrolle über das Cover von der Vimeo-Seite der Dinge gibt.
Squarecandy
9

Hier ist mein Beispiel unter Verwendung der Vimeo-URL ( https://player.vimeo.com/video/30572181 )

<!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.
quelle
Du bist der beste.
Alexandr Kazakov
7

Es scheint, als ob api / v2 tot ist.
Um die neue API verwenden zu können, müssen Sie Ihre Anwendung registrieren und base64 das client_idund client_secretals Autorisierungsheader codieren .

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

Aus Sicherheitsgründen können Sie das client_idund client_secretbereits verschlüsselt vom Server zurückgeben.

Diego Ponciano
quelle
1
base64 ist kein Hash. Die Base64-Codierung Ihrer Daten auf dem Server ist nicht "sicherer" als die Codierung auf der Clientseite. Das heißt, es ist wahrscheinlich etwas schneller.
Sumurai8
7

Dies ist eine schnelle und clevere Methode, um eine benutzerdefinierte Größe auszuwählen.

Ich gehe hierher:

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

Laden Sie die Datei herunter, öffnen Sie sie und suchen Sie das 640 Pixel breite Miniaturbild. Es hat ein Format wie das folgende:

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

Sie nehmen den Link, ändern den 640 für beispielsweise 1400 und erhalten am Ende Folgendes:

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

Fügen Sie es in die Suchleiste Ihres Browsers ein und genießen Sie es.

Prost,

Erdnüsse
quelle
Diese Methode funktioniert nicht. Gibt eine PHP-Datei zurück, bei der VIDEO_ID nicht gefunden wurde.
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
quelle
4

Eigentlich hat der Typ, der diese Frage gestellt hat, seine eigene Antwort gepostet.

"Vimeo möchte anscheinend, dass ich eine HTTP-Anfrage stelle und die Miniatur-URL aus dem zurückgegebenen XML extrahiere ..."

Die Vimeo-API-Dokumente finden Sie hier: http://vimeo.com/api/docs/simple-api

Kurz gesagt, Ihre App muss eine GET-Anfrage an eine URL wie die folgende stellen:

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

Analysieren Sie die zurückgegebenen Daten, um die gewünschte Miniatur-URL zu erhalten, und laden Sie dann die Datei unter dieser URL herunter.

Ian Kemp
quelle
4

Ich habe eine Funktion in PHP geschrieben, um mich darauf einzulassen. Ich hoffe, sie ist für jemanden nützlich. Der Pfad zur Miniaturansicht ist in einem Link-Tag auf der Videoseite enthalten. Dies scheint den Trick für mich zu tun.

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

Hoffe es hilft jedem.

Foggson

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

// Bei der folgenden Funktion übergeben Sie die Thumbnail-URL.

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
quelle
4

Zerlegen der Antwort von Karthikeyan P, damit sie in einer größeren Anzahl von Szenarien verwendet werden kann:

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

Verwendung

Holen Sie sich eine Vimeo-ID von einer Vimeo-Video-URL:

var vimeoId = parseVimeoIdFromUrl(vimeoUrl);

Holen Sie sich eine Vimeo-Miniatur-URL von einer Vimeo-ID:

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

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

Chris Moschini
quelle
4

UPDATE: Diese Lösung funktioniert seit Dezember 2018 nicht mehr.

Ich habe nach dem gleichen gesucht und es sieht so aus, als ob die meisten Antworten hier veraltet sind, da die Vimeo API v2 veraltet ist.

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

Mit dem oben genannten erhalten Sie den Link zum Standard-Miniaturbild von Vimeo.

Wenn Sie ein Bild unterschiedlicher Größe verwenden möchten, können Sie Folgendes hinzufügen:

$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
quelle
Bitte helfen Sie mir mit einem offiziellen Ankündigungslink, bei dem erwähnt wird, dass v2 vimeo veraltet ist.
Deepak Yadav
3

Wenn Sie keine automatisierte Lösung benötigen, finden Sie die URL der Miniaturansicht, indem Sie die vimeo-ID hier eingeben : http://video.depone.eu/

Emily Ryan
quelle
Es gibt eine andere Antwort wie diese auf dieser Seite oben.
Alphapilgrim
2

Ich habe einen CodePen erstellt, der die Bilder für Sie abruft.

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

Geben Sie hier die Bildbeschreibung ein

Israel Morales
quelle
1

Wenn Sie nach einer alternativen Lösung suchen und das Vimeo-Konto auf andere Weise verwalten können, fügen Sie einfach jedes Video, das Sie anzeigen möchten, zu einem Album hinzu und fordern dann mithilfe der API die Albumdetails an. Anschließend werden alle Miniaturansichten und Links angezeigt . Es ist nicht ideal, könnte aber helfen.

API-Endpunkt (Spielplatz)

Twitter Convo mit @vimeoapi

Sidonaldson
quelle
Dies ist möglicherweise nicht der effizienteste Weg, insbesondere wenn (1) der Rest Ihres Codes nicht von der Vimeo-API abhängt und (2) Sie das gute Gefühl haben, dass Ihre API-Aufrufe möglicherweise über das hinausgehen, was Vimeo hat als Grenze gesetzt.
Klewis
@ Blackhawk du hast meinen Punkt verpasst. Es ist eine Alternative. Wenn Sie dies tun, haben Sie alle Ihre Videos in einem einzigen API-Aufruf. Sie können diese Serverseite beispielsweise zwischenspeichern.
Sidonaldson
1

Vielleicht möchten Sie einen Blick auf das Juwel von Matt Hooks werfen. https://github.com/matthooks/vimeo

Es bietet einen einfachen Vimeo-Wrapper für die API.

Sie müssten lediglich die video_id speichern (und den Anbieter, wenn Sie auch andere Videoseiten erstellen).

Sie können die Vimeo-Video-ID wie folgt extrahieren

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

und wenn Sie Ihre Röhre brauchen, finden Sie diese vielleicht nützlich

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
quelle
0

Für diejenigen, die immer noch eine Möglichkeit suchen, das Miniaturbild nur über eine URL abzurufen, wurde genau wie bei Youtube eine kleine Anwendung erstellt, die es nur mit der Vimeo-ID abruft.

https://vumbnail.com/358629078.jpg

Stecken Sie einfach Ihre Video-ID ein und sie wird abgerufen und 24 Stunden lang zwischengespeichert, damit sie schnell funktioniert.

Wenn Sie Ihre eigenen drehen möchten, können Sie dies hier tun .

Repo

Sam Carlton
quelle
-3

Für jemanden wie mich, der versucht, dies kürzlich herauszufinden,

https://i.vimeocdn.com/video/[video_id]_[dimension].webp funktioniert bei mir.

(wobei dimension= 200 × 150 | 640)

Novasaint
quelle
1
Schöner Fund. Das ist wirklich sauber.
Ben Harrison
Großartig, außer dass Safari unter iOS das Webp nicht anzeigt
Gregory Magarshak
9
Das scheint falsch zu sein - ich bekomme ein Bild, das nichts mit dem eigentlichen Video zu tun hat. Die in der Daumen-URL verwendete ID unterscheidet sich von der Video-ID. Wenn Sie die API aufrufen, erhalten Sie diese URL mit unterschiedlichen IDs. Es gibt keine Abkürzung zum Aufrufen der API.
Morten Holmgaard
12
Das funktioniert nicht, die video_id und image_id sind nicht gleich. So erhalten Sie ein Bild, das nicht zu dem von Ihnen angeforderten Video gehört
Nicolas Azrak
Die Video-ID und
ID