How to Analyze Your YouTube Competitors’ Channels at Scale

Why YouTube Competitive Analysis is Key for Winning on YouTube

To succeed on YouTube, it’s not enough to simply create and upload videos. Understanding what your competitors are doing, and doing better, can provide critical insights that shape your content strategy, enhance audience engagement, and ultimately drive business growth.

Here’s why conducting a YouTube competitive analysis is essential:

1. Identify Content Gaps and Opportunities

By analyzing your competitors’ content, you can uncover gaps in their strategies—topics they haven’t covered or niches they haven’t explored. This allows your business to fill those gaps with valuable content, attracting viewers that your competitors might be missing.

2. Optimize Content Strategy Based on Competitor Performance

Understanding which types of content perform best for your competitors can inform your own content strategy. For instance, you might discover that tutorial videos generate more engagement in your industry than promotional content, enabling you to adjust your approach accordingly.

3. Benchmark Your Channel’s Performance

Competitive analysis allows you to measure your channel’s performance against industry leaders. By benchmarking metrics like view count, subscriber growth, and engagement rates, you can set realistic goals and track your progress over time.

4. Improve Video SEO with Competitive Insights

Analyzing the keywords and tags used by successful competitors can help you optimize your video SEO. By incorporating these insights into your own metadata, you can improve your search rankings and increase visibility on the platform.

5. Enhance Audience Engagement by Learning from Competitor Interactions

Studying how your competitors engage with their audience—through comments, live streams, or community posts—can offer valuable lessons. Adopting similar tactics, or even improving upon them, can help you build a more loyal and active audience.

By focusing on these business-oriented benefits of YouTube competitive analysis, your company can not only keep up with the competition but also find new ways to stand out in a crowded marketplace.

Extracting YouTube Data for Competitive Analysis

To effectively perform a competitive analysis, the first step is to identify which competitors to analyze. Here’s a straightforward approach to finding your competitors and extracting key data from their videos.

Step 1: Identifying Competitors

To begin, you need to identify relevant competitors in your niche. For example, let’s say you’re focused on content related to “Social Media Marketing.” Here’s how you can find the top competitors:

1. Search on YouTube: Start by entering the keyword “Social Media Marketing” into the YouTube search bar. This will return a list of the most popular videos related to that topic.
2. Evaluate the top videos: Review the first page of the results and identify the videos with the highest views and engagement. These videos often belong to channels that are influential in your niche.
3. Select Competitor Channels: From the top-performing videos, select the top two channels that frequently appear in the search results. For this example, we will choose the channel Adam Erhart to demonstrate the process. However, you can choose as many competitor channels as you like and repeat the following steps for each channel.

Step 2: Scraping Video URLs from Competitor Channels

Once you’ve identified your competitors, the next step is to gather data from their most popular videos. We’ll automate this process using a combination of Python libraries—requests, BeautifulSoup, and yt-dlp—along with ScraperAPI to handle the scraping reliably.

import requests
from bs4 import BeautifulSoup
from yt_dlp import YoutubeDL
import pandas as pd

• requests: We use it to send a request to the YouTube channel’s videos page and retrieve the HTML content of the page.
• BeautifulSoup: BeautifulSoup allows us to navigate and search the HTML tree to extract specific elements—such as video URLs—from the page content.
• yt-dlp: This is a fork of the popular YouTube-dl tool, which is used to download videos and extract metadata from YouTube. In our case, we use yt-dlp to extract detailed information (like title, view count, and likes) from each video without downloading the video itself.
• Pandas: We use it to organize the extracted data into a structured format (e.g., a DataFrame) and save it as a CSV file for further analysis.

Next, we define some key variables:

# Replace with your ScraperAPI key
SCRAPER_API_KEY = 'your_scraperapi_key'
BASE_URL = 'http://api.scraperapi.com'
youtube_channel_videos_url = 'https://www.youtube.com/c/Adamerhartvideo/videos'

• SCRAPER_API_KEY: This is your unique key for accessing ScraperAPI. Replace the placeholder with your actual ScraperAPI key.
• BASE_URL: This is the base URL for making requests through ScraperAPI. All our requests will be directed to this URL, with additional parameters (like our target YouTube page) appended to it.
• youtube_channel_videos_url: This is the specific URL of the YouTube channel’s videos page we want to scrape. In this example, we’re using Adam Erhart’s channel, but this can be replaced with any competitor’s channel you want to analyze.

Step 3: Getting the URLs of Competitor Videos

After identifying your competitors and selecting the channels you want to analyze, the next step is to gather the URLs of their most popular videos. These URLs will serve as the entry points for extracting detailed information about each video. To automate this process, we’ll use ScraperAPI to scrape the video URLs from the competitor’s YouTube channel page.

Here’s how you can do it:

def scrape_youtube_video_urls(url):
    params = {
        'api_key': SCRAPER_API_KEY,
        'url': url,
        'render': 'true'
    }
    response = requests.get(BASE_URL, params=params)
    soup = BeautifulSoup(response.text, 'html.parser')
    
    video_urls = []
    
    videos = soup.find_all('ytd-rich-item-renderer')
    
    # Find all video hrefs
    for video in videos:
        video_url = video.find('a')['href']
        video_urls.append(f"https://www.youtube.com{video_url}")
    
    if not video_urls:
        print("No videos found")
        return []
    else:
        print("Video URLs scraped")
        return video_urls[:20]  # Limiting to top 20 videos

Here’s a breakdown of how this code works:

• params = { 'api_key': SCRAPER_API_KEY, 'url': url, 'render': 'true' }: This dictionary contains the parameters needed to make a request through ScraperAPI. The api_key is your unique ScraperAPI key, and url is the YouTube channel’s videos page that you want to scrape. The 'render': 'true' parameter ensures that JavaScript on the page is fully rendered before the content is returned, which is necessary for scraping dynamic content like YouTube videos.
• response = requests.get(BASE_URL, params=params): This line sends a GET request to ScraperAPI, passing in the parameters defined earlier. ScraperAPI fetches the fully rendered HTML content of the specified YouTube channel’s videos page, ensuring that all dynamic elements are loaded.
• soup = BeautifulSoup(response.text, 'html.parser'): Here, we use BeautifulSoup to parse the rendered HTML content retrieved by ScraperAPI. This allows us to navigate the HTML structure and extract specific elements, such as video URLs.
• videos = soup.find_all('ytd-rich-item-renderer'): This line finds all instances of ytd-rich-item-renderer elements, which represent individual videos in the list of uploads on a YouTube channel’s page. These elements contain the information we need to extract the video URLs.
• for video in videos:: This loop iterates through each video element found on the page.
  • video_url = video.find('a')['href']: Within each video element, this line extracts the relative URL (href) from the first anchor tag (<a>) found. This href represents the link to the specific video.
  • video_urls.append(f"https://www.youtube.com{video_url}"): The relative URL is combined with YouTube’s base URL (https://www.youtube.com) to create a full URL, which is then added to the video_urls list.
• if not video_urls:: This conditional checks if any video URLs were found. If none were found, it prints a message indicating no videos were found and returns an empty list.
• return video_urls[:20]: If video URLs were found, the function prints a success message and returns a list of the top 20 video URLs. This limit can be adjusted based on your analysis needs.

Step 4: Extracting Detailed Video Information

With the URLs of your competitor’s top videos in hand, the next step is to extract detailed information about each video. This is where the yt-dlp library comes into play. yt-dlp is a powerful tool that allows you to extract extensive metadata from YouTube videos without actually downloading the videos themselves. 

This includes information such as the video title, view count, and the number of likes—key metrics that can provide deep insights into your competitor’s content strategy.

Let’s break down the code that extracts this data:

def extract_video_info(video_url):
    opts = {}
    with YoutubeDL(opts) as yt:
        info = yt.extract_info(video_url, download=False)

        data = {
            "URL": video_url,
            "Title": info.get("title"),
            "Likes": info.get("like_count"),
            "Views": info.get("view_count"),
        }
        
        return data

• opts = {}: This line initializes an empty dictionary for options that can be passed to yt-dlp. In this example, we aren’t specifying any additional options, but yt-dlp supports a wide range of settings for more customized extractions.
• with YoutubeDL(opts) as yt:: This line creates a YoutubeDL object using the options defined (even if it’s empty in this case). The with statement ensures that resources are properly managed, and the yt object provides methods for extracting video information.
• info = yt.extract_info(video_url, download=False): The extract_info method retrieves all available metadata about the video specified by video_url. The download=False parameter tells yt-dlp to only extract the information without downloading the actual video file.
• data = { ... }: This dictionary collects the most relevant pieces of data from the info object. Specifically:
  • "URL": video_url: Stores the URL of the video, which can be useful for referencing the original content.
  • "Title": info.get("title"): Extracts the title of the video. The title is crucial for understanding the content’s focus and how it may appeal to viewers.
  • "Likes": info.get("like_count"): Captures the number of likes the video has received. This metric is a strong indicator of viewer approval and engagement.
  • "Views": info.get("view_count"): Records the total number of views, which reflects the video’s popularity and reach.
• return data: Finally, the function returns the data dictionary containing all the extracted information. This structured data can then be stored, analyzed, and compared across multiple videos.

By looping through each video URL obtained in the previous step, you can systematically gather a rich dataset of video titles, view counts, and likes. This information is essential for evaluating which types of content are most successful for your competitors.

This structured approach allows you to collect comparable data across multiple competitor channels, providing a comprehensive view of what’s working in your niche and guiding your own content strategy.

Step 5: Collecting and Compiling Video Data

Now that you have the URLs of your competitor’s top videos and a function to extract detailed information about each video, the next step is to bring everything together. 

The collect_videos_data function is responsible for orchestrating the entire data collection process. It calls the previous functions to first scrape the video URLs and then extract key metadata from each video. Finally, it compiles all the data into a structured format, ready for analysis.

Here’s how it works:

def collect_videos_data(youtube_channel_videos_url):

    video_urls = scrape_youtube_video_urls(youtube_channel_videos_url)
    
    all_video_data = []
    for video_url in video_urls:
        video_data = extract_video_info(video_url)
        all_video_data.append(video_data)
    
    if all_video_data:
        print("Data collected for top 20 videos")
        return all_video_data
    else:
        print("No data collected")
        return []

• video_urls = scrape_youtube_video_urls(youtube_channel_videos_url): We start by calling scrape_youtube_video_urls, passing in the URL of the competitor’s YouTube channel. This call returns a list of URLs for the top 20 videos on that channel.
• all_video_data = []: We initialize an empty list called all_video_data, which will store the detailed information for each video.
• for video_url in video_urls:: The function then loops through each video URL in video_urls.
  • video_data = extract_video_info(video_url): For each video URL, the function calls extract_video_info, which uses yt-dlp to extract metadata such as the video title, view count, and number of likes. The extracted data is stored in a dictionary format.
  • all_video_data.append(video_data): The extracted information for each video is added to the all_video_data list, building up a comprehensive collection of data from the competitor’s top videos.
• if all_video_data:: After the loop completes, the function checks if any video data was collected.
  • print("Data collected for top 20 videos"): If the list contains data, the function prints a success message and returns the compiled dataset.
  • else:: If no data was collected (for example, if the scraping process encountered an issue), the function prints a message indicating that no data was collected and returns an empty list.

This function efficiently automates the entire data collection process, allowing you to compile all the relevant information from your competitor’s top videos with minimal effort.

Step 6: Saving the Data and Finalizing the Script

After successfully collecting and compiling the video data, the final step is to save this data into a CSV file, making it easy to analyze and share. We’ll use the pandas library to convert the data into a DataFrame and then save it as a CSV file. Finally, we’ll execute the entire script to ensure everything runs smoothly.

Here’s the code to accomplish this:

ef save_to_csv(video_data):
    df = pd.DataFrame(video_data)
    df.to_csv('youtube_top_videos_data.csv', index=False)
    print("Data saved to youtube_top_videos_data.csv")

# Execute the script
if __name__ == "__main__":
    video_data = collect_videos_data(youtube_channel_videos_url)
    save_to_csv(video_data)

In this step, the save_to_csv function takes the compiled video data and converts it into a pandas DataFrame. It then saves this DataFrame as a CSV file named youtube_top_videos_data.csv. This file can be easily opened in Excel or any other data analysis tool for further examination. 

The script is finalized with an if __name__ == "__main__": block, which ensures that the collect_videos_data function is called, and the data is saved when the script is executed.

This final step efficiently wraps up the entire data collection process, allowing you to store your competitor’s video data in a structured, easily accessible format.

Analyzing YouTube Competitors: Drawing Strategic Insights

Once you’ve compiled data on your competitors’ top YouTube videos, the next step is to analyze this data to uncover key insights that can inform your content strategy.

Excel’s pivot tables are a powerful tool for summarizing and analyzing large datasets. In this section, we’ll walk you through how to create a pivot table in Excel using your video data and how to interpret the results to draw actionable insights.

Creating a Pivot Table to Analyze Video Performance

A pivot table allows you to quickly summarize large amounts of data and see relationships within the data. For example, you can use a pivot table to see which videos have the highest views and likes and identify patterns in the content that performs best.

Step-by-Step Tutorial

1. Prepare Your Data:
   • Before creating a pivot table, ensure that your data is clean and well-organized. Each column should have a clear header (e.g., Title, Likes Received, Views Received).
   • If you’re unfamiliar with preparing data in Excel, refer to our Amazon competitive analysis tutorial for guidance on data cleaning and organization.
2. Insert the Pivot Table:
   • Select your data range.
   • Go to the Insert tab in Excel and click PivotTable.
   • In the dialog box, choose where you want to place the pivot table (e.g., in a new worksheet) and click OK.
3. Configure the Pivot Table Fields:
   • In the PivotTable Fields pane, drag the Title field to the Rows area. This will list the video titles in the rows of the pivot table.
   • Drag the Views field to the Values area. Excel will automatically calculate the sum of views for each video.
   • Drag the Likes field to the Values area. Excel will also calculate the sum of likes for each video.
   • You can adjust the settings in the Values area to display the data as a sum, average, or another statistic.
4. Filter and Sort:
   • You can use the filter options in the pivot table to focus on the top-performing videos. For instance, sort the table by Views to display the videos with the most views at the top.
   • Similarly, you can filter by Likes to see which videos received the most engagement.
5. Interpreting the Pivot Table:

• The pivot table provides a clear overview of which videos are performing best based on views and likes.
• For example, from our pivot table, we can see that videos like “10 Instagram Marketing Strategies Guaranteed to Grow ANY Business” and “7 Effective Social Media Marketing Strategies for 2024” are among the top performers in both views and likes.

Drawing Strategic Insights from the Pivot Table

With the pivot table in place, you can begin to draw meaningful insights that will inform your content strategy:

• High-Performing Content: The top videos by views and likes likely represent the content that resonates most with your competitor’s audience. For instance, videos that provide actionable strategies and tips (“How to…”, “Top 10…”) appear to be particularly effective. This suggests that creating similar content could be beneficial for your own channel.
• Keyword Effectiveness: The titles of the top videos often include strong keywords related to social media marketing strategies. These keywords not only help attract viewers but also drive engagement. Incorporating these or similar keywords into your own video titles could improve your content’s visibility.
• Audience Preferences: The data suggests that viewers are particularly interested in strategic and educational content. Videos offering practical advice and step-by-step guides seem to perform well, indicating a preference for tangible content.

By leveraging a pivot table to analyze your competitors’ video data, you can efficiently identify the strategies and content types that work best in your niche. This data-driven approach allows you to fine-tune your content strategy, helping you create videos that attract more views and engage your audience more effectively.

Wrapping Up: Business Use Cases for YouTube Competitive Analysis

Conducting a thorough YouTube competitive analysis is a strategic tool that can significantly boost your business’s content strategy and overall digital presence. The insights gathered from analyzing your competitors’ video titles, likes, and view counts can be applied in a variety of practical ways to drive tangible business outcomes.

For instance:

• By identifying the topics and keywords that consistently attract high views and engagement, you can tailor your content strategy to focus on what your audience truly cares about. Optimizing video titles based on successful competitor strategies can improve your videos’ visibility in search results, driving more organic traffic to your content.
• Creating high-engagement content by emulating the successful elements of your competitors’ videos—whether it’s the content type, presentation style, or emotional triggers—can help you build a more loyal audience. Videos that resonate deeply with viewers tend to keep them engaged and coming back for more, which is crucial for growing a dedicated follower base.
• Furthermore, the benchmarks established from your competitive analysis provide a solid foundation for measuring your own success. Regularly comparing your content’s views, likes, and engagement rates against those of your competitors can help you stay competitive and continuously improve your strategy.

These insights also open doors for monetization opportunities. Identifying content that attracts high engagement can lead to better ad placements or sponsorship deals. Moreover, partnering with other creators or influencers, especially in content areas that perform well, can help expand your reach and tap into new audience segments.

Harnessing the power of YouTube competitive analysis can be a game-changer for your business. By understanding what works—and what doesn’t—you can optimize your content strategy, engage your audience more effectively, and stay ahead of the competition.

Ready to take your YouTube strategy to the next level? Try ScraperAPI today and start gaining actionable insights that drive real business results. With ScraperAPI, you can effortlessly scrape YouTube data and more, giving you the tools you need to outmaneuver your competitors and achieve success.