How to get a Youtube channel RSS feed after 2015 April 20 (without v3 API)?

How to get a Youtube channel RSS feed after 2015 April 20 (without v3 API)?

  1. Blog
  2. 15 November 2026
  3. 4 min read

Stefan Bogdanescu

Founder & Senior Architect

How to get a Youtube channel RSS feed after 2015 April 20 (without v3 API)

Before April 20, 2015, YouTube publicly exposed an Atom feed at http://gdata.youtube.com/feeds/api/videos/{channel_id}/uploads. It was simple: you grabbed the channel ID, appended it to that URL, and your feed reader picked up new videos automatically. That endpoint vanished with API v2's sunset, but the underlying data source hasn't disappeared; YouTube simply wrapped it behind OAuth 2.0 authentication requirements.

If you need an RSS feed for a feed reader and don't want to spin up a full-blown GCP project or manage API keys, here is how to reconstruct that behavior without touching v3.

The underlying endpoint still exists

YouTube's internal video listing service lives at:

https://www.youtube.com/feeds/videos.xml?channel_id={CHANNEL_ID}

Replace {CHANNEL_ID} with the numeric ID of the channel you're tracking. This endpoint returns a valid Atom feed without requiring an API key, but it does require that the channel owner has not disabled public subscriptions via their privacy settings.

If the target channel uses a custom handle (e.g., @channelname) instead of a numeric ID, you can still resolve it:

  1. Visit the channel's main page in your browser.
  2. Inspect the page source or network tab to find the canonical <yt:channelId> value in the Atom header or JSON-LD metadata.
  3. Substitute that numeric ID into the feed URL above.

This approach works because YouTube treats public subscriptions as a first-class feature outside of the API ecosystem. The feed is meant for exactly this use case: aggregators, readers, and lightweight clients.

Handling authentication and rate limits

While no API key is needed, YouTube enforces rate limiting on unauthenticated requests. Typical behavior includes:

  • A soft limit around 1–2 requests per second.
  • HTTP 429 (Too Many Requests) if you exceed thresholds.
  • Occasional transient errors even below the limit due to backend throttling.

For a feed reader that polls every few minutes, this is rarely an issue. However, if you plan to poll more aggressively (sub-minute intervals), consider adding jitter between requests or caching results to reduce load.

Example in PHP:

function getYoutubeFeed($channelId) {
    $url = "https://www.youtube.com/feeds/videos.xml?channel_id=" . urlencode($channelId);
    
    $ch = curl_init();
    curl_setopt_array($ch, [
        CURLOPT_URL => $url,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_FOLLOWLOCATION => true,
        CURLOPT_TIMEOUT => 10,
    ]);

    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    if ($httpCode === 429) {
        throw new Exception('Rate limit exceeded. Back off.');
    }

    return simplexml_load_string($response);
}

When the feed fails: checking status and alternatives

If the feed returns an error, inspect the HTTP status and body:

  • 403 Forbidden: The channel owner has disabled public subscriptions or restricted access.
  • 404 Not Found: The channel ID is invalid or the channel no longer exists.
  • 5xx Server Errors: Temporary YouTube-side issues; retry with exponential backoff.

YouTube also provides a status endpoint for programmatic checks:

https://www.youtube.com/feeds/videos.xml?channel_id={CHANNEL_ID}&status=upcoming

However, this is not universally stable and should be used cautiously as a fallback rather than a primary source.

Why this works without an API key

YouTube maintains separate infrastructure for public subscription feeds versus the structured API endpoints. The Atom feed at /feeds/videos.xml is designed to be consumed by third-party apps without authentication, provided the channel owner allows it. This separation means you don't need OAuth tokens or API quotas for simple RSS aggregation.

If you're using Laravel, you can wrap this logic in a service class:

class YoutubeFeedService
{
    public function fetch($channelId): SimpleXMLElement
    {
        $url = "https://www.youtube.com/feeds/videos.xml?channel_id={$channelId}";

        $ch = curl_init();
        curl_setopt_array($ch, [
            CURLOPT_URL => $url,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_FOLLOWLOCATION => true,
            CURLOPT_TIMEOUT => 10,
        ]);

        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($httpCode !== 200) {
            throw new \Exception("Failed to fetch feed: HTTP {$httpCode}");
        }

        return simplexml_load_string($response);
    }
}

Trade-offs and limitations

  • No guaranteed uptime: YouTube may change or remove the endpoint with little notice.
  • Rate limits apply: Aggressive polling can trigger throttling.
  • Channel owner control: If a channel disables public subscriptions, the feed becomes inaccessible without OAuth.
  • No metadata enrichment: The basic feed lacks some fields available via v3 (e.g., detailed analytics).

For most feed reader use cases, these constraints are acceptable. If you need richer data or guaranteed access regardless of channel settings, an OAuth-enabled v3 integration is the only path forward.

When building tools that depend on YouTube feeds, always include fallback strategies—such as caching recent entries and retrying with backoff—to handle transient outages gracefully.

Our network