YouTube SponsorBlock Segments Scraper

YouTube SponsorBlock Segments Scraper exports crowdsourced sponsor and non-content timestamps from public YouTube videos. Give it video URLs or IDs and receive analysis-ready SponsorBlock rows with exact start and end times, categories, votes, lock state, UUIDs, and source links.

No YouTube API key, SponsorBlock account, browser, or proxy is required.

What does YouTube SponsorBlock Segments Scraper do?

This Actor looks up the public SponsorBlock dataset for batches of YouTube videos. It emits one row for every matching segment instead of hiding several timestamps inside one nested video object. That shape is convenient for transcript cleanup, editing tools, sponsor-load research, and media datasets.

You can request all public SponsorBlock categories:

• 🎯 sponsor — paid promotion or sponsor reads
• 📣 selfpromo — creator self-promotion
• 👍 interaction — subscribe, like, or comment reminders
• 🎬 intro — opening sequences
• 🏁 outro — end cards and closing material
• 🎵 music_offtopic — non-music sections in music videos
• ⏪ preview — recaps or previews
• 🧩 filler — tangential filler
• 📍 poi_highlight — points of interest users may jump to

Start with the prefilled video to see real data in seconds.

Who is this YouTube segment scraper for?

Transcript and AI pipeline builders

• Remove sponsor reads before embedding or summarizing transcripts.
• Exclude intros, outros, and interaction reminders from training corpora.
• Keep UUID and vote metadata for reproducible filtering rules.

Video editors and media operations teams

• Turn public skip markers into review queues.
• Create cut lists from startSeconds and endSeconds.
• Process recurring batches without copying timestamps by hand.

Media researchers and analysts

• Measure sponsor duration as a share of video runtime.
• Compare sponsor load across a selected video corpus.
• Separate community-approved locked segments from disputed submissions.

Developers building YouTube tools

• Add SponsorBlock data through the Apify API, schedules, webhooks, or MCP.
• Export flat JSON, CSV, Excel, XML, or RSS-compatible data.
• Handle missing videos and per-video errors without losing the rest of a batch.

Why use this SponsorBlock scraper?

• ✅ Exact timestamps — numeric starts, ends, and computed duration.
• ✅ All public categories — not only paid sponsor reads.
• ✅ Batch input — mix watch URLs, Shorts URLs, youtu.be links, and IDs.
• ✅ Flat dataset — one segment per row for easy filtering and joins.
• ✅ Moderation context — retain votes and lock state.
• ✅ Reliable batches — bounded retries for rate limits and temporary failures.
• ✅ No credentials — no Google API quota or SponsorBlock token.
• ✅ Low overhead — direct HTTP requests without browser startup.
• ✅ Apify platform features — API access, scheduling, webhooks, datasets, and integrations.

What SponsorBlock data can you extract?

Field	Meaning
recordType	segment, no_segments, or error
videoId	Canonical 11-character YouTube video ID
category	SponsorBlock category
actionType	Recommended action such as skip
startSeconds	Segment start in seconds
endSeconds	Segment end in seconds
durationSeconds	Computed end minus start
uuid	SponsorBlock segment UUID
votes	Community vote score
locked	Whether the segment is locked by SponsorBlock moderation
description	Public segment description when supplied
videoDurationSeconds	Video duration reported with the segment
sourceUrl	Canonical YouTube watch URL
sponsorBlockApiUrl	Exact public API request used
fetchedAt	UTC ISO 8601 fetch time
error	Per-video failure message, only for error rows

SponsorBlock is crowdsourced. A missing segment means no matching public submission was returned; it does not prove that a video contains no sponsorship. Vote scores can also change over time.

How much does it cost to extract YouTube sponsor segments?

This Actor uses pay-per-event pricing. A small start fee covers batch initialization, then only emitted SponsorBlock segment rows are charged. no_segments and error status rows are not charged as segments.

Event	Free	Starter / Bronze	Scale / Silver	Business / Gold
Run start	$0.005	$0.005	$0.005	$0.005
Each segment	$0.000087727	$0.000076284	$0.000059502	$0.000045771

Examples at the measured rates:

Workflow	Segments	Free-tier price	Bronze price
One short lookup	5	about $0.00544	about $0.00538
Small research batch	100	about $0.01377	about $0.01263
Dataset cleanup	1,000	about $0.09273	about $0.08128

Apify's Free plan includes monthly platform credits, so small evaluations can usually run within those credits. Final billed cost depends on the number of public matching segments, not the number of input videos.

How to scrape SponsorBlock timestamps from YouTube

1. Open YouTube SponsorBlock Segments Scraper on Apify.
2. Add one or more YouTube video URLs or IDs under Video URLs or IDs.
3. Select the categories relevant to your workflow.
4. Enable Include videos with no segments if you need a coverage audit.
5. Click Start.
6. Preview the default dataset while the run is active.
7. Export the result as JSON, CSV, Excel, XML, or another supported format.

A minimal input:

{
  "videos": ["https://www.youtube.com/watch?v=Hfovjw7Ts_U"],
  "categories": ["sponsor", "selfpromo"]
}

A transcript-cleanup input:

{
  "videos": [
    "https://youtu.be/Hfovjw7Ts_U",
    "dQw4w9WgXcQ"
  ],
  "categories": [
    "sponsor",
    "selfpromo",
    "interaction",
    "intro",
    "outro"
  ],
  "includeNoSegments": true,
  "concurrency": 4
}

Input parameters

Parameter	Type	Default	Description
videos	string array	required	1–500 YouTube video URLs or IDs
categories	string array	all nine categories	Public SponsorBlock categories to request
includeNoSegments	boolean	false	Emit an uncharged summary row for videos with no matching segments
concurrency	integer	8	Simultaneous requests, from 1 to 25
maxRetries	integer	3	Retries for timeout, HTTP 429, and temporary 5xx responses

Supported URL forms include:

• https://www.youtube.com/watch?v=VIDEO_ID
• https://youtu.be/VIDEO_ID
• https://www.youtube.com/shorts/VIDEO_ID
• https://www.youtube.com/live/VIDEO_ID
• https://www.youtube.com/embed/VIDEO_ID
• raw VIDEO_ID

Duplicate video IDs are fetched once even when supplied in different URL forms. Unsupported hosts and malformed IDs fail validation instead of being sent to an unrelated website.

Output example

{
  "recordType": "segment",
  "videoId": "Hfovjw7Ts_U",
  "category": "sponsor",
  "actionType": "skip",
  "startSeconds": 42.042,
  "endSeconds": 58.689,
  "durationSeconds": 16.647,
  "uuid": "fee520a575a4db8d9201027697a6b177238ca53f6742e21fad994e98a1870b407",
  "votes": 2,
  "locked": false,
  "description": "",
  "videoDurationSeconds": 1457.841,
  "sourceUrl": "https://www.youtube.com/watch?v=Hfovjw7Ts_U",
  "sponsorBlockApiUrl": "https://sponsor.ajay.app/api/skipSegments?...",
  "fetchedAt": "2026-07-24T00:00:00.000Z"
}

When includeNoSegments is enabled, a video without matching submissions produces:

{
  "recordType": "no_segments",
  "videoId": "AAAAAAAAAAA",
  "sourceUrl": "https://www.youtube.com/watch?v=AAAAAAAAAAA",
  "fetchedAt": "2026-07-24T00:00:00.000Z"
}

A failed video request produces an error row and does not cancel successful video lookups in the same batch. If every request fails, the overall run fails so monitoring systems do not mistake an outage for valid empty coverage.

How segment deduplication works

Inputs are normalized to canonical YouTube IDs before requests begin. Repeated IDs are removed from the queue. Output records are then deduplicated by the combination of videoId and SponsorBlock UUID.

This means:

• the same watch and youtu.be URL do not create duplicate rows;
• two different segments in one video remain separate;
• the same UUID in two different video IDs remains traceable to its source;
• status rows remain clearly distinguished with recordType.

Tips for best results

• Start with one or two videos to confirm the categories fit your workflow.
• Keep concurrency at the default unless you have a large batch.
• Use sponsor alone when you only need paid ad reads.
• Include intro, outro, and interaction for transcript cleanup.
• Enable includeNoSegments when completeness of the input list matters.
• Filter low-vote rows downstream if your use case requires conservative markers.
• Prefer locked rows when you need stronger moderation confidence.
• Store the uuid if you plan to compare snapshots over time.
• Schedule recurring runs when researching a changing video corpus.

Reliability and error handling

The Actor requests SponsorBlock directly over HTTPS. It treats HTTP 404 as a valid “no submitted segments” result. Timeouts, HTTP 429 rate limits, and temporary 5xx server failures use bounded exponential backoff. A Retry-After response header is respected up to a safe delay limit.

Invalid input fails before any source requests are sent. One failed video becomes an error row while other workers continue. This fail-soft batch behavior is useful for large pipelines, while the all-failed guard keeps alerts truthful.

Integrations for video workflows

YouTube SponsorBlock Segments Scraper → Google Sheets

Export segment rows to a sheet, calculate durationSeconds / videoDurationSeconds, and compare sponsor load across videos.

YouTube SponsorBlock Segments Scraper → transcript processing

Join rows by videoId, then remove transcript tokens whose timestamps overlap sponsor, intro, outro, or interaction ranges.

YouTube SponsorBlock Segments Scraper → Slack or Discord

Schedule a batch and send a webhook when new sponsor UUIDs appear in a monitored corpus.

YouTube SponsorBlock Segments Scraper → Make or Zapier

Trigger a workflow after each run, route high-vote sponsor rows to a database, and preserve errors for retry queues.

YouTube SponsorBlock Segments Scraper → cloud storage

Use Apify integrations to archive JSON or CSV snapshots for longitudinal media research.

Using the Apify API with Node.js

Install the Apify client:

$npm install apify-client

Run the Actor and read its default dataset:

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/youtube-sponsorblock-segments-scraper').call({
  videos: ['https://www.youtube.com/watch?v=Hfovjw7Ts_U'],
  categories: ['sponsor', 'selfpromo', 'intro', 'outro'],
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);

Using the Apify API with Python

Install the client:

$pip install apify-client

Then call the Actor:

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/youtube-sponsorblock-segments-scraper').call(run_input={
    'videos': ['Hfovjw7Ts_U'],
    'categories': ['sponsor'],
    'includeNoSegments': True,
})

items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)

Using the Apify API with cURL

Start a run:

curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~youtube-sponsorblock-segments-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "videos": ["Hfovjw7Ts_U"],
    "categories": ["sponsor", "selfpromo"]
  }'

After the run finishes, fetch items from its defaultDatasetId:

$curl "https://api.apify.com/v2/datasets/DATASET_ID/items?clean=true&format=json"

Use with AI agents via MCP

YouTube SponsorBlock Segments Scraper can be used by AI assistants through Apify's Model Context Protocol integration.

For Claude Code:

$claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/youtube-sponsorblock-segments-scraper"

For Claude Desktop, Cursor, or VS Code, add this MCP configuration:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/youtube-sponsorblock-segments-scraper"
    }
  }
}

Your client will ask you to authenticate with Apify.

Example prompts

Try asking:

• “Use automation-lab/youtube-sponsorblock-segments-scraper to list paid sponsor spans in these five YouTube URLs.”
• “Export intros, outros, and interaction reminders so I can clean this transcript batch.”
• “Compare sponsor duration and community vote scores across these videos.”

Is it legal to extract SponsorBlock data?

SponsorBlock exposes these crowdsourced records through a public endpoint. You should still use the data responsibly, follow SponsorBlock's applicable terms and API guidance, respect YouTube's terms, and comply with privacy and data-protection laws relevant to your use case.

This Actor does not bypass authentication or access private YouTube data. It only looks up user-supplied public video IDs. Do not use the output to misrepresent community submissions as verified facts; votes, lock state, and coverage can change.

Limitations

• SponsorBlock is crowdsourced, so some videos have no submissions.
• A submission can be disputed, outdated, or later removed.
• Vote scores and lock state reflect the response at fetch time.
• This Actor does not download videos, captions, audio, or thumbnails.
• It does not discover channel videos in v1; provide video URLs or IDs directly.
• It does not submit, vote on, or modify SponsorBlock segments.
• It does not extract promo codes from YouTube descriptions.
• Private, deleted, malformed, or unknown IDs may have no SponsorBlock rows.
• SponsorBlock rate limits or outages can temporarily produce error rows.

Troubleshooting

Why is the dataset empty?

The selected videos may have no public submissions for the selected categories. Enable includeNoSegments to receive explicit coverage rows, or broaden the category selection.

Why did one video produce an error row?

Inspect its error field and run log. The Actor already retries temporary timeouts, 429 responses, and 5xx errors; persistent errors may indicate a source outage or malformed input.

Why did the entire run fail?

The Actor fails only when input is invalid or every source request fails. This prevents automated monitoring from interpreting a SponsorBlock outage as a valid empty result.

Why are durations fractional?

SponsorBlock timestamps use decimal seconds. Keep the numeric values for accurate editing, or round them in your downstream workflow.

FAQ

How fast is the Actor?

It uses direct concurrent HTTP requests, so small batches normally finish in seconds. Actual time depends on batch size, retries, and SponsorBlock response speed.

Do I need a YouTube API key?

No. The Actor accepts video IDs directly and does not consume Google API quota.

Does it use the official SponsorBlock API?

It uses SponsorBlock's public skipSegments endpoint and preserves the exact request URL in output records.

Can I process YouTube Shorts?

Yes. Shorts URLs are normalized to their 11-character video IDs before SponsorBlock lookup.

Can I request only sponsor segments?

Yes. Set categories to ["sponsor"].

Are videos with no segments charged?

No segment event is charged when the API returns no matching segments. The run start event still applies.

Are per-video error rows charged as segments?

No. Only unique emitted segment records trigger the segment event.

How is this different from a generic YouTube scraper?

Generic scrapers return video metadata, channels, search results, or comments. This Actor returns crowdsourced skip ranges and moderation context for known videos.

Can I use the data to remove ads from transcripts?

Yes. Join by videoId and exclude transcript entries whose times overlap the selected ranges. Review votes and lock state according to your quality threshold.

Other YouTube scrapers and tools

Combine this Actor with other Automation Labs tools:

• YouTube Scraper — video and channel metadata.
• YouTube Transcript Scraper — caption and transcript text.
• YouTube Channel Scraper — channel profiles and video lists.
• YouTube Comments Scraper — comments and replies.
• YouTube Playlist Scraper — playlist video datasets.
• YouTube Shorts Scraper — Shorts discovery and metadata.
• YouTube Region Restriction Checker — video availability by country.

A common workflow is: discover videos with a YouTube scraper, extract captions, then use this Actor's segment ranges to remove sponsors and other non-content spans.

Data freshness and reproducibility

Every row includes fetchedAt, and every segment includes its SponsorBlock uuid. Store both when building snapshots. The UUID helps identify the same public submission across repeated runs, while votes and lock state show how moderation changed.

For reproducible research:

1. Save the exact input and selected categories.
2. Archive the dataset instead of overwriting it.
3. Compare rows by videoId + uuid.
4. Treat new UUIDs as additions and missing UUIDs as removals.
5. Compare vote and lock fields for moderation changes.

Responsible use of community data

SponsorBlock records are community contributions, not editorial certifications. Use conservative quality thresholds for automated publishing or research claims. Preserve provenance fields, describe your category selection, and avoid presenting “no segments” as proof that a video has no advertising.

For editing and personal productivity, a lower threshold may be acceptable. For public research, consider reviewing disputed or low-vote rows manually.