How do I get the YouTube video ID from a URL?

Question

I want to get the v=id from YouTube’s URL with JavaScript (no jQuery, pure JavaScript).

Example YouTube URL formats

http://www.youtube.com/watch?v=u8nQa1cJyX8&a=GxdCwVVULXctT2lYDEPllDR0LRTutYfW

http://www.youtube.com/watch?v=u8nQa1cJyX8

Or any other YouTube format that contains a video ID in the URL.

Result from these formats

u8nQa1cJyX8

possible duplicate of [Extract parameter value from url using regular expressions](http://stackoverflow.com/questions/1280557/extract-parameter-value-from-url-using-regular-expressions) — Mark Byers, Aug 10 '10 at 19:16
That question is only for formats like my second one. But I found an interesting answer there, thanks for sharing it. — Adam Halasz, Aug 10 '10 at 19:19
There are a regular expression for that: [http://pregcopy.com/exp/27](http://pregcopy.com/exp/27) — Exos, Jul 15 '12 at 07:32
Can't take any credit for it, but I found this to be pretty extensive: https://gist.github.com/FinalAngel/1876898. It even catches urls as diverse as https://www.youtube.com/watch?feature=player_embedded&v=1p3vcRhsYGo and http://www.youtube.com/v/1p3vcRhsYGo — Simon, Sep 24 '13 at 20:58
**As of 2015:** skip to **[this answer](http://stackoverflow.com/questions/3452546/javascript-regex-how-to-get-youtube-video-id-from-url/27728417#27728417)**. The other answers are out of date. — Lenar Hoyt, Oct 13 '15 at 21:11
Checkout the javascript module [get-video-id](https://github.com/radiovisual/get-video-id) that will extract the Youtube id from any known Youtube url format (including embed strings). It doesn't use one monolithic regex, but it employs a few regex's to find the different patterns. — radiovisual, Apr 12 '16 at 14:52

score 539 · Answer 1 · edited Mar 14 '20 at 07:00

539

I made an enhancement to Regex provided by "jeffreypriebe" because he needed a kind of YouTube URL is the URL of the videos when they are looking through a channel.

Well no but this is the function that I have armed.

<script type="text/javascript">
function youtube_parser(url){
    var regExp = /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\?))\??v?=?([^#&?]*).*/;
    var match = url.match(regExp);
    return (match&&match[7].length==11)? match[7] : false;
}
</script>

These are the types of URLs supported

http://www.youtube.com/watch?v=0zM3nApSvMg&feature=feedrec_grec_index
http://www.youtube.com/user/IngridMichaelsonVEVO#p/a/u/1/QdK8U-VIH_o
http://www.youtube.com/v/0zM3nApSvMg?fs=1&amp;hl=en_US&amp;rel=0
http://www.youtube.com/watch?v=0zM3nApSvMg#t=0m10s
http://www.youtube.com/embed/0zM3nApSvMg?rel=0
http://www.youtube.com/watch?v=0zM3nApSvMg
http://youtu.be/0zM3nApSvMg

Can be found in [http://web.archive.org/web/20160926134334/] http://lasnv.net/foro/839/Javascript_parsear_URL_de_YouTube

edited Mar 14 '20 at 07:00

Илья Зеленько

7,509
3
44
55

answered Nov 24 '11 at 16:57

Lasnv

5,415
2
13
2

9

The regex contains a little bug \??v?=? this should just be at the watch part, otherwise you would filter a 'v' if the id starts with a 'v'. so this should do the trick /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\??v?=?))([^#\&\?]*).*/ – webstrap Dec 16 '11 at 17:14
88

Even cleaner: `/.*(?:youtu.be\/|v\/|u\/\w\/|embed\/|watch\?v=)([^#\&\?]*).*/` Then use `match[1]` instead of `match[7]` (which seemed a bit arbitrary to me). Also fixes bug pointed out by WebDev. – Chris Nolet Feb 16 '12 at 13:58
/^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\?))\??v?=?([^#\&\?^\s]*).*/ this will limit it until the space " " so this will work some text https://www.youtube.com/watch?v=S09F5MejfBE some other text – Zeev G Dec 09 '14 at 15:14
2

You realise that this regex is not actually even checking the domain; it's so permissive that the string "v/2g5jg1Q2e6k" is enough to match it. – KJ Tsanaktsidis Sep 24 '15 at 00:51
6

How long until YouTube IDs are 12 characters long? – Lenar Hoyt Oct 13 '15 at 21:05
I tweaked this to make all groups non-capturing apart from the ID group `^.*(?:(?:youtu.be\/)|(?:v\/)|(?:\/u\/\w\/)|(?:embed\/)|(?:watch\?))\??v?=?([^#\&\?]*).*$` – Jonathan Crooke Nov 19 '15 at 10:13
I think It doesn't work if the url contains "player_embedded" – Xav987 Dec 16 '15 at 19:02
1

Did you know that it's not really perfect, if you put https://www.anything.com/watch?v=jn40gqhxoSY It think it's a youtube url – Gino Oct 01 '17 at 19:59
Interesting Regex on a PHP question for YouTube IDs: https://stackoverflow.com/questions/6556559/youtube-api-extract-video-id/6556662#6556662 – brasofilo Feb 09 '18 at 03:25
`https://www.youtube.com/watch?feature=feedrec_grec_index&v=0zM3nApSvMg` this is failling. – Abdullah Nurum May 03 '19 at 04:29
4

Anyone can extend this reqex and thus people complaining are not making any sense. – Lecha Bisultanov Dec 07 '19 at 14:38
fails on this one `https://www.youtube.com/watch?time_continue=4&v=0zM3nApSvMg` – webdevbyjoss Jun 29 '20 at 17:21
check this solution with this video - https://www.youtube.com/watch?v=a-XQJHpp5vI – Kamlesh Oct 20 '20 at 13:36
This does not work on this link https://www.youtube.com/watch?t=5&v=_uN2aPIdVYI. Just returns false. – Gagan Bhat Apr 11 '21 at 18:56
Wrong result with `https://www.youtube.com/embed/vE3nc7oU704`, because `embed` started ID with `v`. – mixalbl4 Dec 14 '21 at 14:36
This works the best in terms of grabbing the YT id `(?:youtube(?:-nocookie)?\.com\/(?:[^\/\n\s]+\/\S+\/|(?:v|e(?:mbed)?)\/|\S*?[?&]vi?=)|youtu\.be\/)([a-zA-Z0-9_-]{11})` and then just get the match using `match[1]`. You can also see the regex match here https://regex101.com/r/TAupB0/1 – Alfonse Aug 03 '22 at 16:17
when the query params get shuffled (v comes later), it won't work. Example: https://www.youtube.com/watch?time_continue=19&v=-bVYKXrdTMk – Wim den Herder Dec 06 '22 at 05:32

score 267 · Answer 2 · edited Jun 30 '16 at 20:35

267

I simplified Lasnv's answer a bit.

It also fixes the bug that WebDeb describes.

Here it is:

var regExp = /^.*(youtu\.be\/|v\/|u\/\w\/|embed\/|watch\?v=|\&v=)([^#\&\?]*).*/;
var match = url.match(regExp);
if (match && match[2].length == 11) {
  return match[2];
} else {
  //error
}

Here is a regexer link to play with: http://regexr.com/3dnqv

edited Jun 30 '16 at 20:35

LosManos

7,195
6
56
107

answered Feb 01 '12 at 19:50

mantish

6,598
2
16
9

2

just a heads up: this should only be used when you know that you are dealing with a youtube url. I (wrongfully) used it to verify urls as youtube, which caused false positives, e.g. this passes: 'v/2059-9080-5437' – fabi Dec 05 '13 at 13:41
4

I'm using now a different Regex that also checks for a youtube domain. I'm not sure if I should update the answer as it's a big change: /^.*(youtu.be\/|youtube(-nocookie)?.com\/(v\/|.*u\/\w\/|embed\/|.*v=))([\w-]{11}).*/ – mantish Apr 23 '15 at 14:24
4

When will YouTube switch to 12 characters for the video ID? – Lenar Hoyt Oct 13 '15 at 21:06
shouldn't the dot in "youtu.be" be escaped? – Alex from Jitbit Nov 24 '15 at 20:10
you're right @jitbit Thank you. Although it usually works as well without escaping it. – mantish Nov 25 '15 at 22:22
I just find out that this regex will find a url with "tv" in it, even if it's not Youtube like: http://www.podtrac.com/pts/redirect.mp4/cdn.twit.tv/video/tnt/tnt1634/tnt1634_h264m_864x480_500.mp4 – Gino Nov 08 '16 at 05:22
I changed this part |v\/| to |\?v\/| – Gino Nov 08 '16 at 05:33
I'm not a fan of the overly permissive `[^#\&\?]*` — can't we use a slightly stricter `\w` or `[a-zA-Z0-9_]{11,12}` (to allow for 12-character ids some time in the future). – podperson May 16 '17 at 21:56
@podperson Why would they switch to 12 char IDs? Its several billion years off before they run out of possible 11 char IDs. – NickG Jul 25 '17 at 14:10
This solves the problems with the urls listed below by JW: `/^.*(youtu\.be\/|vi?\/|u\/\w\/|embed\/|\?vi?=|\&vi?=)([^#\&\?]*).*/` – podperson Jul 31 '17 at 23:13
@NickG I don't know what their schema for generating ids is. If it were merely based on unique numbers in base 62 or whatever they wouldn't need 11 character ids, would they? The larger point was that if you're expecting 11 characters of a particular type, put that in the search. – podperson Oct 10 '17 at 23:33
with respect to when (if ever) youtube will go to 12 character VID's. I SUSPECT they may have chosen 11 because 11x5bits = 55 bits is the closest thing to the maximum JS integer size of 53 bits and the high order character will never use - or _. I could be totally wrong on this but if I'm not then they will stay at 11 until they want to jump to 22 or 24 (which could be the 12th of never). JUST AN OBSERVATION. – Kerry Davis Apr 20 '18 at 19:27
What about http://y2u.be/j4dMnAPZu70 links? – Shlomi Oct 30 '22 at 10:05

score 128 · Accepted Answer · answered Aug 10 '10 at 19:21

128

You don't need to use a regular expression for this.

var video_id = window.location.search.split('v=')[1];
var ampersandPosition = video_id.indexOf('&');
if(ampersandPosition != -1) {
  video_id = video_id.substring(0, ampersandPosition);
}

answered Aug 10 '10 at 19:21

Jacob Relkin

161,348
33
346
320

this is a usefull function to make it work where you want based on this code. var video_url = 'https://www.youtube.com/watch?v=eOrNdBpGMv8&feature=youtube_gdata'; ytid(video_url); function ytid(video_url) { var video_id = video_url.split('v=')[1]; var ampersandPosition = video_id.indexOf('&'); if (ampersandPosition != -1) { video_id = video_id.substring(0, ampersandPosition); } alert(video_id); return video_id; } – Gino Nov 23 '12 at 21:01
16

does not handle embedded URLs – serge Mar 18 '16 at 13:14
31

also doesn't handle 'share' generated urls- `https://youtu.be/{{video_id}}` – hamncheez Oct 11 '17 at 20:33
10

This regex works well with youtube share and watch url. `url='https://youtu.be/{{video_id}}'; url.match(/(?:https?:\/{2})?(?:w{3}\.)?youtu(?:be)?\.(?:com|be)(?:\/watch\?v=|\/)([^\s&]+)/); ` – Dipten Dec 31 '19 at 10:57

score 123 · Answer 4 · edited May 18 '22 at 01:50

None of these worked on the kitchen sink as of 1/1/2015, notably URLs without protocal http/s and with youtube-nocookie domain. So here's a modified version that works on all these various Youtube versions:

    // Just the regex. Output is in [1].
    /^.*(?:(?:youtu\.be\/|v\/|vi\/|u\/\w\/|embed\/|shorts\/)|(?:(?:watch)?\?v(?:i)?=|\&v(?:i)?=))([^#\&\?]*).*/

    // For testing.
    var urls = [
        'https://youtube.com/shorts/dQw4w9WgXcQ?feature=share',
        '//www.youtube-nocookie.com/embed/up_lNV-yoK4?rel=0',
        'http://www.youtube.com/user/Scobleizer#p/u/1/1p3vcRhsYGo',
        'http://www.youtube.com/watch?v=cKZDdG9FTKY&feature=channel',
        'http://www.youtube.com/watch?v=yZ-K7nCVnBI&playnext_from=TL&videos=osPknwzXEas&feature=sub',
        'http://www.youtube.com/ytscreeningroom?v=NRHVzbJVx8I',
        'http://www.youtube.com/user/SilkRoadTheatre#p/a/u/2/6dwqZw0j_jY',
        'http://youtu.be/6dwqZw0j_jY',
        'http://www.youtube.com/watch?v=6dwqZw0j_jY&feature=youtu.be',
        'http://youtu.be/afa-5HQHiAs',
        'http://www.youtube.com/user/Scobleizer#p/u/1/1p3vcRhsYGo?rel=0',
        'http://www.youtube.com/watch?v=cKZDdG9FTKY&feature=channel',
        'http://www.youtube.com/watch?v=yZ-K7nCVnBI&playnext_from=TL&videos=osPknwzXEas&feature=sub',
        'http://www.youtube.com/ytscreeningroom?v=NRHVzbJVx8I',
        'http://www.youtube.com/embed/nas1rJpm7wY?rel=0',
        'http://www.youtube.com/watch?v=peFZbP64dsU',
        'http://youtube.com/v/dQw4w9WgXcQ?feature=youtube_gdata_player',
        'http://youtube.com/vi/dQw4w9WgXcQ?feature=youtube_gdata_player',
        'http://youtube.com/?v=dQw4w9WgXcQ&feature=youtube_gdata_player',
        'http://www.youtube.com/watch?v=dQw4w9WgXcQ&feature=youtube_gdata_player',
        'http://youtube.com/?vi=dQw4w9WgXcQ&feature=youtube_gdata_player',
        'http://youtube.com/watch?v=dQw4w9WgXcQ&feature=youtube_gdata_player',
        'http://youtube.com/watch?vi=dQw4w9WgXcQ&feature=youtube_gdata_player',
        'http://youtu.be/dQw4w9WgXcQ?feature=youtube_gdata_player'
    ];
    
    var i, r, rx = /^.*(?:(?:youtu\.be\/|v\/|vi\/|u\/\w\/|embed\/|shorts\/)|(?:(?:watch)?\?v(?:i)?=|\&v(?:i)?=))([^#\&\?]*).*/;
    
    for (i = 0; i < urls.length; ++i) {
        r = urls[i].match(rx);
        console.log(r[1]);
    }

Worth noting that many of the above solutions don't cover this wide batch of valid urls, the test script is very helpful, +1! — blented, May 17 '16 at 00:56
Note that this will be fooled by something like "www.engadget.com/watch?v=dQw4w9WgXcQ", not that it's likely to be a problem though — binaryfunt, Aug 02 '16 at 09:23
It works, but couldnt fixed the issue arising a text with multiple youtube url's See this https://regex101.com/r/qK5qJ5/1. It should not replace the second url. — Ashish, Aug 21 '16 at 19:08
**If you don't want that an empty ID matches**: `^.*(?:(?:youtu\.be\/|v\/|vi\/|u\/\w\/|embed\/)|(?:(?:watch)?\?v(?:i)?=|\&v(?:i)?=))([^#\&\?]+).*` (i.e. https://www.youtube.com/watch?v= will not match) — zurfyx, Oct 26 '17 at 10:03
What do you mean by "None of these worked on the kitchen sink"? — rmutalik, May 13 '20 at 23:50
did not work for me. https://www.youtube.com/watch?v=a-XQJHpp5vI — Kamlesh, Oct 20 '20 at 13:37
@Kamlesh I think OP updated the script, I ran [youtube.com/watch?v=a-XQJHpp5vI](https://youtube.com/watch?v=a-XQJHpp5vI) and it correctly got the id `a-XQJHpp5vI` . — Caleb Taylor, Jul 09 '21 at 07:37
@rmutalik "everything but the kitchen sink" is an expression in English meaning "everything imaginable." In this case the author is making a reference to "all of the possible URLs." — Jason, Nov 29 '21 at 18:03
To use this in python, just remove the first and last / and put it in a normal string in re.match(pattern, url).groups()[0] — 2080, May 28 '23 at 08:09

Vlad · Answer 5 · 2021-02-21T09:28:11.307

The best solution (from 2019-2021) I found is that:

function YouTubeGetID(url){
   url = url.split(/(vi\/|v=|\/v\/|youtu\.be\/|\/embed\/)/);
   return (url[2] !== undefined) ? url[2].split(/[^0-9a-z_\-]/i)[0] : url[0];
}

I found it here.

/*
* Tested URLs:
var url = 'http://youtube.googleapis.com/v/4e_kz79tjb8?version=3';
url = 'https://www.youtube.com/watch?feature=g-vrec&v=Y1xs_xPb46M';
url = 'http://www.youtube.com/watch?feature=player_embedded&v=Ab25nviakcw#';
url = 'http://youtu.be/Ab25nviakcw';
url = 'http://www.youtube.com/watch?v=Ab25nviakcw';
url = '<iframe width="420" height="315" src="http://www.youtube.com/embed/Ab25nviakcw" frameborder="0" allowfullscreen></iframe>';
url = '<object width="420" height="315"><param name="movie" value="http://www.youtube-nocookie.com/v/Ab25nviakcw?version=3&amp;hl=en_US"></param><param name="allowFullScreen" value="true"></param><param name="allowscriptaccess" value="always"></param><embed src="http://www.youtube-nocookie.com/v/Ab25nviakcw?version=3&amp;hl=en_US" type="application/x-shockwave-flash" width="420" height="315" allowscriptaccess="always" allowfullscreen="true"></embed></object>';
url = 'http://i1.ytimg.com/vi/Ab25nviakcw/default.jpg';
url = 'https://www.youtube.com/watch?v=BGL22PTIOAM&feature=g-all-xit';
url = 'BGL22PTIOAM';
*/

TypeScript: const youTubeGetID = (url: string) => { const [a, , b] = url .replace(/(>|<)/gi, '') .split(/(vi\/|v=|\/v\/|youtu\.be\/|\/embed\/)/); if (b !== undefined) { return b.split(/[^0-9a-z_-]/i)[0]; } else { return a; } }; — Vlad, Feb 27 '20 at 10:03

score 32 · Answer 6 · edited May 23 '17 at 11:54

/^.*(youtu.be\/|v\/|e\/|u\/\w+\/|embed\/|v=)([^#\&\?]*).*/

Tested on:

http://www.youtube.com/v/0zM3nApSvMg?fs=1&hl=en_US&rel=0
http://www.youtube.com/embed/0zM3nApSvMg?rel=0
http://www.youtube.com/watch?v=0zM3nApSvMg&feature=feedrec_grec_index
http://www.youtube.com/watch?v=0zM3nApSvMg
http://youtu.be/0zM3nApSvMg
http://www.youtube.com/watch?v=0zM3nApSvMg#t=0m10s
http://www.youtube.com/user/IngridMichaelsonVEVO#p/a/u/1/KdwsulMb8EQ
http://youtu.be/dQw4w9WgXcQ
http://www.youtube.com/embed/dQw4w9WgXcQ
http://www.youtube.com/v/dQw4w9WgXcQ
http://www.youtube.com/e/dQw4w9WgXcQ
http://www.youtube.com/watch?v=dQw4w9WgXcQ
http://www.youtube.com/?v=dQw4w9WgXcQ
http://www.youtube.com/watch?feature=player_embedded&v=dQw4w9WgXcQ
http://www.youtube.com/?feature=player_embedded&v=dQw4w9WgXcQ
http://www.youtube.com/user/IngridMichaelsonVEVO#p/u/11/KdwsulMb8EQ
http://www.youtube-nocookie.com/v/6L3ZvIMwZFM?version=3&hl=en_US&rel=0

Inspired by this other answer.

^.*(?:youtu.be\/|v\/|e\/|u\/\w+\/|embed\/|v=)([^#\&\?]*).* will give you the result in group 1 — Marc, Feb 15 '13 at 16:11

jeffreypriebe · Answer 7 · 2012-01-19T02:49:35.823

28

Given that YouTube has a variety of URL styles, I think Regex is a better solution. Here is my Regex:

^.*(youtu.be\/|v\/|embed\/|watch\?|youtube.com\/user\/[^#]*#([^\/]*?\/)*)\??v?=?([^#\&\?]*).*

Group 3 has your YouTube ID

Sample YouTube URLs (currently, including "legacy embed URL style") - the above Regex works on all of them:

http://www.youtube.com/v/0zM3nApSvMg?fs=1&amp;hl=en_US&amp;rel=0
http://www.youtube.com/embed/0zM3nApSvMg?rel=0
http://www.youtube.com/watch?v=0zM3nApSvMg&feature=feedrec_grec_index
http://www.youtube.com/watch?v=0zM3nApSvMg
http://youtu.be/0zM3nApSvMg
http://www.youtube.com/watch?v=0zM3nApSvMg#t=0m10s
http://www.youtube.com/user/IngridMichaelsonVEVO#p/a/u/1/QdK8U-VIH_o

Hat tip to Lasnv

edited Jan 19 '12 at 02:49

answered Jan 26 '11 at 23:30

jeffreypriebe

2,267
25
30

10

You really need to go back to the drawing board with this one. Yes it matches the above URLs correctly. But it also erroneously matches many other non-youtube-url strings such as: `"domain.com/embed/file.txt"`, `"/tv/"` and `"Has anyone seen my watch?"`. See: [my answer](http://stackoverflow.com/questions/5830387/php-regex-find-all-youtube-video-ids-in-string/5831191#5831191) to a similar question for a much more precise solution. – ridgerunner Apr 29 '11 at 21:26
1

I see your point: the above regex is useless to answer the question of "Is this a YouTube URL?" but that wasn't my goal. I have YouTube URLs - I'm merely extracting an ID. Yes, your answer is solid (and covers a use case that mine doesn't). – jeffreypriebe May 05 '11 at 02:04
you have the same bug i mentioned above with ids beginning with a 'v' – webstrap Dec 16 '11 at 18:13
Thanks @WebDev - do you know if YouTube ever puts a v in the ID (or starts an ID with a "v")? – jeffreypriebe Dec 16 '11 at 19:35
1

Still works as of today (2013-01-25). Here's an example of it in action: http://jsfiddle.net/bcmoney/yBP4J/ – bcmoney Jan 25 '13 at 19:41

tsdorsey · Answer 8 · 2023-07-10T07:36:40.177

tl;dr.

Matches all URL examples on this question and then some.

let re = /(https?:\/\/)?(((m|www)\.)?(youtube(-nocookie)?|youtube.googleapis)\.com.*(v\/|v=|vi=|vi\/|e\/|embed\/|user\/.*\/u\/\d+\/)|youtu\.be\/)([_0-9a-z-]+)/i;
let id = "https://www.youtube.com/watch?v=l-gQLqv9f4o".match(re)[7];

ID will always be in match group 8.

Live examples of all the URLs I grabbed from the answers to this question: https://regexr.com/3u0d4

Full explanation:

As many answers/comments have brought up, there are many formats for youtube video URLs. Even multiple TLDs where they can appear to be "hosted".

You can look at the full list of variations I checked against by following the regexr link above.

Lets break down the RegExp.

(https?:\/\/)? Optional protocols http:// or https:// The ? makes the preceding item optional so the s and then the entire group (anything enclosed in a set of parenthesis) are optional.

Ok, this next part is the meat of it. Basically we have two options, the various versions of [optional-subdomain].youtube.com/...[id] and the link shortened youtu.be/[id] version.

(                                                  // Start a group which will match everything after the protocol and up to just before the video id.
  ((m|www)\.)?                                     // Optional subdomain, this supports looking for 'm' or 'www'.
  (youtube(-nocookie)?|youtube.googleapis)         // There are three domains where youtube videos can be accessed. This matches them.
  \.com                                            // The .com at the end of the domain. 
  .*                                               // Match anything 
  (v\/|v=|vi=|vi\/|e\/|embed\/|user\/.*\/u\/\d+\/) // These are all the things that can come right before the video id. The | character means OR so the first one in the "list" matches.
  |                                                // There is one more domain where you can get to youtube, it's the link shortening url which is just followed by the video id. This OR separates all the stuff in this group and the link shortening url.
  youtu\.be\/                                      // The link shortening domain
)                                                  // End of group

Finally we have the group to select the video ID. At least one character that is a number, letter, underscore, or dash.

([_0-9a-z-]+)

You can find out much more detail about each part of the regex by heading over the regexr link and seeing how each part of the expression matches with the text in the url.

Change `/^` to `/^.*` at the beginning to allow this solution to work even in the case of leading white spaces or other garbage. — Llama D'Attore, Oct 26 '21 at 09:52
Good idea. I just updated the regex to remove the ^ entirely, it's not needed. I've also updated the regexr example as well. Thanks @AlexanderD'Attore — tsdorsey, Oct 27 '21 at 17:38
This is a phenomenal answer. I also appreciate the detail and the huge list of URLs you're testing against. Very useful for a 2021 / 2022 answer :) — onassar, Jan 18 '22 at 00:35
Some improvements would be to allow `m\.youtube\.com` (for mobile), and possibly `youtube\...` (for local top level domains). Also, the now removed `^` at the beginning might be useful for those who want stricter URL-checking. But anyway, this answer is pretty good, thanks! — Magnus, Jul 08 '22 at 17:56
Thanks for the feedback @Magnus. I have updated the regular expression to allow for the 'm' subdomain. It's more complete but technically not required as the subdomain was optional. As to the removed ^ I left that up to the person using it as that kind of requirement is task dependent and not in the scope of this answer. — tsdorsey, Jul 10 '22 at 07:39

score 21 · Answer 9 · answered Nov 14 '11 at 01:29

I created a function that tests a users input for Youtube, Soundcloud or Vimeo embed ID's, to be able to create a more continous design with embedded media. This function detects and returns an object withtwo properties: "type" and "id". Type can be either "youtube", "vimeo" or "soundcloud" and the "id" property is the unique media id.

On the site I use a textarea dump, where the user can paste in any type of link or embed code, including the iFrame-embedding of both vimeo and youtube.

function testUrlForMedia(pastedData) {
var success = false;
var media   = {};
if (pastedData.match('http://(www.)?youtube|youtu\.be')) {
    if (pastedData.match('embed')) { youtube_id = pastedData.split(/embed\//)[1].split('"')[0]; }
    else { youtube_id = pastedData.split(/v\/|v=|youtu\.be\//)[1].split(/[?&]/)[0]; }
    media.type  = "youtube";
    media.id    = youtube_id;
    success = true;
}
else if (pastedData.match('http://(player.)?vimeo\.com')) {
    vimeo_id = pastedData.split(/video\/|http:\/\/vimeo\.com\//)[1].split(/[?&]/)[0];
    media.type  = "vimeo";
    media.id    = vimeo_id;
    success = true;
}
else if (pastedData.match('http://player\.soundcloud\.com')) {
    soundcloud_url = unescape(pastedData.split(/value="/)[1].split(/["]/)[0]);
    soundcloud_id = soundcloud_url.split(/tracks\//)[1].split(/[&"]/)[0];
    media.type  = "soundcloud";
    media.id    = soundcloud_id;
    success = true;
}
if (success) { return media; }
else { alert("No valid media id detected"); }
return false;
}

Nice idea, but it doesn't work on the vast majority of URL formats. Including not matching on any https sites. — NickG, Jul 25 '17 at 14:44

podperson · Answer 10 · 2019-03-05T21:41:45.363

Late to the game here, but I've mashed up two excellent responses from mantish and j-w. First, the modified regex:

const youtube_regex = /^.*(youtu\.be\/|vi?\/|u\/\w\/|embed\/|\?vi?=|\&vi?=)([^#\&\?]*).*/

Here's the test code (I've added mantish's original test cases to j-w's nastier ones):

 var urls = [
      'http://www.youtube.com/watch?v=0zM3nApSvMg&feature=feedrec_grec_index',
      'http://www.youtube.com/user/IngridMichaelsonVEVO#p/a/u/1/QdK8U-VIH_o',
      'http://www.youtube.com/v/0zM3nApSvMg?fs=1&amp;hl=en_US&amp;rel=0',
      'http://www.youtube.com/watch?v=0zM3nApSvMg#t=0m10s',
      'http://www.youtube.com/embed/0zM3nApSvMg?rel=0',
      'http://www.youtube.com/watch?v=0zM3nApSvMg',
      'http://youtu.be/0zM3nApSvMg',
      '//www.youtube-nocookie.com/embed/up_lNV-yoK4?rel=0',
      'http://www.youtube.com/user/Scobleizer#p/u/1/1p3vcRhsYGo',
      'http://www.youtube.com/watch?v=cKZDdG9FTKY&feature=channel',
      'http://www.youtube.com/watch?v=yZ-K7nCVnBI&playnext_from=TL&videos=osPknwzXEas&feature=sub',
      'http://www.youtube.com/ytscreeningroom?v=NRHVzbJVx8I',
      'http://www.youtube.com/user/SilkRoadTheatre#p/a/u/2/6dwqZw0j_jY',
      'http://youtu.be/6dwqZw0j_jY',
      'http://www.youtube.com/watch?v=6dwqZw0j_jY&feature=youtu.be',
      'http://youtu.be/afa-5HQHiAs',
      'http://www.youtube.com/user/Scobleizer#p/u/1/1p3vcRhsYGo?rel=0',
      'http://www.youtube.com/watch?v=cKZDdG9FTKY&feature=channel',
      'http://www.youtube.com/watch?v=yZ-K7nCVnBI&playnext_from=TL&videos=osPknwzXEas&feature=sub',
      'http://www.youtube.com/ytscreeningroom?v=NRHVzbJVx8I',
      'http://www.youtube.com/embed/nas1rJpm7wY?rel=0',
      'http://www.youtube.com/watch?v=peFZbP64dsU',
      'http://youtube.com/v/dQw4w9WgXcQ?feature=youtube_gdata_player',
      'http://youtube.com/vi/dQw4w9WgXcQ?feature=youtube_gdata_player',
      'http://youtube.com/?v=dQw4w9WgXcQ&feature=youtube_gdata_player',
      'http://www.youtube.com/watch?v=dQw4w9WgXcQ&feature=youtube_gdata_player',
      'http://youtube.com/?vi=dQw4w9WgXcQ&feature=youtube_gdata_player',
      'http://youtube.com/watch?v=dQw4w9WgXcQ&feature=youtube_gdata_player',
      'http://youtube.com/watch?vi=dQw4w9WgXcQ&feature=youtube_gdata_player',
      'http://youtu.be/dQw4w9WgXcQ?feature=youtube_gdata_player'
  ];

  var failures = 0;
  urls.forEach(url => {
    const parsed = url.match(youtube_regex);
    if (parsed && parsed[2]) {
      console.log(parsed[2]);
    } else {
      failures++;
      console.error(url, parsed);
    }
  });
  if (failures) {
    console.error(failures, 'failed');
  }

Experimental version to handle the m.youtube urls mentioned in comments:

const youtube_regex = /^.*((m\.)?youtu\.be\/|vi?\/|u\/\w\/|embed\/|\?vi?=|\&vi?=)([^#\&\?]*).*/

It requires parsed[2] to be changed to parsed[3] in two places in the tests (which it then passes with m.youtube urls added to the tests). Let me know if you see problems.

You should add this one in your testing suit since it was problematic and your regexp resolved it for me : https://youtu.be/ve4f400859I . The letter v was stripped out in my previous regexp — Mark Odey, Jul 30 '18 at 16:08
I get false postive for `http://youtu.be/` if I add the `/` it marks it as valid. Using it in `(value) => /^.*(youtu\.be\/|vi?\/|u\/\w\/|embed\/|\?vi?=|\&vi?=)([^#\&\?]*).*/.test(value)` — Anima-t3d, Sep 05 '18 at 05:35
Thanks for the comments. I haven't updated my example yet (don't have time to test) so anyone using my code please take note :-) — podperson, Sep 11 '18 at 14:38
@MehulThakkar are they otherwise similar to youtube.com urls? — podperson, Mar 01 '19 at 17:36
@podperson: Yes, when you open any youtube url in any mobile browser, it will get converted to this type. — Mehul Thakkar, Mar 03 '19 at 15:50
@MehulThakkar I added a modified version of the regexp at the bottom of the post. I ran the tests after adding some sample urls, and it seems to work, but it hasn't exactly been through QA (unlike the original!) — podperson, Mar 05 '19 at 21:43

Dipo · Answer 11 · 2021-08-26T15:20:31.083

12

This regex matches embed, share and link URLs.

const youTubeIdFromLink = (url) => url.match(/(?:https?:\/\/)?(?:www\.|m\.)?youtu(?:be)?\.(?:com|be)(?:\/watch\/?\?v=|\/embed\/|\/)([^\s&\?\/\#]+)/)[1];


console.log(youTubeIdFromLink('https://youtu.be/You-Tube_ID?rel=0&hl=en')); //You-Tube_ID

console.log(youTubeIdFromLink('https://www.youtube.com/embed/You-Tube_ID?rel=0&hl=en')); //You-Tube_ID

console.log(youTubeIdFromLink('https://m.youtube.com/watch?v=You-Tube_ID&rel=0&hl=en')); //You-Tube_ID

edited Aug 26 '21 at 15:20

answered Feb 28 '21 at 03:41

Dipo

507
7
10

Thank you. I changed it a bit at the end: https://regex101.com/r/bTrei2/1 – MrMartiniMo Aug 25 '21 at 12:02
@MrMartiniMo Thanks for the heads up but the regex in your link still doesn’t match YouTube IDs that contain hyphen (-). Example: https://www.youtube.com/watch?v=06w3-l1AzFk. I have updated my answer to match YouTube ID containing any character except the url delimiters. – Dipo Aug 26 '21 at 14:48

score 10 · Answer 12 · edited Feb 10 '22 at 08:32

I have got a Regex which supports commonly used url's which also includes YouTube Shorts

Regex Pattern:

(youtu.*be.*)\/(watch\?v=|embed\/|v|shorts|)(.*?((?=[&#?])|$))

Javascript Return Method:

function getId(url) {
  let regex = /(youtu.*be.*)\/(watch\?v=|embed\/|v|shorts|)(.*?((?=[&#?])|$))/gm;
  return regex.exec(url)[3];
}

Types of URL's supported:

http://www.youtube.com/watch?v=0zM3nApSvMg&feature=feedrec_grec_index
http://www.youtube.com/user/IngridMichaelsonVEVO#p/a/u/1/QdK8U-VIH_o
http://www.youtube.com/v/0zM3nApSvMg?fs=1&amp;hl=en_US&amp;rel=0
http://www.youtube.com/watch?v=0zM3nApSvMg#t=0m10s
http://www.youtube.com/embed/0zM3nApSvMg?rel=0
http://www.youtube.com/watch?v=0zM3nApSvMg
http://youtu.be/0zM3nApSvMg
https://youtube.com/shorts/0dPkkQeRwTI?feature=share
https://youtube.com/shorts/0dPkkQeRwTI

With Test:

https://regex101.com/r/5JhmpW/1

Most simple, yet effective solution from this thread – marson Apr 16 '22 at 21:55 — marson, Apr 16 '22 at 21:55
Not working when it has forward slash at the end – Mwthreex Dec 20 '22 at 13:14 — Mwthreex, Dec 20 '22 at 13:14

score 7 · Answer 13 · answered Aug 26 '11 at 22:08

7

Since YouTube video ids is set to be 11 characters, we can simply just substring after we split the url with v=. Then we are not dependent on the ampersand at the end.

var sampleUrl = "http://www.youtube.com/watch?v=JcjoGn6FLwI&asdasd";

var video_id = sampleUrl.split("v=")[1].substring(0, 11)

Nice and simple :)

answered Aug 26 '11 at 22:08

Mark

473
6
7

This one is literally a duplicate of the accepted answer – brasofilo Feb 09 '18 at 03:27

score 6 · Answer 14 · answered Sep 09 '11 at 13:09

6

I have summed up all the suggestions and here is the universal and short answer to this question:

if(url.match('http://(www.)?youtube|youtu\.be')){
    youtube_id=url.split(/v\/|v=|youtu\.be\//)[1].split(/[?&]/)[0];
}

answered Sep 09 '11 at 13:09

romaninsh

10,606
4
50
70

surya · Answer 15 · 2012-06-27T17:26:56.820

Java Code: (Works for all the URLs:

)

    String url = "http://www.youtube.com/watch?v=0zM3nApSvMg&feature=feedrec_grec_index";

    String regExp = "/.*(?:youtu.be\\/|v\\/|u/\\w/|embed\\/|watch\\?.*&?v=)";
    Pattern compiledPattern = Pattern.compile(regExp);
    Matcher matcher = compiledPattern.matcher(url);
    if(matcher.find()){
        int start = matcher.end();
        System.out.println("ID : " + url.substring(start, start+11));

    }

For DailyMotion:

String url = "http://www.dailymotion.com/video/x4xvnz_the-funny-crash-compilation_fun";

    String regExp = "/video/([^_]+)/?";
    Pattern compiledPattern = Pattern.compile(regExp);
    Matcher matcher = compiledPattern.matcher(url);
    if(matcher.find()){
        String match = matcher.group();
        System.out.println("ID : " + match.substring(match.lastIndexOf("/")+1));

    }

Remove the double quotes from around the Regex pattern in the JavaScript code and it should work. — HopAlongPolly, May 27 '16 at 19:27

score 4 · Answer 16 · edited Apr 03 '16 at 19:14

Slightly stricter version:

^https?://(?:www\.)?youtu(?:\.be|be\.com)/(?:\S+/)?(?:[^\s/]*(?:\?|&)vi?=)?([^#?&]+)

Tested on:

http://www.youtube.com/user/dreamtheater#p/u/1/oTJRivZTMLs
https://youtu.be/oTJRivZTMLs?list=PLToa5JuFMsXTNkrLJbRlB--76IAOjRM9b
http://www.youtube.com/watch?v=oTJRivZTMLs&feature=youtu.be
https://youtu.be/oTJRivZTMLs
http://youtu.be/oTJRivZTMLs&feature=channel
http://www.youtube.com/ytscreeningroom?v=oTJRivZTMLs
http://www.youtube.com/embed/oTJRivZTMLs?rel=0
http://youtube.com/v/oTJRivZTMLs&feature=channel
http://youtube.com/v/oTJRivZTMLs&feature=channel
http://youtube.com/vi/oTJRivZTMLs&feature=channel
http://youtube.com/?v=oTJRivZTMLs&feature=channel
http://youtube.com/?feature=channel&v=oTJRivZTMLs
http://youtube.com/?vi=oTJRivZTMLs&feature=channel
http://youtube.com/watch?v=oTJRivZTMLs&feature=channel
http://youtube.com/watch?vi=oTJRivZTMLs&feature=channel

score 4 · Answer 17 · edited Aug 17 '18 at 03:25

4

You can use the following code to get the YouTube video ID from a URL:

url = "https://www.youtube.com/watch?v=qeMFqkcPYcg"
VID_REGEX = /(?:youtube(?:-nocookie)?\.com\/(?:[^\/\n\s]+\/\S+\/|(?:v|e(?:mbed)?)\/|\S*?[?&]v=)|youtu\.be\/)([a-zA-Z0-9_-]{11})/
alert(url.match(VID_REGEX)[1]);

edited Aug 17 '18 at 03:25

Grant Miller

27,532
16
147
165

answered Aug 14 '18 at 04:21

K. Ayoub

406
1
5
15

I had issues with all other regex examples but this one effectively works on the 3 share options people on desktops use. an url from the address bar, an url from the share button and an url from the inline share button. Thanks!!! – Maarten Apr 09 '20 at 11:33

score 4 · Answer 18 · edited Feb 26 '20 at 14:02

4

This can get video id from any type of youtube links

var url= 'http://youtu.be/0zM3nApSvMg';
var urlsplit= url.split(/^.*(youtu.be\/|v\/|embed\/|watch\?|youtube.com\/user\/[^#]*#([^\/]*?\/)*)\??v?=?([^#\&\?]*).*/);
console.log(urlsplit[3]);

edited Feb 26 '20 at 14:02

Stefan

627
6
19

answered Jan 06 '20 at 05:59

Praveen Kumar

41
3

score 2 · Answer 19 · edited Mar 11 '17 at 02:43

2

This definitely requires regex:

Copy into Ruby IRB:

var url = "http://www.youtube.com/watch?v=NLqASIXrVbY"
var VID_REGEX = /(?:youtube(?:-nocookie)?\.com\/(?:[^\/\n\s]+\/\S+\/|(?:v|e(?:mbed)?)\/|\S*?[?&]v=)|youtu\.be\/)([a-zA-Z0-9_-]{11})/
url.match(VID_REGEX)[1]

See for all test cases: https://gist.github.com/blairanderson/b264a15a8faaac9c6318

edited Mar 11 '17 at 02:43

Peter Mortensen

30,738
21
105
131

answered Apr 21 '15 at 18:16

Blair Anderson

19,463
8
77
114

score 2 · Answer 20 · edited Mar 11 '17 at 02:44

2

One more:

var id = url.match(/(^|=|\/)([0-9A-Za-z_-]{11})(\/|&|$|\?|#)/)[2]

It works with any URL showed in this thread.

It won't work when YouTube addS some other parameter with 11 base64 characters. Till then it is the easy way.

edited Mar 11 '17 at 02:44

Peter Mortensen

30,738
21
105
131

answered Aug 27 '15 at 15:48

pykiss

949
12
15

score 2 · Answer 21 · answered Jun 04 '18 at 17:49

I made a small function to extract the video id out of a Youtube url which can be seen below.

var videoId = function(url) {
   var match = url.match(/v=([0-9a-z_-]{1,20})/i);
   return (match ? match['1'] : false);
};

console.log(videoId('https://www.youtube.com/watch?v=dQw4w9WgXcQ'));
console.log(videoId('https://www.youtube.com/watch?t=17s&v=dQw4w9WgXcQ'));
console.log(videoId('https://www.youtube.com/watch?v=dQw4w9WgXcQ&t=17s'));

This function will extract the video id even if there are multiple parameters in the url.

score 2 · Answer 22 · answered Jun 25 '20 at 21:46

If someone needs the perfect function in Kotlin to save their time. Just hoping this helps

fun extractYTId(ytUrl: String?): String? {
    var vId: String? = null
    val pattern = Pattern.compile(
        "^https?://.*(?:youtu.be/|v/|u/\\w/|embed/|watch?v=)([^#&?]*).*$",
        Pattern.CASE_INSENSITIVE
    )
    val matcher = pattern.matcher(ytUrl)
    if (matcher.matches()) {
        vId = matcher.group(1)
    }
    return vId
}

Tom Chapin · Answer 23 · 2020-09-09T18:33:19.040

Here's a ruby version of this:

def youtube_id(url)
   # Handles various YouTube URLs (youtube.com, youtube-nocookie.com, youtu.be), as well as embed links and urls with various parameters
   regex = /(?:youtube(?:-nocookie)?\.com\/(?:[^\/\n\s]+\/\S+\/|(?:v|vi|e(?:mbed)?)\/|\S*?[?&]v=|\S*?[?&]vi=)|youtu\.be\/)([a-zA-Z0-9_-]{11})/
   match = regex.match(url)
   if match && !match[1].nil?
      match[1]
   else
      nil
   end
end

To test the method:

example_urls = [
   'www.youtube-nocookie.com/embed/dQw4-9W_XcQ?rel=0',
   'http://www.youtube.com/user/Scobleizer#p/u/1/dQw4-9W_XcQ',
   'http://www.youtube.com/watch?v=dQw4-9W_XcQ&feature=channel',
   'http://www.youtube.com/watch?v=dQw4-9W_XcQ&playnext_from=TL&videos=osPknwzXEas&feature=sub',
   'http://www.youtube.com/ytscreeningroom?v=dQw4-9W_XcQ',
   'http://www.youtube.com/user/SilkRoadTheatre#p/a/u/2/dQw4-9W_XcQ',
   'http://youtu.be/dQw4-9W_XcQ',
   'http://www.youtube.com/watch?v=dQw4-9W_XcQ&feature=youtu.be',
   'http://youtu.be/dQw4-9W_XcQ',
   'http://www.youtube.com/user/Scobleizer#p/u/1/dQw4-9W_XcQ?rel=0',
   'http://www.youtube.com/watch?v=dQw4-9W_XcQ&playnext_from=TL&videos=dQw4-9W_XcQ&feature=sub',
   'http://www.youtube.com/ytscreeningroom?v=dQw4-9W_XcQ',
   'http://www.youtube.com/embed/dQw4-9W_XcQ?rel=0',
   'http://www.youtube.com/watch?v=dQw4-9W_XcQ',
   'http://youtube.com/v/dQw4-9W_XcQ?feature=youtube_gdata_player',
   'http://youtube.com/vi/dQw4-9W_XcQ?feature=youtube_gdata_player',
   'http://youtube.com/?v=dQw4-9W_XcQ&feature=youtube_gdata_player',
   'http://www.youtube.com/watch?v=dQw4-9W_XcQ&feature=youtube_gdata_player',
   'http://youtube.com/?vi=dQw4-9W_XcQ&feature=youtube_gdata_player',
   'http://youtube.com/watch?v=dQw4-9W_XcQ&feature=youtube_gdata_player',
   'http://youtube.com/watch?vi=dQw4-9W_XcQ&feature=youtube_gdata_player',
   'http://youtu.be/dQw4-9W_XcQ?feature=youtube_gdata_player'
]

# Test each one
example_urls.each do |url|
   raise 'Test failed!' unless youtube_id(url) == 'dQw4-9W_XcQ'
end

To see this code and run the tests in an online repl you can also go here: https://repl.it/@TomChapin/youtubeid

Roosevelt Honaker · Answer 24 · 2022-09-28T13:03:41.600

2

This short piece works for every youtube link I've tried.

url.match(/([a-z0-9_-]{11})/gim)[0]

https://regexr.com/3nsop

edited Sep 28 '22 at 13:03

answered Sep 07 '22 at 01:55

Roosevelt Honaker

31
4

What about `/(?:[=\/])([a-z0-9_-]{10,12})[&?#\/\n]/gmi`? https://regexr.com/7hatn – Rodrigo Polo Jul 20 '23 at 01:41

score 2 · Answer 25 · answered Mar 23 '12 at 08:58

2

A slightly changed version from the one mantish posted:

var regExp = /^.*(youtu.be\/|v\/|u\/\w\/|embed\/|watch\?v=|\&v=)([^#\&\?]{11,11}).*/;
var match = url.match(regExp);
if (match) if (match.length >= 2) return match[2];
// error

This assumes the code is always 11 characters. I'm using this in ActionScript, not sure if {11,11} is supported in Javascript. Also added support for &v=.... (just in case)

answered Mar 23 '12 at 08:58

Josha

579
3
7

this was the only one that worked for a url i was testing with: http://www.youtube.com/watch?feature=player_embedded&v=0zM3nApSvMg – Dominic Jan 14 '13 at 10:58
perfect. thanks @Josha 69 link combination i test all is worked for me. – gokhan May 08 '14 at 16:51

score 1 · Answer 26 · answered May 29 '13 at 21:35

I liked Surya's answer.. Just a case where it won't work...

String regExp = "/.*(?:youtu.be\\/|v\\/|u/\\w/|embed\\/|watch\\?.*&?v=)";

doesn't work for

youtu.be/i4fjHzCXg6c  and  www.youtu.be/i4fjHzCXg6c

updated version:

String regExp = "/?.*(?:youtu.be\\/|v\\/|u/\\w/|embed\\/|watch\\?.*&?v=)";

works for all.

score 1 · Answer 27 · answered Aug 03 '13 at 03:30

1

Try this one -

function getYouTubeIdFromURL($url) 
{
  $pattern = '/(?:youtube.com/(?:[^/]+/.+/|(?:v|e(?:mbed)?)/|.*[?&]v=)|youtu.be/)([^"&?/ ]{11})/i';
  preg_match($pattern, $url, $matches);

  return isset($matches[1]) ? $matches[1] : false;
}

answered Aug 03 '13 at 03:30

Rohit Suthar

3,528
1
42
48

score 1 · Answer 28 · answered Nov 05 '14 at 13:53

Chris Nolet cleaner example of Lasnv answer is very good, but I recently found out that if you trying to find your youtube link in text and put some random text after the youtube url, regexp matches way more than needed. Improved Chris Nolet answer:

/^.*(?:youtu.be\/|v\/|u\/\w\/|embed\/|watch\?v=)([^#\&\?]{11,11}).*/

score 1 · Answer 29 · answered Jun 29 '16 at 10:06

function parser(url){
    var regExp = /^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\/)|(\?v=|\&v=))([^#\&\?]*).*/;
    var match = url.match(regExp);
    if (match && match[8].length==11){
            alert('OK');
    }else{
            alert('BAD');
    }
}

For testing:

https://www.youtube.com/embed/vDoO_bNw7fc - attention first symbol «v» in «vDoO_bNw7fc»

http://www.youtube.com/user/dreamtheater#p/u/1/oTJRivZTMLs
https://youtu.be/oTJRivZTMLs?list=PLToa5JuFMsXTNkrLJbRlB--76IAOjRM9b
http://www.youtube.com/watch?v=oTJRivZTMLs&feature=youtu.be
https://youtu.be/oTJRivZTMLs
http://youtu.be/oTJRivZTMLs&feature=channel
http://www.youtube.com/ytscreeningroom?v=oTJRivZTMLs
http://www.youtube.com/embed/oTJRivZTMLs?rel=0
http://youtube.com/v/oTJRivZTMLs&feature=channel
http://youtube.com/v/oTJRivZTMLs&feature=channel
http://youtube.com/vi/oTJRivZTMLs&feature=channel
http://youtube.com/?v=oTJRivZTMLs&feature=channel
http://youtube.com/?feature=channel&v=oTJRivZTMLs
http://youtube.com/?vi=oTJRivZTMLs&feature=channel
http://youtube.com/watch?v=oTJRivZTMLs&feature=channel
http://youtube.com/watch?vi=oTJRivZTMLs&feature=channel

score 1 · Answer 30 · answered Feb 24 '21 at 22:01

i wrote a function for that below:

function getYoutubeUrlId (url) {
    const urlObject = new URL(url);
    let urlOrigin = urlObject.origin;
    let urlPath = urlObject.pathname;

    if (urlOrigin.search('youtu.be') > -1) {
        return urlPath.substr(1);
    }

    if (urlPath.search('embed') > -1) {
        // Örneğin "/embed/wCCSEol8oSc" ise "wCCSEol8oSc" return eder.
        return urlPath.substr(7);
    }

   
    return urlObject.searchParams.get('v');
},

https://gist.github.com/semihkeskindev/8a4339c27203c5fabaf2824308c7868f

score 1 · Answer 31 · answered Dec 27 '21 at 16:30

Python3 version:

import re

def get_youtube_id(url):
   match = re.match('^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\?))?\?v?=?(?P<id>\w*).*', url);
   return match.group('id')

If you are looking to include it in a shell/bash/zsh/fish script, here's how to do it:

echo -n "$YOUTUBE_URL" | python -c "import re; import sys; m = re.match('^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\?))?\?v?=?(?P<id>\w*).*', sys.stdin.read()); sys.stdout.write(m.group('id'))"

Example:

echo -n "https://www.youtube.com/watch/?v=APYVWYHS654" | python -c "import re; import sys; m = re.match('^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\?))?\?v?=?(?P<id>\w*).*', sys.stdin.read()); sys.stdout.write(m.group('id'))"

APYVWYHS654

score 0 · Answer 32 · answered Sep 21 '13 at 21:50

We know these characters "?v=" can never appear more than ones but 'v' can appear somehow in the Id Itself so we use "?v=" as delimiter. See it Working Here

//Get YouTube video Id From Its Url

     $('button').bind('click',function(){
var 
url='http://www.youtube.com/watch?v=u8nQa1cJyX8',
videoId = url.split('?v='),//Split data to two
YouTubeVideoId=videoId[1];
alert(YouTubeVideoId);return false;

});

<button>Click ToGet VideoId</button>

score 0 · Answer 33 · answered Jun 04 '14 at 21:40

0

Simple regex if you have the full URL, keep it simple.

results = url.match("v=([a-zA-Z0-9]+)&?")
videoId = results[1] // watch you need.

answered Jun 04 '14 at 21:40

Gubatron

6,222
5
35
37

score 0 · Answer 34 · answered Nov 20 '14 at 07:00

var video_url = document.getElementById('youtubediv').value;
        if(video_url!=""){
        ytid(video_url);
        document.getElementById("youtube").setAttribute("src","http://www.youtube.com/embed/"+ytid(video_url));
        }
        function ytid(video_url){
            var video_id = video_url.split('v=')[1];
            var ampersandPosition = video_id.indexOf('&');
            if(ampersandPosition != -1) {
                video_id = video_id.substring(0, ampersandPosition);
            }
            return video_id;
        }

i hope it can help

score 0 · Answer 35 · answered Mar 12 '15 at 07:00

0

function youtube_parser(url){
    var match = url.match(/^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\?))\??v?=?([^#\&\?]*).*/);
    return (match&&match[7].length==11)?match[7]:false;
}

Shortest and Efficient

answered Mar 12 '15 at 07:00

Wasim A.

9,660
22
90
120

not right, fails vs http://www.youtube.com/e/dQw4w9WgXcQ so please take out the efficient part :) – alecellis1985 Mar 04 '16 at 04:38

score 0 · Answer 36 · edited May 23 '17 at 12:10

0

Well, the way to do it with simple parsing would be: get everything starting after the first = sign to the first & sign.

I think they had a similiar answer here:

Parsing a Vimeo ID using JavaScript?

edited May 23 '17 at 12:10

Community

1
1

answered Aug 10 '10 at 19:22

karlphillip

92,053
36
243
426

2

And what if the URL doesn't contains `&`? – Adam Halasz Aug 10 '10 at 19:24
Then you must find what's the equivalent delimiter. For instance, the first URL you gave us its the & sign. On the second URL, the end of the string is the delimiter. – karlphillip Aug 10 '10 at 19:42

score 0 · Answer 37 · edited May 23 '17 at 10:31

0

As webstrap mentioned in a comment:

It worked if the video start with "v" and it's from youtu.be

The regex contains a little bug \??v?=? this should just be at the watch part, otherwise you would filter a 'v' if the id starts with a 'v'. so this should do the trick

/^.*((youtu.be\/)|(v\/)|(\/u\/\w\/)|(embed\/)|(watch\??v?=?))([^#\&\?]*).*/

edited May 23 '17 at 10:31

Community

1
1

answered Mar 30 '16 at 10:52

Shuher

108
1
6

score 0 · Answer 38 · edited May 23 '17 at 11:54

I made some slight changes to mantish's regex to include all test cases from J W's and matx's answers; since it didn't work on all of them initially. Further changes might be required, but as far as I can tell this at least covers the majority of links:

/(?:[?&]vi?=|\/embed\/|\/\d\d?\/|\/vi?\/|https?:\/\/(?:www\.)?youtu\.be\/)([^&\n?#]+)/

var url = ''; // get it from somewhere

var youtubeRegExp = /(?:[?&]vi?=|\/embed\/|\/\d\d?\/|\/vi?\/|https?:\/\/(?:www\.)?youtu\.be\/)([^&\n?#]+)/;
var match = url.match( youtubeRegExp );

if( match && match[ 1 ].length == 11 ) {
    url = match[ 1 ];
} else {
    // error
}

For further testing:

http://regexr.com/3fp84

score 0 · Answer 39 · answered Jan 18 '18 at 07:00

In C#, it looks like this:

public static string GetYouTubeId(string url) {
    var regex = @"(?:youtube\.com\/(?:[^\/]+\/.+\/|(?:v|e(?:mbed)?|watch)\/|.*[?&amp;]v=)|youtu\.be\/)([^""&amp;?\/ ]{11})";

    var match = Regex.Match(url, regex);

    if (match.Success)
    {
        return match.Groups[1].Value;
    }

    return url;
  }

Feel free to modify.

score 0 · Answer 40 · answered Aug 25 '19 at 10:38

0

Simplifying Jacob Relkin answer, all you need to do is this:

const extractVideoIdFromYoutubeLink = youtubeLink => {
    return youtubeLink.split( 'v=' )[1].split( '&' )[0];
};

answered Aug 25 '19 at 10:38

Hosam Abdelnaser

127
2
11

score 0 · Answer 41 · answered Sep 23 '19 at 12:12

Here's a radically different solution.

You could request the JSON oEmbed document from 'https://www.youtube.com/oembed?format=json&url=' . rawurlencode($url) and then thumbnail_url has a fixed format, match it with a PCRE pattern like https://i.ytimg.com/vi/([^/]+), the first group is the YouTube ID.

Lukas Pierce · Answer 42 · 2019-12-11T15:17:04.550

0

try npm package youtube-id

tested on different urls:

const tested = [
  'https://www.youtube.com/watch?v={YOUTUBE_ID}&nohtml5=False',
  'https://youtu.be/{YOUTUBE_ID}',
  'www.youtube.com/embed/{YOUTUBE_ID}'
  // ....
]

edited Dec 11 '19 at 15:17

answered Dec 11 '19 at 14:59

Lukas Pierce

807
3
9
15

Link only answer is useless, especially when it will be broken. Can you elaborate on this a little more? – Toto Dec 11 '19 at 15:07

score 0 · Answer 43 · answered Dec 19 '20 at 02:52

0

Here's a shortest and the easiest regex for that

url = url+'&'    
regex = "v=(.*?)&|youtu.be\/(.*?)&"

answered Dec 19 '20 at 02:52

shekhar chander

600
8
14

score 0 · Answer 44 · answered Oct 18 '21 at 09:58

Modified Regex from the above answer by Dipo with support of Youtube shorts link

(?:https?:\/\/)?(?:www\.)?youtu(?:be)?\.(?:com|be)(?:\/watch\/?\?v=|\/embed\/|\/shorts\/|\/)(\w+)

tested Links

https://youtu.be/YOUTUBE_ID?123
https://www.youtube.com/embed/YOUTUBE_ID?123
https://www.youtube.com/watch?v=YOUTUBE_ID?asd

https://youtu.be/YOUTUBE_ID&123
https://www.youtube.com/embed/YOUTUBE_ID&123
https://www.youtube.com/watch?v=YOUTUBE_ID&asd

https://youtu.be/YOUTUBE_ID/123
https://www.youtube.com/embed/YOUTUBE_ID/123
https://www.youtube.com/watch?v=YOUTUBE_ID/asd
https://youtube.com/shorts/YOUTUBE_ID?feature=share

Please check your test case from here

https://regex101.com/r/BUSmeK/1

score 0 · Answer 45 · answered Sep 07 '22 at 16:31

/^https?:\/\/(?:(?:youtu\.be\/)|(?:(?:www\.)?youtube\.com\/(?:(?:watch\?(?:[^&]+&)?vi?=)|(?:vi?\/)|(?:shorts\/))))([a-zA-Z0-9_-]{11,})/i

Here is an optimized regex that finds the video id and follows the YouTube oEmbed definition for embed urls exactly. You can see my matches against test URLs here: https://regex101.com/r/q4mWg1/1

It purposefully doesn't match protocol relative URLs (// instead of https://) and youtube-nocookie.com URLs as those aren't in the oEmbed definition and decrease performance.

You can view the oEmbed spec here: https://oembed.com/

The offical providers definitions, including the one for YouTube, are here: https://oembed.com/providers.json

I found this very useful on Wordpress sites where I needed to match against the oEmbed URLs in the post content.

GOXR3PLUS · Answer 46 · 2023-08-20T23:28:46.417

Took me a week , used chatgpt 4 , used claude2 , i used my brain mostly but here you go for any future readers ( thank me later ... ) :

I even included youtube shorts links ....

function getYoutubeVideoId(link) {
    const text = link.trim()
    let urlPattern = /https?:\/\/(?:www\.)?[\w\.-]+(?:\/[\w\.-]*)*(?:\?[\w\.\-]+=[\w\.\-]+(?:&[\w\.\-]+=[\w\.\-]+)*)?\/?/g
    let url = text.match(urlPattern)

    if (url && (url[0].includes('youtube') || url[0].includes('youtu.be'))) {
const youtubeRegExp = /http(?:s?):\/\/(?:m\.|www\.)?(?:m\.)?youtu(?:be\.com\/(?:watch\?v=|embed\/|shorts\/)|\.be\/)([\w\-\_]*)(&(amp;)?[\w\?\=]*)?/;
        const match = text.match(youtubeRegExp)
        const fullLink = url[0]
        let videoId = null
        if (match) {
            videoId = match[1]
        }
        return { fullLink, videoId, hasExtraText: text.replace(fullLink, '').trim().length > 0 }
    } else {
        return { fullLink: null, videoId: null, hasExtraText: true }
    }
}

const testYoutubeLinks = () => {
    const randomTexts = [
        'https://www.youtube.com/shorts/FUVDVAtoRAQ',
        'https://www.youtube.com/watch?v=abcd123456 hello',
        'https://youtu.be/xyz987654 yo',
        'https://www.youtube.com/embed/ouM8z-4Uw4A hi',
        'https://www.youtube.com/watch?v=wxyz123456&t=30s 123',
        'https://www.youtube.com/watch?v=G_IQwt9ceN8&themeRefresh=1 hii',
        'https://www.youtube.com/watch?v=G_IQwt9ceN8&themeRefresh=1 uhhhu',
        'https://m.youtube.com/watch?v=6MFMju-rdUQ 23324',
        'youtube.com whatever',
        'http://www.youtube.com/watch?v=0zM3nApSvMg&feature=feedrec_grec_index',
        'http://www.youtube.com/user/IngridMichaelsonVEVO#p/a/u/1/QdK8U-VIH_o',
        '   http://www.youtube.com/v/0zM3nApSvMg?fs=1&amp;hl=en_US&amp;rel=0',
        'http://www.youtube.com/watch?v=0zM3nApSvMg#t=0m10s',
        '   http://www.youtube.com/embed/0zM3nApSvMg?rel=0',
        'http://www.youtube.com/watch?v=0zM3nApSvMg',
        '   http://youtu.be/0zM3nApSvMg'
    ]

    console.log('New Date:', new Date())
    randomTexts.forEach((text) => console.log(getYoutubeVideoId(text)))
    console.log('----')
}

The above code gives you the fullLink , the videoId and a property called hasExtraText in case you want to know if the given text is not only link and has extra text ...

I am using it in production to detect if user has copy pasted youtubelinks in chat:

score -1 · Answer 47 · answered Apr 15 '21 at 11:28

You can just click the share button and copy the shorten URL. For example: This YouTube video got this URL https://www.youtube.com/watch?v=3R0fzCw3amM but if you click the share button and copy the shorten URL, you will get this https://youtu.be/3R0fzCw3amM

score -2 · Answer 48 · edited Sep 07 '13 at 21:09

-2

videoId = videoUrl.split('v=')[1].substring(0,11);

edited Sep 07 '13 at 21:09

nhahtdh

55,989
15
126
162

answered Sep 07 '13 at 10:16

barak manos

29,648
10
62
114

There's no guarantee on the 11 character length. – Brad Nov 25 '17 at 19:16

score -9 · Answer 49 · edited Jun 20 '20 at 09:12

-9

Here comes the Powerful Python

import pytube

yt = pytube.YouTube("https://www.youtube.com/watch?v=kwM2ApskJy4")

video_id = yt.video_id

print("video id from utl..",video_id)

edited Jun 20 '20 at 09:12

Community

1
1

answered Nov 12 '19 at 20:13

Ram Gupta

19
1

8

No one asked for python – Chud37 Nov 18 '19 at 11:45
This was very useful, thank you The python regex from the pytube source is `r"(?:v=|\/)([0-9A-Za-z_-]{11}).*"` – lovelikelando Feb 14 '21 at 22:59

How do I get the YouTube video ID from a URL?

Example YouTube URL formats

Result from these formats

49 Answers49

tl;dr.

Full explanation:

Here comes the Powerful Python

Linked

Related