# Scrapier — YouTube API > Scrapier endpoints for YouTube: YouTube Channel Info, YouTube Channel Live/Streams, YouTube Channel Video Scraper, YouTube Comment Replies and 13 more. Base URL: https://api.scrapier.io/api/v2 · Auth: header `X-API-Key: ` · Synchronous: HTTP 200 returns {"success": true, "data": {...}} · Paginate by sending data.next_cursor back as `cursor` until it is null · Paths keep the trailing slash. Live parameter source (no auth): https://api.scrapier.io/api/v2/endpoints · Docs: https://docs.scrapier.io/api-reference/youtube.md ## GET /youtube-channel-info/ YouTube Channel Info: Structured YouTube data: send `urls`. Single lookup, 1 credit per successful call. Cost: 1 credit per successful call · Pagination: single lookup · Results: data.items Parameters: - urls (required, string, example MrBeast): YouTube channel URL (/@handle, /channel/UC…, /c/, /user/), @handle, name or UC id. Returns one channel record (about + first page of videos/shorts/live/posts). - cursor (optional, string): Pagination cursor returned in the previous response's `next_cursor`. Pass it back unchanged to fetch the next page. When `next_cursor` is null, you have reached the last page. - raw_data (optional, boolean, default false): When true, the response carries the full raw upstream payload(s) the scraper received (GraphQL / JSON API bodies, HTML, embedded JSON-LD -- exactly as the platform returned them) under `raw_responses`, in place of the formatted items. When false (default) you get the formatted output. Pagination (`cursor` / `next_cursor`) works the same in both modes. Example: curl "https://api.scrapier.io/api/v2/youtube-channel-info/?urls=MrBeast" -H "X-API-Key: YOUR_API_KEY" Docs: https://docs.scrapier.io/api-reference/youtube/youtube-channel-info.md ## GET /youtube-channel-live/ YouTube Channel Live/Streams: Structured YouTube data: send `channels`. Cursor-paginated, 1 credit per successful call. Cost: 1 credit per successful call · Pagination: cursor · Results: data.lives Parameters: - channels (required, string, example ishowspeed): YouTube @handle / channel URL / channelId. Required first call. - cursor (optional, string): Pagination cursor returned in the previous response's `next_cursor`. Pass it back unchanged to fetch the next page. When `next_cursor` is null, you have reached the last page. - raw_data (optional, boolean, default false): When true, the response carries the full raw upstream payload(s) the scraper received (GraphQL / JSON API bodies, HTML, embedded JSON-LD -- exactly as the platform returned them) under `raw_responses`, in place of the formatted items. When false (default) you get the formatted output. Pagination (`cursor` / `next_cursor`) works the same in both modes. Example: curl "https://api.scrapier.io/api/v2/youtube-channel-live/?channels=ishowspeed" -H "X-API-Key: YOUR_API_KEY" Docs: https://docs.scrapier.io/api-reference/youtube/youtube-channel-live.md ## GET /youtube-channel-video-scraper/ YouTube Channel Video Scraper: Structured YouTube data: send `youtube_channels`. Cursor-paginated, 1 credit per successful call. Cost: 1 credit per successful call · Pagination: cursor · Results: data.items Parameters: - youtube_channels (required, string, example @mrbeast): YouTube @handle / channel URL / channel id. Required on the first call. - cursor (optional, string): Pagination cursor returned in the previous response's `next_cursor`. Pass it back unchanged to fetch the next page. When `next_cursor` is null, you have reached the last page. - scrape_type (optional, string, one of: videos|shorts|both, default videos, locked in cursor): videos | shorts | both (videos paged first, then shorts). - end_date (optional, string, locked in cursor): YYYY-MM-DD, inclusive start of kept range (videos only). - raw_data (optional, boolean, default false): When true, the response carries the full raw upstream payload(s) the scraper received (GraphQL / JSON API bodies, HTML, embedded JSON-LD -- exactly as the platform returned them) under `raw_responses`, in place of the formatted items. When false (default) you get the formatted output. Pagination (`cursor` / `next_cursor`) works the same in both modes. Example: curl "https://api.scrapier.io/api/v2/youtube-channel-video-scraper/?youtube_channels=%40mrbeast" -H "X-API-Key: YOUR_API_KEY" Docs: https://docs.scrapier.io/api-reference/youtube/youtube-channel-video-scraper.md ## GET /youtube-comment-replies/ YouTube Comment Replies: Structured YouTube data: send `continuation_tokens`. Cursor-paginated, 1 credit per successful call. Cost: 1 credit per successful call · Pagination: cursor · Results: data.thread · Needs your own session cookie: continuation_tokens Parameters: - continuation_tokens (required, string): Base64url reply continuation token from a "Show more replies" call -> ONE thread record (comments nested inside). Single lookup: next_cursor is always null. A truncated thread (hit max_items / an absolute page cap / a transport error) reports next_continuation_token on the row — resubmit it as a fresh continuation_tokens value to keep walking. - cursor (optional, string): Pagination cursor returned in the previous response's `next_cursor`. Pass it back unchanged to fetch the next page. When `next_cursor` is null, you have reached the last page. - max_items (optional, integer, default 0, locked in cursor): Replies per thread. 0 or omitted = walk to exhaustion. - language (optional, string, default en, locked in cursor): innertube hl. - region (optional, string, default US, locked in cursor): innertube gl. - raw_data (optional, boolean, default false): When true, the response carries the full raw upstream payload(s) the scraper received (GraphQL / JSON API bodies, HTML, embedded JSON-LD -- exactly as the platform returned them) under `raw_responses`, in place of the formatted items. When false (default) you get the formatted output. Pagination (`cursor` / `next_cursor`) works the same in both modes. Example: curl "https://api.scrapier.io/api/v2/youtube-comment-replies/?continuation_tokens=YOUR_CONTINUATION_TOKENS" -H "X-API-Key: YOUR_API_KEY" Docs: https://docs.scrapier.io/api-reference/youtube/youtube-comment-replies.md ## GET /youtube-comments-scraper/ YouTube Comments: Structured YouTube data: send `urls`. Cursor-paginated, 1 credit per successful call. Cost: 1 credit per successful call · Pagination: cursor · Results: data.comments Parameters: - urls (required, string, example https://www.youtube.com/watch?v=uKv3mi2t2KE): YouTube watch URL / youtu.be / bare 11-char id. Required on the first call. - cursor (optional, string): Pagination cursor returned in the previous response's `next_cursor`. Pass it back unchanged to fetch the next page. When `next_cursor` is null, you have reached the last page. - sort_by (optional, string, one of: top|newest, default top): Comment sort order. Locked into the cursor. - language (optional, string, default en): innertube hl. Locked into the cursor. - region (optional, string, default US): innertube gl. Locked into the cursor. - raw_data (optional, boolean, default false): When true, the response carries the full raw upstream payload(s) the scraper received (GraphQL / JSON API bodies, HTML, embedded JSON-LD -- exactly as the platform returned them) under `raw_responses`, in place of the formatted items. When false (default) you get the formatted output. Pagination (`cursor` / `next_cursor`) works the same in both modes. Example: curl "https://api.scrapier.io/api/v2/youtube-comments-scraper/?urls=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DuKv3mi2t2KE" -H "X-API-Key: YOUR_API_KEY" Docs: https://docs.scrapier.io/api-reference/youtube/youtube-comments-scraper.md ## GET /youtube-community-posts/ YouTube Community Posts: Structured YouTube data: send `urls`. Cursor-paginated, 1 credit per successful call. Cost: 1 credit per successful call · Pagination: cursor · Results: data.posts Parameters: - urls (required, string, example https://www.youtube.com/@MrBeast): YouTube channel URL, @username, or channel ID. Required on first call; ignored when `cursor` is supplied. - cursor (optional, string): Pagination cursor returned in the previous response's `next_cursor`. Pass it back unchanged to fetch the next page. When `next_cursor` is null, you have reached the last page. - raw_data (optional, boolean, default false): When true, the response carries the full raw upstream payload(s) the scraper received (GraphQL / JSON API bodies, HTML, embedded JSON-LD -- exactly as the platform returned them) under `raw_responses`, in place of the formatted items. When false (default) you get the formatted output. Pagination (`cursor` / `next_cursor`) works the same in both modes. Example: curl "https://api.scrapier.io/api/v2/youtube-community-posts/?urls=https%3A%2F%2Fwww.youtube.com%2F%40MrBeast" -H "X-API-Key: YOUR_API_KEY" Docs: https://docs.scrapier.io/api-reference/youtube/youtube-community-posts.md ## GET /youtube-hashtag-videos/ YouTube Hashtag Videos: Structured YouTube data: send `hashtags`. Cursor-paginated, 1 credit per successful call. Cost: 1 credit per successful call · Pagination: cursor · Results: data.videos · Long-running (client timeout 210 s or more) Parameters: - hashtags (required, string, example chatgpt): Hashtag (without #). Required on first call; ignored when `cursor` is supplied. - cursor (optional, string): Pagination cursor returned in the previous response's `next_cursor`. Pass it back unchanged to fetch the next page. When `next_cursor` is null, you have reached the last page. - scrape_shorts_only (optional, boolean, default false): Only scrape Shorts. Locked into the cursor. - scrape_videos_only (optional, boolean, default false): Only scrape regular videos. Locked into the cursor. - raw_data (optional, boolean, default false): When true, the response carries the full raw upstream payload(s) the scraper received (GraphQL / JSON API bodies, HTML, embedded JSON-LD -- exactly as the platform returned them) under `raw_responses`, in place of the formatted items. When false (default) you get the formatted output. Pagination (`cursor` / `next_cursor`) works the same in both modes. Example: curl "https://api.scrapier.io/api/v2/youtube-hashtag-videos/?hashtags=chatgpt" -H "X-API-Key: YOUR_API_KEY" Docs: https://docs.scrapier.io/api-reference/youtube/youtube-hashtag-videos.md ## GET /youtube-playlist/ YouTube Playlist Videos: Structured YouTube data: send `urls`. Cursor-paginated, 1 credit per successful call. Cost: 1 credit per successful call · Pagination: cursor · Results: data.videos Parameters: - urls (required, string, example https://www.youtube.com/playlist?list=PLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw): YouTube playlist URL, watch?v=..&list=.. URL or bare playlist ID (PL…, UU…). Required on first call; ignored when `cursor` is supplied. Each page returns up to ~100 videos (one YouTube page). - cursor (optional, string): Pagination cursor returned in the previous response's `next_cursor`. Pass it back unchanged to fetch the next page. When `next_cursor` is null, you have reached the last page. - raw_data (optional, boolean, default false): When true, the response carries the full raw upstream payload(s) the scraper received (GraphQL / JSON API bodies, HTML, embedded JSON-LD -- exactly as the platform returned them) under `raw_responses`, in place of the formatted items. When false (default) you get the formatted output. Pagination (`cursor` / `next_cursor`) works the same in both modes. Example: curl "https://api.scrapier.io/api/v2/youtube-playlist/?urls=https%3A%2F%2Fwww.youtube.com%2Fplaylist%3Flist%3DPLObrtcm1Kw6Odq5ks2R3bbJUGVVwQF-vw" -H "X-API-Key: YOUR_API_KEY" Docs: https://docs.scrapier.io/api-reference/youtube/youtube-playlist.md ## GET /youtube-search-full/ YouTube Search: Structured YouTube data: send `queries`. Cursor-paginated, 2 credits per successful call. Cost: 2 credits per successful call · Pagination: cursor · Results: data.items Parameters: - queries (required, string, example fitness): Search term. Required on first call; ignored when `cursor` is supplied. - cursor (optional, string): Pagination cursor returned in the previous response's `next_cursor`. Pass it back unchanged to fetch the next page. When `next_cursor` is null, you have reached the last page. - max_results_video (optional, integer, default 20): Max regular videos returned per page (0 = exclude). One page = one native YouTube search page (~20 videos). Locked into the cursor. - max_results_shorts (optional, integer, default 10): Max shorts returned per page (0 = exclude; videos=0 + shorts>0 switches to YouTube's Shorts-only search). Locked into the cursor. - max_results_streams (optional, integer, default 0): Max currently-live streams per page (0 = exclude). Locked into the cursor. - sort_by (optional, string, default relevance): Sort order: relevance | upload_date | view_count | rating (applied server-side by YouTube) - upload_date (optional, string): Upload-date filter: hour | today | week | month | year (empty = any time) - duration (optional, string): Duration filter: short (<4 min) | medium (4-20 min) | long (>20 min) (empty = any) - country (optional, string, default US): Result region (2-letter country code, YouTube `gl`) - language (optional, string, default en): Interface language for result texts (YouTube `hl`, e.g. en, es, de) - download_subtitles (optional, boolean, default false): Fetch the transcript + caption language list for each video (true/false). Best-effort within the per-call time budget; rows always carry details first - subtitles_language (optional, string, default en): Preferred transcript language code (e.g. "en", "es", "fr"); falls back to an auto-translation or the original track - subtitles_format (optional, string, default srt): Transcript format: srt | text | timestamp (JSON list of {start, duration, text}) - fetch_metadata (optional, boolean, default true): Enrich each video with exact likes, full description, tags, category, publish date, subscribers and comment count (true/false) - fetch_shorts_stats (optional, boolean, default false): Fetch subscribers + comment count for shorts too (default false: skips an extra ~22KB upstream request per short; set true to include them; videos always get them when fetch_metadata is true) - isHD (optional, boolean, default false): Filter: HD only (server-side YouTube filter) - is4K (optional, boolean, default false): Filter: 4K only (server-side YouTube filter) - isLive (optional, boolean, default false): Filter: live streams only (server-side; enables streams automatically) - hasSubtitles (optional, boolean, default false): Filter: videos with subtitles/CC only (server-side YouTube filter) - raw_data (optional, boolean, default false): When true, the response carries the full raw upstream payload(s) the scraper received (GraphQL / JSON API bodies, HTML, embedded JSON-LD -- exactly as the platform returned them) under `raw_responses`, in place of the formatted items. When false (default) you get the formatted output. Pagination (`cursor` / `next_cursor`) works the same in both modes. Example: curl "https://api.scrapier.io/api/v2/youtube-search-full/?queries=fitness" -H "X-API-Key: YOUR_API_KEY" Docs: https://docs.scrapier.io/api-reference/youtube/youtube-search-full.md ## GET /youtube-search-suggestions/ YouTube Search Suggestions: Structured YouTube data: send `queries`. Cursor-paginated, 1 credit per successful call. Cost: 1 credit per successful call · Pagination: cursor · Results: data.suggestions Parameters: - queries (required, string, example lofi): Search term (<= 100 chars). Required on first call; ignored when `cursor` is supplied. - cursor (optional, string): Pagination cursor returned in the previous response's `next_cursor`. Pass it back unchanged to fetch the next page. When `next_cursor` is null, you have reached the last page. - country (optional, string, default US): ISO 3166-1 alpha-2 country code (gl). Locked into the cursor. - language (optional, string): UI language (hl) e.g. en, pt-BR. Blank = picked from country. Locked into the cursor. - enrich_entities (optional, boolean, default true): Attach entity/channel cards to suggestions. Locked into the cursor. - expansion_alphabet (optional, string): Characters appended during expansion. Blank = a-z0-9. Locked into the cursor. - raw_data (optional, boolean, default false): When true, the response carries the full raw upstream payload(s) the scraper received (GraphQL / JSON API bodies, HTML, embedded JSON-LD -- exactly as the platform returned them) under `raw_responses`, in place of the formatted items. When false (default) you get the formatted output. Pagination (`cursor` / `next_cursor`) works the same in both modes. Example: curl "https://api.scrapier.io/api/v2/youtube-search-suggestions/?queries=lofi" -H "X-API-Key: YOUR_API_KEY" Docs: https://docs.scrapier.io/api-reference/youtube/youtube-search-suggestions.md ## GET /youtube-shorts/ YouTube Shorts: Structured YouTube data: every input is optional. Cursor-paginated, 1 credit per successful call. Cost: 1 credit per successful call · Pagination: cursor · Results: data.shorts Parameters: - mode (optional, string, one of: single|video|multi|channel, default single): single / video (one Short via input_value) or multi / channel (a channel Shorts tab, 25 per page). When `channels` is set it always wins. - input_value (optional, string, default dQw4w9WgXcQ): Short URL or 11-char video ID (single mode). A channel URL/@handle here is treated as channel mode. - channels (optional, string): Channel @handle, URL (/@x, /channel/UC..., /c/x, /user/x, .../shorts) or UC id. Returns its Shorts newest-first, 25 per call; follow next_cursor. - cursor (optional, string): Pagination cursor returned in the previous response's `next_cursor`. Pass it back unchanged to fetch the next page. When `next_cursor` is null, you have reached the last page. - raw_data (optional, boolean, default false): When true, the response carries the full raw upstream payload(s) the scraper received (GraphQL / JSON API bodies, HTML, embedded JSON-LD -- exactly as the platform returned them) under `raw_responses`, in place of the formatted items. When false (default) you get the formatted output. Pagination (`cursor` / `next_cursor`) works the same in both modes. No parameter is marked required; send at least one input (see descriptions). Example: curl "https://api.scrapier.io/api/v2/youtube-shorts/" -H "X-API-Key: YOUR_API_KEY" Docs: https://docs.scrapier.io/api-reference/youtube/youtube-shorts.md ## GET /youtube-subtitles/ YouTube Subtitle / Transcript: Structured YouTube data: send `urls`. Cursor-paginated, 1 credit per successful call. Cost: 1 credit per successful call · Pagination: cursor · Results: data.transcripts Parameters: - urls (required, string, example https://www.youtube.com/watch?v=dQw4w9WgXcQ): YouTube video URL (watch, youtu.be, shorts, embed, live) or bare 11-char ID. Required on first call; ignored when `cursor` is supplied. No captions / unavailable -> 404. - cursor (optional, string): Pagination cursor returned in the previous response's `next_cursor`. Pass it back unchanged to fetch the next page. When `next_cursor` is null, you have reached the last page. - include_english_ag (optional, boolean, default true): Include auto-generated English subtitles. Locked into the cursor. - include_non_english (optional, boolean, default false): Include non-English subtitles. Locked into the cursor. - output_format (optional, string, one of: text|timestamp, default text): text or timestamp. Locked into the cursor. - language (optional, string): Optional language code (e.g. en, es, pt-BR): return only that language (manual preferred over auto-generated). If missing, the original track is returned with translation_error set. Locked into the cursor. - raw_data (optional, boolean, default false): When true, the response carries the full raw upstream payload(s) the scraper received (GraphQL / JSON API bodies, HTML, embedded JSON-LD -- exactly as the platform returned them) under `raw_responses`, in place of the formatted items. When false (default) you get the formatted output. Pagination (`cursor` / `next_cursor`) works the same in both modes. Example: curl "https://api.scrapier.io/api/v2/youtube-subtitles/?urls=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DdQw4w9WgXcQ" -H "X-API-Key: YOUR_API_KEY" Docs: https://docs.scrapier.io/api-reference/youtube/youtube-subtitles.md ## GET /youtube-trending/ YouTube Trending: Structured YouTube data: send `country_code`. Cursor-paginated, 1 credit per successful call. Cost: 1 credit per successful call · Pagination: cursor · Results: data.videos Parameters: - country_code (required, string, example US): Two-letter ISO country code (e.g., US, BD, IN, GB). Required on first call; ignored when `cursor` is supplied. - cursor (optional, string): Pagination cursor returned in the previous response's `next_cursor`. Pass it back unchanged to fetch the next page. When `next_cursor` is null, you have reached the last page. - content_type (optional, string, default music): Trending list: music (trending music videos, 30; regions without that chart fall back to daily top music videos) | movies (trending trailers, 30) | top_music_videos (100) | gaming | sports | news | live | learning | fashion. Invalid value -> 400. Locked into the cursor. - raw_data (optional, boolean, default false): When true, the response carries the full raw upstream payload(s) the scraper received (GraphQL / JSON API bodies, HTML, embedded JSON-LD -- exactly as the platform returned them) under `raw_responses`, in place of the formatted items. When false (default) you get the formatted output. Pagination (`cursor` / `next_cursor`) works the same in both modes. Example: curl "https://api.scrapier.io/api/v2/youtube-trending/?country_code=US" -H "X-API-Key: YOUR_API_KEY" Docs: https://docs.scrapier.io/api-reference/youtube/youtube-trending.md ## GET /youtube-trending-shorts/ YouTube Trending Shorts: Structured YouTube data: every input is optional. Cursor-paginated, 1 credit per successful call. Cost: 1 credit per successful call · Pagination: cursor · Results: data.items Parameters: - hashtags (optional, string, default trendingshorts): Hashtag Shorts feed to read (no '#'; letters/digits/underscore, any script). Default 'trendingshorts'. One feed per call (15 hydrated Shorts/page); ignored when `cursor` is supplied. Unknown hashtag -> 404. extra.hydrated=false marks a row served from feed data because its detail fetch missed the 22s deadline. - cursor (optional, string): Pagination cursor returned in the previous response's `next_cursor`. Pass it back unchanged to fetch the next page. When `next_cursor` is null, you have reached the last page. - country (optional, string, default US, locked in cursor): ISO 3166-1 alpha-2 region (YouTube gl); a country YouTube does not offer -> 400. - language (optional, string, default en, locked in cursor): Interface language (YouTube hl). - sort_by (optional, string, one of: default|views|likes|comments|engagement|newest|oldest|shortest|longest, default default, locked in cursor): Local ordering applied per page. - include (optional, string, locked in cursor): Comma list of extra joins: channel|captions|download|sound|comments (adds comment count, heavier). - raw_data (optional, boolean, default false): When true, the response carries the full raw upstream payload(s) the scraper received (GraphQL / JSON API bodies, HTML, embedded JSON-LD -- exactly as the platform returned them) under `raw_responses`, in place of the formatted items. When false (default) you get the formatted output. Pagination (`cursor` / `next_cursor`) works the same in both modes. No parameter is marked required; send at least one input (see descriptions). Example: curl "https://api.scrapier.io/api/v2/youtube-trending-shorts/" -H "X-API-Key: YOUR_API_KEY" Docs: https://docs.scrapier.io/api-reference/youtube/youtube-trending-shorts.md ## GET /youtube-video-details/ YouTube Video Details: Structured YouTube data: send `urls`. Cursor-paginated, 1 credit per successful call. Cost: 1 credit per successful call · Pagination: cursor · Results: data.videos Parameters: - urls (required, string, example https://www.youtube.com/watch?v=dQw4w9WgXcQ): YouTube video URL or ID. Required on first call; ignored when `cursor` is supplied. - cursor (optional, string): Pagination cursor returned in the previous response's `next_cursor`. Pass it back unchanged to fetch the next page. When `next_cursor` is null, you have reached the last page. - raw_data (optional, boolean, default false): When true, the response carries the full raw upstream payload(s) the scraper received (GraphQL / JSON API bodies, HTML, embedded JSON-LD -- exactly as the platform returned them) under `raw_responses`, in place of the formatted items. When false (default) you get the formatted output. Pagination (`cursor` / `next_cursor`) works the same in both modes. Example: curl "https://api.scrapier.io/api/v2/youtube-video-details/?urls=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DdQw4w9WgXcQ" -H "X-API-Key: YOUR_API_KEY" Docs: https://docs.scrapier.io/api-reference/youtube/youtube-video-details.md ## GET /youtube-video-sponsors/ YouTube Video Sponsors: Structured YouTube data: send `video_ids`. Cursor-paginated, 1 credit per successful call. Cost: 1 credit per successful call · Pagination: cursor · Results: data.result Parameters: - video_ids (required, string, example https://www.youtube.com/watch?v=K8AMhj-ImMI): YouTube watch / youtu.be / shorts / embed URL or bare 11-char id. One video per call. Required first call. - cursor (optional, string): Pagination cursor returned in the previous response's `next_cursor`. Pass it back unchanged to fetch the next page. When `next_cursor` is null, you have reached the last page. - language (optional, string, default en, locked in cursor): 2-letter transcript language code. - include_transcript (optional, boolean, default false, locked in cursor): Also return the full transcript segments. - resolve_short_links (optional, boolean, default true, locked in cursor): Follow bit.ly / amzn.to style links. - raw_data (optional, boolean, default false): When true, the response carries the full raw upstream payload(s) the scraper received (GraphQL / JSON API bodies, HTML, embedded JSON-LD -- exactly as the platform returned them) under `raw_responses`, in place of the formatted items. When false (default) you get the formatted output. Pagination (`cursor` / `next_cursor`) works the same in both modes. Example: curl "https://api.scrapier.io/api/v2/youtube-video-sponsors/?video_ids=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DK8AMhj-ImMI" -H "X-API-Key: YOUR_API_KEY" Docs: https://docs.scrapier.io/api-reference/youtube/youtube-video-sponsors.md ## GET /youtube-video-thumbnail/ YouTube Video Thumbnail: Structured YouTube data: every input is optional. Cursor-paginated, 1 credit per successful call. Cost: 1 credit per successful call · Pagination: cursor · Results: data.videos Parameters: - urls (optional, string, default https://www.youtube.com/watch?v=dQw4w9WgXcQ): VIDEO MODE: watch / youtu.be / shorts / embed URL or bare 11-char id. Single lookup (next_cursor always null, result under `video`). Required unless channel_url is given. - channel_url (optional, string): CHANNEL MODE: @handle, /channel/UC…, /c/… or /user/… URL. ~10 videos per page (newest first) under `videos`, paged through YouTube's own continuation token. Required first call; ignored when `cursor` is supplied. - cursor (optional, string): Pagination cursor returned in the previous response's `next_cursor`. Pass it back unchanged to fetch the next page. When `next_cursor` is null, you have reached the last page. - channel_tab (optional, string, one of: videos|shorts|streams, default videos, locked in cursor): Channel mode: which listing to walk. - start_date (optional, string, locked in cursor): Channel mode: only videos uploaded on/after (YYYY-MM-DD or ISO 8601). - end_date (optional, string, locked in cursor): Channel mode: only videos uploaded on/before (YYYY-MM-DD or ISO 8601). - verify_thumbnails (optional, boolean, default true, locked in cursor): Probe every file on i.ytimg.com (real size / bytes / dropped). - include_frames (optional, boolean, default true, locked in cursor): Also return the auto-generated frame thumbnails (frame_items). - raw_data (optional, boolean, default false): When true, the response carries the full raw upstream payload(s) the scraper received (GraphQL / JSON API bodies, HTML, embedded JSON-LD -- exactly as the platform returned them) under `raw_responses`, in place of the formatted items. When false (default) you get the formatted output. Pagination (`cursor` / `next_cursor`) works the same in both modes. No parameter is marked required; send at least one input (see descriptions). Example: curl "https://api.scrapier.io/api/v2/youtube-video-thumbnail/" -H "X-API-Key: YOUR_API_KEY" Docs: https://docs.scrapier.io/api-reference/youtube/youtube-video-thumbnail.md