# Twitch Clips Scraper (`adventurous_vanity/twitch-clips-scraper`) Actor

Top Twitch clips per streamer — views, duration, game, curator, VOD offset, thumbnails. No Twitch API key or login required.

- **URL**: https://apify.com/adventurous\_vanity/twitch-clips-scraper.md
- **Developed by:** [Robert Gregory](https://apify.com/adventurous_vanity) (community)
- **Categories:** Videos, Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Twitch Clips Scraper — top clips by streamer, no API key

Scrape the **top Twitch clips** for any list of streamers and get clean, structured data back — clip titles, view counts, duration, game, who clipped it, follower counts, and the exact VOD timestamp each clip came from. **No Twitch API key, no OAuth app, and no login required.** Give it channel names, pick a time window, and press Run.

Whether you run a clip-compilation channel, feed a short-form video pipeline, scout esports talent, or monitor a game's coverage, this Twitch clip scraper turns Twitch's own view-ranked clips into a dataset you can filter, sort, and export to JSON, CSV, or Excel.

### Quick start

1. Add one or more streamers to the **Streamers** field — plain logins (`caseoh_`) or full channel URLs (`https://www.twitch.tv/jasontheween`), mixed freely.
2. Pick a **time window** (last 24 hours, 7 days, 30 days, or all time) and a **sort** (most viewed, most recent, or trending).
3. *(Optional)* set duration and minimum-view filters so you only get clips you can actually use.
4. Click **Run**. Results stream into the dataset and can be exported to JSON, CSV, or Excel, or pulled via the Apify API.

The default input works out of the box — press Run without changing anything to see example clips for two popular streamers.

### What you get per clip

| Field | Example | Notes |
|---|---|---|
| `title` | `"Bless You Case!😂"` | Clip title as shown on Twitch |
| `url` | `https://www.twitch.tv/caseoh_/clip/…` | Direct, shareable clip link |
| `viewCount` | `5293` | Twitch view count — the ranking signal |
| `durationSeconds` | `14` | Clip length; filter to match Shorts/TikTok limits |
| `createdAt` | `2026-06-27T04:44:16Z` | ISO timestamp |
| `game` | `"Just Chatting"` | Category the clip was captured in |
| `curator` | `"XxGamer_K1ngxX"` | Who created the clip |
| `broadcaster` | login, display name, **follower count** | Channel context in every row |
| `sourceVodId` + `vodOffsetSeconds` | `2806286803` @ `9591` | Where in the stream the clip happened |
| `thumbnailUrl`, `language`, `isFeatured` | — | Landscape thumbnail + metadata |

### Input options

- **streamers** *(required)* — Twitch logins or channel URLs, one per entry.
- **period** — `24h`, `7d`, `30d`, or `all`. Controls how far back clips are pulled.
- **sort** — `views` (most viewed), `recent` (newest), or `trending`.
- **maxClipsPerStreamer** — 1 to 100. Twitch serves up to 100 clips per streamer per window for anonymous access.
- **minDurationSeconds** / **maxDurationSeconds** — keep clips within a length range (great for short-form pipelines).
- **minViews** — skip clips below a view threshold so you only pay for high-signal results.

#### Example input

```json
{
  "streamers": ["caseoh_", "https://www.twitch.tv/jasontheween"],
  "period": "7d",
  "sort": "views",
  "maxClipsPerStreamer": 25,
  "minDurationSeconds": 5,
  "maxDurationSeconds": 60,
  "minViews": 100
}
````

### Who uses this Twitch clip scraper

#### Clip channels and video editors

Find the highest-performing moments per streamer per day without scrubbing hours of VODs. Sort by views, filter to the length you need, and pull the direct clip URL plus the source VOD timestamp so you can cut extra context around the moment.

#### Short-form / Shorts / Reels / TikTok pipelines

Feed automation with pre-ranked source clips. The duration filters map directly to platform limits (e.g. keep clips under 60 seconds), and every row includes a thumbnail and view count so you can prioritize what to publish first.

#### Esports and talent scouting

Track which streamers and which games are producing viral moments. Follower counts and per-game tagging in every row make it easy to spot rising channels and trending categories.

#### Brand, game, and community monitoring

Watch the clips coming out of the streamers who play your game, or monitor a community's biggest moments over any time window. Run it on a schedule to build a daily leaderboard of top clips.

### Why choose this Twitch scraper

- **No Twitch API key or login** — no developer account, tokens, or rate-limit management on your side.
- **Ranked at the source** — uses Twitch's own view-count and trending ordering, not a guess applied after the fact.
- **VOD coordinates included** — `sourceVodId` + `vodOffsetSeconds` let you locate and cut the full context around any clip.
- **Built-in quality filters** — duration and view thresholds are applied before results are returned.
- **Clean, predictable output** — one flat dataset item per clip, ready for JSON/CSV/Excel export or the Apify API.

### How to export the data

After a run, open the **Dataset** tab and export to JSON, CSV, Excel, HTML, or RSS, or fetch results programmatically through the Apify API and client libraries. You can also schedule runs and connect the output to Make, Zapier, or your own webhook.

### Frequently asked questions

#### Do I need a Twitch account or API key?

No. This scraper reads Twitch's public clip data, so there is nothing to configure — no API key, no OAuth app, no login.

#### How many clips can I get per streamer?

Up to 100 clips per streamer per time window. Twitch limits anonymous access beyond one page of results, so for deeper history run several narrower windows (for example, pull the top clips every day rather than one big all-time run).

#### Can I scrape multiple streamers at once?

Yes. Add as many logins or channel URLs as you like to the **streamers** field and each is scraped in turn.

#### Can I filter by clip length or views?

Yes. Use `minDurationSeconds`, `maxDurationSeconds`, and `minViews`. Filters are applied before results are returned, so you only get — and only pay for — clips that match.

#### What time windows are supported?

Last 24 hours, last 7 days, last 30 days, and all time, via the `period` option.

#### Does it return the original stream location of a clip?

Yes. Each clip includes `sourceVodId` and `vodOffsetSeconds`, so you can jump to the exact moment in the broadcast the clip was taken from (when the VOD is still available).

#### How do I run it on a schedule?

Use Apify Schedules to run the actor hourly, daily, or on any cron expression, then export or forward the dataset automatically.

#### Is scraping Twitch clips allowed?

This actor collects publicly available clip metadata. You are responsible for using the data in line with Twitch's Terms of Service and applicable law. Do not use scraped content in ways that infringe creators' rights.

### Local development

```bash
npm install
npm test          # unit tests (mocked network)
npm run smoke     # live hit against real Twitch
apify run         # full actor run with .actor/INPUT
```

# Actor input Schema

## `streamers` (type: `array`):

Twitch channel logins or channel URLs (e.g. `caseoh_` or `https://www.twitch.tv/caseoh_`). One entry per streamer.

## `period` (type: `string`):

How far back to look for clips.

## `sort` (type: `string`):

Clip ordering within the window.

## `maxClipsPerStreamer` (type: `integer`):

Up to 100 clips per streamer per run (Twitch page limit for anonymous access).

## `minDurationSeconds` (type: `integer`):

Skip clips shorter than this. 0 = no minimum.

## `maxDurationSeconds` (type: `integer`):

Skip clips longer than this. 0 = no maximum.

## `minViews` (type: `integer`):

Skip clips with fewer views than this. 0 = no minimum.

## Actor input object example

```json
{
  "streamers": [
    "caseoh_",
    "jasontheween"
  ],
  "period": "7d",
  "sort": "views",
  "maxClipsPerStreamer": 25,
  "minDurationSeconds": 0,
  "maxDurationSeconds": 0,
  "minViews": 0
}
```

# Actor output Schema

## `clips` (type: `string`):

One item per scraped clip — title, views, duration, game, curator, broadcaster (with follower count), source VOD id + offset, thumbnail.

## `runSummary` (type: `string`):

Counts of streamers requested/failed and clips pushed for this run.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "streamers": [
        "caseoh_",
        "jasontheween"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("adventurous_vanity/twitch-clips-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "streamers": [
        "caseoh_",
        "jasontheween",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("adventurous_vanity/twitch-clips-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "streamers": [
    "caseoh_",
    "jasontheween"
  ]
}' |
apify call adventurous_vanity/twitch-clips-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=adventurous_vanity/twitch-clips-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitch Clips Scraper",
        "description": "Top Twitch clips per streamer — views, duration, game, curator, VOD offset, thumbnails. No Twitch API key or login required.",
        "version": "1.0",
        "x-build-id": "ORBUUW77pj4kdE1ja"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/adventurous_vanity~twitch-clips-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-adventurous_vanity-twitch-clips-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/adventurous_vanity~twitch-clips-scraper/runs": {
            "post": {
                "operationId": "runs-sync-adventurous_vanity-twitch-clips-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/adventurous_vanity~twitch-clips-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-adventurous_vanity-twitch-clips-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "streamers"
                ],
                "properties": {
                    "streamers": {
                        "title": "Streamers",
                        "type": "array",
                        "description": "Twitch channel logins or channel URLs (e.g. `caseoh_` or `https://www.twitch.tv/caseoh_`). One entry per streamer.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "period": {
                        "title": "Time window",
                        "enum": [
                            "24h",
                            "7d",
                            "30d",
                            "all"
                        ],
                        "type": "string",
                        "description": "How far back to look for clips.",
                        "default": "7d"
                    },
                    "sort": {
                        "title": "Sort",
                        "enum": [
                            "views",
                            "recent",
                            "trending"
                        ],
                        "type": "string",
                        "description": "Clip ordering within the window.",
                        "default": "views"
                    },
                    "maxClipsPerStreamer": {
                        "title": "Max clips per streamer",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Up to 100 clips per streamer per run (Twitch page limit for anonymous access).",
                        "default": 25
                    },
                    "minDurationSeconds": {
                        "title": "Min clip duration (s)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip clips shorter than this. 0 = no minimum.",
                        "default": 0
                    },
                    "maxDurationSeconds": {
                        "title": "Max clip duration (s)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip clips longer than this. 0 = no maximum.",
                        "default": 0
                    },
                    "minViews": {
                        "title": "Min view count",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip clips with fewer views than this. 0 = no minimum.",
                        "default": 0
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```