YouTube RSS feed URL for any channel or playlist

Feed URL formats

The base URL https://www.youtube.com/feeds/videos.xml takes one query parameter: channel_id, playlist_id or the older user. Channel IDs start with UC. A channel's uploads are also available as playlists: replace the UC at the start of the channel ID with UU for all uploads, UULF for uploads without Shorts, or UUSH for Shorts only. The table below uses the Google for Developers channel, UC_x5XG1OV2P6uZZ5FSM9Ttw.

The feed does not accept an @handle: ?handle= returns HTTP 400. Use the channel ID instead; the next section shows where to find it.

Find the channel ID

1. Open the channel page

   Open the channel on YouTube, for example https://www.youtube.com/@GoogleDevelopers.

2. Open the About panel

   Click the "...more" link after the channel description to open the About panel.

3. Copy the channel ID

   Scroll to "Share channel" and choose "Copy channel ID". The ID starts with UC; paste it after channel_id= in the feed URL.

Another way to find the ID is to view the channel page's source and search for channel_id=. The page contains a <link rel="alternate" type="application/rss+xml"> tag with the full feed URL. Your code cannot read the channel page through the free proxy: in our test the page HTML was about 1.6 MB, above the 1 MiB response cap, and the proxy answered 502 with X-Cors-Error: response_too_large. Look the ID up once and keep it in your code or config.

Fetch the feed in JavaScript

A direct fetch() of the feed from a web page fails because YouTube's feed response has no Access-Control-Allow-Origin header. Chrome logs No 'Access-Control-Allow-Origin' header is present on the requested resource and fetch() rejects with TypeError: Failed to fetch. Prefix the feed URL with https://proxy.cors.dev/: the proxy fetches the feed and returns it with Access-Control-Allow-Origin set to your page's origin. The free tier needs no signup and no API key, and accepts GET requests with XML responses up to 1 MiB, while the feed is about 25 KB.

const channelId = 'UC_x5XG1OV2P6uZZ5FSM9Ttw';
const feedUrl = `https://www.youtube.com/feeds/videos.xml?channel_id=${channelId}`;

const response = await fetch(`https://proxy.cors.dev/${feedUrl}`, { credentials: 'omit' });
if (!response.ok) {
  throw new Error(`Feed request failed: ${response.headers.get('X-Cors-Error') ?? response.status}`);
}

const feed = new DOMParser().parseFromString(await response.text(), 'application/xml');
if (feed.querySelector('parsererror')) throw new Error('The feed is not valid XML');

const YT = 'http://www.youtube.com/xml/schemas/2015';
const MEDIA = 'http://search.yahoo.com/mrss/';

const videos = [...feed.getElementsByTagName('entry')].map((entry) => ({
  id: entry.getElementsByTagNameNS(YT, 'videoId')[0].textContent,
  title: entry.getElementsByTagName('title')[0].textContent,
  url: entry.querySelector('link[rel="alternate"]').getAttribute('href'),
  published: new Date(entry.getElementsByTagName('published')[0].textContent),
  thumbnail: entry.getElementsByTagNameNS(MEDIA, 'thumbnail')[0].getAttribute('url'),
  views: Number(entry.getElementsByTagNameNS(MEDIA, 'statistics')[0]?.getAttribute('views') ?? 0),
}));

console.log(videos.length, videos[0]);

The code parses the XML with DOMParser and turns each entry into an object with the video ID, title, watch URL, publish date, thumbnail URL and view count. yt:videoId, media:thumbnail and media:statistics use XML namespaces, so the code reads them with getElementsByTagNameNS(). When a request fails, the proxy puts an error code in the X-Cors-Error response header, and the code adds it to the error message.

// Markup: <ul id="videos"></ul>
const list = document.querySelector('#videos');

list.replaceChildren(
  ...videos.slice(0, 6).map((video) => {
    const item = document.createElement('li');
    const link = document.createElement('a');
    const thumbnail = document.createElement('img');

    link.href = video.url;
    thumbnail.src = video.thumbnail;
    thumbnail.alt = '';
    thumbnail.width = 480;
    thumbnail.height = 360;
    thumbnail.loading = 'lazy';

    link.append(thumbnail, video.title);
    item.append(link);
    return item;
  }),
);

The render code creates elements with DOM methods and adds titles as text, so a video title cannot inject HTML. Each thumbnail is the hqdefault.jpg image at 480 by 360 pixels. The code sets width and height to reserve the space and loads images lazily.

Fields in each entry

Each entry element holds one video. The feed itself also carries the channel name in title and a link to the channel page. The table lists the entry fields most pages need.

Limits

• The feed returns only the 15 most recent entries and has no paging; older videos need the YouTube Data API, which requires an API key.
• YouTube serves the feed with Cache-Control: public, max-age=900, which lets caches reuse a copy for 15 minutes, so polling more often than every 15 minutes gains little.
• The proxy does not cache feeds (Cache-Control: no-store) and applies fair-use rate limits per IP; each visitor's browser sends its own requests, so the limit applies per visitor.
• Shorts appear in the channel feed with links like https://www.youtube.com/shorts/VIDEO_ID; use the UULF playlist to leave them out.

Good questions.