DEV Community: Cleaner Wrasse

Building a YouTube Video View Count Ranking CLI Tool with Python and YouTube Data API

Cleaner Wrasse — Thu, 27 Aug 2026 02:58:46 +0000

Building a Video View Count Ranking CLI with Python and the YouTube Data API

Introduction

In this article, I built a CLI tool using Python and the YouTube Data API v3.

The tool takes a YouTube channel as input and:

Retrieves the latest 100 videos
Retrieves the view count of each video
Sorts the videos by view count in descending order
Displays the top 10 videos in the terminal

🎯 Building a Minimal Working CLI Tool with Python

The goal of this project is to build a CLI tool that retrieves video information from a specified YouTube channel.

The tool can be launched from the terminal with:

python3 youtube_cli.py

🧩 1. Install the Required Libraries

First, install the libraries required to use the YouTube Data API from Python.

pip3 install google-api-python-client google-auth-oauthlib google-auth-httplib2

🧩 2. Enable the API in Google Cloud Console

To use the YouTube Data API, you first need to configure your project in Google Cloud.

Open Google Cloud Console
Create a new project
Enable YouTube Data API v3
Create an OAuth 2.0 Client ID
Download client_secret.json
Place client_secret.json in your Python project directory

🧩 3. CLI Tool Implementation (`youtube_cli.py`)

Here is the Python CLI tool used in this project.

The user enters a YouTube channel name or handle, and the tool retrieves the latest 100 videos from that channel and displays the top 10 videos with the highest view counts.

youtube_cli.py

from google_auth_oauthlib.flow import InstalledAppFlow
from googleapiclient.discovery import build

SCOPES = ["https://www.googleapis.com/auth/youtube.readonly"]

def get_channel_id_from_query(youtube, query):
    # Search YouTube for the specified channel name or keyword
    print(f"Searching for a channel matching: 「{query}」")
    response = youtube.search().list(
        part="snippet",
        q=query,
        type="channel",
        maxResults=1
    ).execute()

    items = response.get("items", [])
    if not items:
        raise ValueError(f"Channel 「{query}」 was not found.")

    channel_id = items[0]["snippet"]["channelId"]
    channel_title = items[0]["snippet"]["title"]
    print(f"Target channel: 【 {channel_title} 】\n")

    return channel_id

def main():
    TOP_N = 10
    MAX_VIDEOS = 100  # Maximum number of recent videos to retrieve

    # OAuth authentication
    flow = InstalledAppFlow.from_client_secrets_file(
        "client_secret.json", SCOPES
    )
    creds = flow.run_local_server(port=0)
    youtube = build("youtube", "v3", credentials=creds)

    # 1. Ask the user for a channel name or keyword
    user_query = input(
        "Enter the name of the YouTube channel you want to analyze: "
    ).strip()

    if not user_query:
        print("No channel name was entered. Exiting.")
        return

    # Get the channel ID
    try:
        channel_id = get_channel_id_from_query(youtube, user_query)
    except ValueError as e:
        print(e)
        return

    # Get the channel's uploads playlist ID
    channel_info = youtube.channels().list(
        part="contentDetails",
        id=channel_id
    ).execute()

    uploads_playlist_id = (
        channel_info["items"][0]
        ["contentDetails"]
        ["relatedPlaylists"]
        ["uploads"]
    )

    # Retrieve up to 100 recent video IDs
    video_ids = []
    next_page_token = None

    print("Retrieving the latest videos...")

    while True:
        playlist_items = youtube.playlistItems().list(
            part="contentDetails",
            playlistId=uploads_playlist_id,
            maxResults=50,
            pageToken=next_page_token
        ).execute()

        for item in playlist_items.get("items", []):
            video_ids.append(item["contentDetails"]["videoId"])

            # Stop when the maximum number of videos is reached
            if len(video_ids) >= MAX_VIDEOS:
                break

        if len(video_ids) >= MAX_VIDEOS:
            break

        next_page_token = playlist_items.get("nextPageToken")

        if not next_page_token:
            break

    videos = []

    print(f"Retrieving data for the latest {len(video_ids)} videos...")

    # Process videos in batches of up to 50
    for i in range(0, len(video_ids), 50):
        chunk_ids = video_ids[i:i+50]
        ids_string = ",".join(chunk_ids)

        stats = youtube.videos().list(
            part="statistics,snippet",
            id=ids_string
        ).execute()

        for info in stats.get("items", []):
            title = info["snippet"]["title"]
            views = int(info["statistics"].get("viewCount", 0))
            video_id = info["id"]

            videos.append({
                "title": title,
                "views": views,
                "id": video_id
            })

    # Sort by view count
    videos.sort(key=lambda x: x["views"], reverse=True)

    # Display the ranking
    print(
        f"\n--- View Count Ranking for 【{user_query}】 "
        f"(Top {TOP_N}) ---"
    )

    for i, v in enumerate(videos[:TOP_N], start=1):
        print(
            f"{i}. {v['title']} - {v['views']:,} views "
            f"(https://www.youtube.com/watch?v={v['id']})"
        )

if __name__ == "__main__":
    main()

Running the CLI Tool

Run the following command from the directory containing youtube_cli.py:

./scripts % python3 youtube_cli.py

A browser window will open, and you will be asked to select a Google account.

Select the account you want to use for authentication.

Then, click Continue.

After authentication is completed, return to the terminal.

You should then see the following prompt:

Enter the name of the YouTube channel you want to analyze:

For example, enter:

Enter the name of the YouTube channel you want to analyze: @SaturdayNightLive

Output

The tool will search for the specified channel and retrieve its latest videos.

Searching for a channel matching: 「@SaturdayNightLive」
Target channel: 【 Saturday Night Live 】

Retrieving the latest videos...
Retrieving data for the latest 100 videos...

--- View Count Ranking for 【@SaturdayNightLive】 (Top 10) ---
1. you know what this song needs? - 12,489,263 views (https://www.youtube.com/watch?v=Q1ZabPOA76w)
2. cast list reveal - 6,404,227 views (https://www.youtube.com/watch?v=Uw9ub2NnMYY)
3. Jeffrey Epstein Ghost Cold Open - SNL - 5,039,611 views (https://www.youtube.com/watch?v=YzqJh6WnQOM)
4. some wires were crossed - 4,867,443 views (https://www.youtube.com/watch?v=HZtZATonxw8)
5. weekend update! - 3,381,263 views (https://www.youtube.com/watch?v=gROY9_gPA4Q)
6. the american dream - 3,258,007 views (https://www.youtube.com/watch?v=wCSDinZYJEQ)
7. finale joke swap! - 3,054,821 views (https://www.youtube.com/watch?v=WMRcO1VuUhw)
8. Weekend Update: Colin Jost and Michael Che Swap Jokes for Season 51 Finale - SNL - 3,041,289 views (https://www.youtube.com/watch?v=WY8lNAmso1Y)
9. talking to a mechanic be like - 2,916,902 views (https://www.youtube.com/watch?v=-VAQxjvYxZ8)
10. now kiss - 2,871,220 views (https://www.youtube.com/watch?v=ruX5XweYnOI)

🎯 Conclusion

The YouTube Data API CLI tool follows this flow:

Enable the API in Google Cloud
↓
Create an OAuth 2.0 Client ID
↓
Place client_secret.json in the Python project
↓
Authenticate with a Google account
↓
Call the YouTube Data API
↓
Receive the response in JSON format
↓
Process the required data with Python
↓
Display the results in the terminal

In short:

Configure the API in Google Cloud, authenticate the Python application with OAuth, call the YouTube Data API, process the returned JSON data with Python, and display the results through a CLI.

My Developer Profile

Cleaner Wrasse — Sun, 26 Apr 2026 16:07:16 +0000

About Me

I took the plunge into the IT industry in May 2023.
In my career so far, I’ve had many opportunities to work with Java and JavaScript (TypeScript). My current goal is to build a solid foundation in these two languages before exploring further career opportunities🏂

As a junior engineer, I am learning something new every day, and I'm eager to gain broad and deep knowledge and experience in the tech field🧑‍💻

Note
I haven't been able to travel lately, so I'm dying to go somewhere far away! ✈️

📸 Sandanbeki Rock Cliff | Shirahama, Wakayama

📸 Yakatabune (Traditional Houseboat) | Arashiyama, Kyoto

📸 Halloween Night | Namba, Osaka

📸 Kyudo (Japanese Archery) Experience | Shinsekai, Osaka

📸 Bundaran HI (Welcome Monument) | Jakarta, Indonesia

📸 Römerberg Square | Frankfurt, Germany

🛠 Tech Stack & Expertise

Java
JavaScript / TypeScript

🔗 Links & Portfolio

GitHub: Flying-WhaleShark

🚀 Featured Project: Hotel Booking System

This is a full-stack project I developed to solidify my foundation in Java and TypeScript while mastering the end-to-end development process.

Live Demo: Hotel Booking UI (on Render)
Source Code:
- HotelBooking_UI (Frontend / TypeScript)
- HotelBooking_API (Backend / Java)

🧠 Words to Live By

Done is better than perfect
This phrase by Mark Zuckerberg (similar to Steve Jobs' "Real artists ship") serves as a constant reminder for me. I used to be someone who had many ideas but struggled to bring them to fruition. This quote keeps me moving forward😅
If you want to find the secrets of the universe, think in terms of energy, frequency and vibration
Nikola Tesla’s words. I believe there is profound truth in this that science has yet to fully prove. I hope to eventually understand its meaning deeply, either through future scientific breakthroughs or my own interpretation.
Amor Fati
"Love of Fate." I believe there are three main perspectives: oneself, others, and third parties. No matter how well I do, events and accidents occur out of my control. This concept is essential for maintaining the right mindset when they do. While phrases like "C'est la vie" or "Love your neighbor as yourself" are similar, "Amor Fati" resonates with me the most.

🎬 Currently Into

Watching classic movies (especially from the 80s)

Gremlins
They Live (1988), etc.

I’m fascinated by the cultural backgrounds of that era and enjoy comparing older filming techniques with modern ones. Exploring "how things were expressed" back then through cinematography is incredibly stimulating👀✨

🎨 Art & Design Favorites

I am drawn to works that possess a powerful visual impact and overwhelming energy.

The Last Judgment / Michelangelo
The School of Athens / Raphael
Thirty-six Views of Mount Fuji / Katsushika Hokusai
A Famous Mirror: The Spirit of Japan / Kawanabe Kyosai
Morozumi Bungo no kami Masakiyo / Utagawa Kuniyoshi

🎵 Favorite Artists

Kenshi Yonezu (J-Pop / Electronic)
King Gnu (J-Pop / Mixture Rock)
Taylor Swift (Pop / Country)

🏃 Hobbies & Lifestyle

Habits: English learning, Strength training, Swimming
Activities: Bouldering, Traveling

📍 Location

Hometown: Tokyo
Based in: Tokyo → Osaka → Tokyo

How to Deploy a Spring Boot + React App for Free on Render: From Local to Production

Cleaner Wrasse — Tue, 21 Apr 2026 14:35:08 +0000

LIVE DEMO: https://hotelbooking-ui-ds7l.onrender.com/

🛠 Tech Stack

Frontend: React, Tailwind CSS
Backend: Java, Spring Boot
Database: PostgreSQL (H2)
Deployment: Render
Monitoring: UptimeRobot

1/9:

I’d been wanting to build my portfolio using Spring Boot but wasn't sure where to start. While looking for a free hosting service, I came across Render and decided to use it to bring my project to life!

https://render.com/docs/free

At the same time, I realized that building the UI from scratch would be quite a challenge. I figured using a template might be a better approach, so I searched for 'booking application web templates react' and came across this website:

https://github.com/arnobt78/Hotel-Booking-Landing-Page--React-Frontend

I chose the following website for my base design, but I noticed the navigation bar wasn't working properly. To fix this, I also referred to the site below, as combining them allowed me to create a fully functional and reliable user interface.

https://qiita.com/midori-game/items/17357d46e3ed1281001c

To update the visuals, I used the three websites mentioned below along with Nano Banana 2 for image generation.

https://unsplash.com/

https://www.pexels.com/

https://pixabay.com/

2/9:

After that, I cloned the repository and set up the project locally. As a first step for the UI updates, I started by replacing the images.

Original UI:

My current UI:

3/9:

At this stage, I started working on the backend separately from the UI. I chose Spring Boot for the API development. After fine-tuning the integration between the UI and API, I refactored the image handling so that pictures are now managed via the backend database instead of being stored directly in the frontend.

4/9:

↓After completing the UI and API development and verifying the local server setup, I pushed the code to GitHub.

5/9:

With the code ready, I started setting up my Render account. I referred to the guide below for the setup process. I chose to authenticate with GitHub as it’s much more efficient for linking repositories.
https://qiita.com/tks_00/items/73cf04c225e5f6113cd8

6/9:

I proceeded by setting up the API as a Web Service and the UI as a Static Site. It wasn't a smooth start—I ran into several deployment errors related to updated paths and database configurations. Some images also failed to load initially. I spent some time troubleshooting these configuration issues and eventually secured a successful deploy.

7/9:

I've finally reached a point where I'm happy with the progress.

8/9:

Optimizing Load Speed
I noticed that Render’s free tier spins down the instance after 15 minutes of inactivity, leading to a long 60-90s wait for the first user. To maintain faster response times, I integrated UptimeRobot to monitor the site and prevent it from sleeping. I referred to this article for the implementation:
https://qiita.com/yuto141592/items/cef9b50ea4557dfe1be7

After accessing the UptimeRobot site, I created an account using GitHub authentication. To start the monitoring, I pasted my website's URL into the 'URL to monitor' section.
https://dashboard.uptimerobot.com/monitors?ref=website-header

The default monitoring interval is set to every 5 minutes. Since that's enough to keep the server from sleeping, I kept the default settings. With this, the initial loading problem is now solved.

9/9:

Key Takeaways
Through this project, I gained practical experience in integrating React with Spring Boot and learned a lot about server-side communication.

While the current backend is a minimal setup, I plan to build upon it by implementing a booking system. I also aim to add more advanced features such as API fetching and PDF generation to further enhance the backend's functionality.

Links

Live Demo:
https://hotelbooking-ui-ds7l.onrender.com/

Source Code:
https://github.com/Flying-WhaleShark/HotelBooking_UI
https://github.com/Flying-WhaleShark/HotelBooking_API