How SponsorBlock Works in YouTube: An In-Depth Explanation

The SponsorBlock browser extension is a fantastic tool that enhances your YouTube experience by automatically skipping over sponsored content, self-promotion, and other non-essential segments in videos. If you’ve ever been annoyed by long sponsor segments or repetitive self-promos, this extension is designed to help you avoid them effortlessly. Let's break down how the SponsorBlock extension works, step by step, using pseudocode to make it easy to understand.

What Is SponsorBlock?

SponsorBlock is an extension for web browsers that helps you skip through parts of YouTube videos that are marked as sponsored content, self-promotion, or other types of non-video content. It relies on a community-driven database where users submit information about these segments, allowing others to benefit by skipping them automatically.

Key Terms:

• Sponsor segment: A part of a YouTube video where the creator talks about a product or service that sponsors them.
• Crowdsourced: Information gathered from a large group of people who voluntarily contribute to it.
• Skippable segment: A part of the video you don’t have to watch, like sponsor ads.

Now, let’s dive into how it works, step by step.

How SponsorBlock Works: A Step-by-Step Explanation

The process of sponsor blocking in YouTube Vanced can be broken down into a few main steps:

1. Identifying Video: When you watch a YouTube video, the app recognizes the video you’re watching by using a unique ID.
2. Fetching Skippable Segments: The app checks a server (SponsorBlock database) to see if there are any skippable segments for that video.
3. Skipping the Sponsor Segment: If skippable segments are found, the app automatically jumps over those parts of the video.

Let’s explain each step with more detail using pseudocode.

Step 1: Identifying the Video

Every YouTube video has a unique identifier called a video ID. This is part of the URL when you watch the video. For example:

https://www.youtube.com/watch?v=abc123XYZ

In this case, abc123XYZ is the video ID. The first step for SponsorBlock is to figure out which video you’re watching.

Pseudocode:

// Step 1: Get the video ID of the current video
videoID = getCurrentVideoID()

The function getCurrentVideoID() is responsible for grabbing the video ID of the video you’re watching.

Step 2: Fetching Skippable Segments from the Server

Once the app knows the video ID, it sends a request to the SponsorBlock server to see if other users have already marked any parts of this video as skippable (like sponsor ads or self-promotion).

The server responds with a list of timestamps, marking the start and end of each skippable segment.

Pseudocode:

// Step 2: Send the video ID to the SponsorBlock server and fetch skippable segments
skippableSegments = fetchFromServer(videoID)

// Example of what 'skippableSegments' might look like:
skippableSegments = [
    {"start": 60, "end": 120}, // Skip from 1:00 to 2:00
    {"start": 300, "end": 330} // Skip from 5:00 to 5:30
]

The function fetchFromServer(videoID) contacts the SponsorBlock server, which returns an array of timestamps that represent the sponsor segments.

Step 3: Skipping the Sponsor Segment

Now that the app has a list of skippable segments, it needs to monitor the video while you’re watching it. Once the current time in the video reaches the start of a sponsor segment, the app automatically jumps forward to the end of the segment.

Pseudocode:

// Step 3: Continuously monitor the video time
while videoIsPlaying:
    currentTime = getCurrentVideoTime()

    // Check if the current time falls within any skippable segments
    for segment in skippableSegments:
        if currentTime >= segment["start"] and currentTime <= segment["end"]:
            // Skip to the end of the segment
            skipTo(segment["end"])

Here, getCurrentVideoTime() returns the current time of the video in seconds, and skipTo() jumps to a specific time in the video (in this case, the end of the skippable segment).

Step 4: Allowing User Customization

YouTube Vanced allows users to choose whether or not they want to skip certain types of content, like sponsor segments, self-promotion, or other types of non-video content (like the end credits). This customization is handled by checking which types of segments the user wants to skip.

Pseudocode:

// Step 4: Allow the user to customize which segments to skip
skipTypes = getUserSettings() // e.g., {"sponsor": true, "self-promo": false, "credits": true}

// Before skipping, check if the user has chosen to skip this type of segment
for segment in skippableSegments:
    segmentType = getSegmentType(segment) // e.g., "sponsor", "self-promo", "credits"

    if skipTypes[segmentType] == true:
        if currentTime >= segment["start"] and currentTime <= segment["end"]:
            skipTo(segment["end"])

In this code, getUserSettings() retrieves the user’s preferences, and getSegmentType(segment) returns the type of segment (e.g., sponsor or self-promotion). The app only skips the segment if the user has enabled that type of skip.

Step 5: Submitting New Skippable Segments

If you watch a video and notice a sponsor segment that hasn't been marked yet, you can contribute to the community by submitting the segment. This involves marking the start and end times of the sponsor content and sending this data to the SponsorBlock server.

Pseudocode:

// Step 5: Allow the user to submit new skippable segments
newSegment = getUserInputForSegment() // e.g., {"start": 180, "end": 240, "type": "sponsor"}
sendToServer(videoID, newSegment)

The function getUserInputForSegment() allows the user to manually input the start and end times of the segment, and sendToServer(videoID, newSegment) sends this data to the SponsorBlock server to help other users skip the same segment.

Behind the Scenes: The SponsorBlock Server

The SponsorBlock server is essentially a database that stores all the skippable segments submitted by users. When the app requests skippable segments for a specific video, the server looks up that video ID and sends back the appropriate timestamps.

Here's how the server works in simple terms:

1. Store the segments: The server stores information about skippable segments for every video ID.
2. Respond to requests: When an app sends a video ID, the server looks up skippable segments and sends them back.
3. Accept new submissions: When users submit new skippable segments, the server updates its database.

Pseudocode for server operations:

// Server: Storing segments for videos
database[videoID] = [
    {"start": 60, "end": 120, "type": "sponsor"},
    {"start": 300, "end": 330, "type": "self-promo"}
]

// Server: Fetching skippable segments
function fetchSegments(videoID):
    return database[videoID]

// Server: Storing new segments
function storeSegment(videoID, segment):
    database[videoID].append(segment)

Conclusion: The Power of SponsorBlock

The SponsorBlock browser extension is a powerful tool that improves your YouTube viewing experience by allowing you to skip over sponsor segments, self-promos, and other non-video content. It leverages a community-driven approach to build a database of skippable segments and integrates seamlessly with your browser to provide a smoother viewing experience.

By following these steps:

1. Detecting the Video: Get the video ID.
2. Fetching Skippable Segments: Request segment data from the server.
3. Monitoring the Video: Automatically skip over identified segments.
4. Submitting New Data: Contribute new segments to the community.

SponsorBlock makes watching YouTube videos less interrupted and more enjoyable by leveraging the power of community contributions and automated content management.