# Twitch Streamer Leads Scraper: Contacts by Game & Followers (`scrapemint/twitch-streamer-leads`) Actor

Find Twitch streamers by game, search query, or login and filter by follower band: one row per streamer with followers, business email from the bio, social links, partner status, language, and last stream. For influencer campaigns and creator outreach. Keyless, no browser. Pay per streamer.

- **URL**: https://apify.com/scrapemint/twitch-streamer-leads.md
- **Developed by:** [Ken M](https://apify.com/scrapemint) (community)
- **Categories:** Lead generation, Social media
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 Streamer Leads Scraper: Contacts by Game & Followers

Build streamer outreach lists straight from Twitch's public data. Give it games or categories (live streamers), free-text searches (any channel), or specific logins, filter by follower band, and get one JSON row per streamer: follower count, the business email extracted from their bio, social links (YouTube, Instagram, X, TikTok, Discord), partner and affiliate status, language, live viewers, and when they last streamed. Keyless public endpoint, no login, no browser.

Built for influencer marketing agencies, game studios planning launch campaigns, esports orgs scouting talent, sponsors hunting micro influencers, and anyone selling tools or services to streamers.

### What you get

One row per streamer, with:

- `login`, `url`, `displayName`, `followers`
- `businessEmail` (extracted from the bio when present), `description`
- `socialLinks` (title + url for each linked platform)
- `isPartner`, `isAffiliate`, `language`, `liveViewers`
- `accountCreatedAt`, `lastStreamedAt`, `lastGame`
- `matchedCategory` / `matchedQuery`

### Input

- `categories` (exact Twitch category names, e.g. Fortnite, Just Chatting, Music, Art — returns currently live streamers, biggest first)
- `searchQueries` (free text, e.g. music producer, poker coach — also finds offline channels)
- `logins` (direct lookups)
- `minFollowers` / `maxFollowers` (set 5000-50000 to target micro influencers)
- `requireEmail` (only rows with a business email in the bio)
- `maxStreamers` (default 50, up to 1000)
- `dedupe` (skip previously returned streamers; built for scheduled prospecting)

### Example input

```json
{
  "categories": ["Just Chatting", "Music"],
  "minFollowers": 5000,
  "maxFollowers": 100000,
  "requireEmail": true,
  "maxStreamers": 100
}
````

### Example output

```json
{
  "login": "examplestreamer",
  "url": "https://www.twitch.tv/examplestreamer",
  "displayName": "ExampleStreamer",
  "followers": 48210,
  "businessEmail": "biz@examplestreamer.com",
  "socialLinks": [
    { "title": "YouTube", "url": "https://youtube.com/examplestreamer" },
    { "title": "Twitter", "url": "https://twitter.com/examplestreamer" }
  ],
  "isPartner": true,
  "language": "EN",
  "liveViewers": 1874,
  "lastGame": "Just Chatting",
  "matchedCategory": "Just Chatting"
}
```

### Uses

- Influencer campaigns: every live streamer in your game and follower band, with contact info, in one run
- Micro influencer hunting: cap followers at 50k and require an email for a ready outreach list
- Game launches: streamers currently playing competitor titles are your exact audience
- Talent scouting: partner status, account age, and last stream date show who is serious
- Scheduled prospecting with `dedupe` on: only never-seen streamers in your category each run

### Pricing

Pay per streamer row: a higher rate for rows with a business email in the bio, a lower rate for the rest. Turn on `requireEmail` to pay mostly the contact rate for a pure outreach list. Searches that match nothing cost nothing, and the first 2 rows of every run are free.

### Notes

- Data comes from Twitch's public web API, the same one every anonymous visitor's browser calls. Category browsing returns currently live streamers; use `searchQueries` or `logins` to reach offline channels.
- Business emails are extracted from bios, so coverage depends on streamers publishing one (common for creators open to sponsorships).
- Category names must match Twitch exactly (check the category page title on twitch.tv).

# Actor input Schema

## `categories` (type: `array`):

Exact category names as shown on Twitch, e.g. Fortnite, Just Chatting, Music, Art. Returns currently live streamers in each.

## `searchQueries` (type: `array`):

Free-text channel search, e.g. music producer, cooking, poker coach. Also finds offline channels.

## `logins` (type: `array`):

Twitch usernames to look up directly.

## `minFollowers` (type: `integer`):

Only streamers with at least this many followers.

## `maxFollowers` (type: `integer`):

Only streamers with at most this many followers. Set 5000-50000 to target micro influencers.

## `requireEmail` (type: `boolean`):

Skip streamers whose bio contains no email address.

## `maxStreamers` (type: `integer`):

Cap on streamer rows returned. Controls total cost.

## `dedupe` (type: `boolean`):

Remember returned streamers across runs and skip them. Turn on for scheduled prospecting.

## Actor input object example

```json
{
  "categories": [
    "Fortnite"
  ],
  "searchQueries": [],
  "logins": [],
  "requireEmail": false,
  "maxStreamers": 50,
  "dedupe": false
}
```

# 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 = {
    "categories": [
        "Fortnite"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapemint/twitch-streamer-leads").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 = { "categories": ["Fortnite"] }

# Run the Actor and wait for it to finish
run = client.actor("scrapemint/twitch-streamer-leads").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 '{
  "categories": [
    "Fortnite"
  ]
}' |
apify call scrapemint/twitch-streamer-leads --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Twitch Streamer Leads Scraper: Contacts by Game & Followers",
        "description": "Find Twitch streamers by game, search query, or login and filter by follower band: one row per streamer with followers, business email from the bio, social links, partner status, language, and last stream. For influencer campaigns and creator outreach. Keyless, no browser. Pay per streamer.",
        "version": "0.1",
        "x-build-id": "eXfisQzmQ78ipEXkF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/scrapemint~twitch-streamer-leads/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-scrapemint-twitch-streamer-leads",
                "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/scrapemint~twitch-streamer-leads/runs": {
            "post": {
                "operationId": "runs-sync-scrapemint-twitch-streamer-leads",
                "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/scrapemint~twitch-streamer-leads/run-sync": {
            "post": {
                "operationId": "run-sync-scrapemint-twitch-streamer-leads",
                "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",
                "properties": {
                    "categories": {
                        "title": "Categories / games",
                        "type": "array",
                        "description": "Exact category names as shown on Twitch, e.g. Fortnite, Just Chatting, Music, Art. Returns currently live streamers in each.",
                        "default": [
                            "Fortnite"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchQueries": {
                        "title": "Search queries (optional)",
                        "type": "array",
                        "description": "Free-text channel search, e.g. music producer, cooking, poker coach. Also finds offline channels.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "logins": {
                        "title": "Specific logins (optional)",
                        "type": "array",
                        "description": "Twitch usernames to look up directly.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "minFollowers": {
                        "title": "Min followers (optional)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only streamers with at least this many followers."
                    },
                    "maxFollowers": {
                        "title": "Max followers (optional)",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Only streamers with at most this many followers. Set 5000-50000 to target micro influencers."
                    },
                    "requireEmail": {
                        "title": "Only streamers with a business email",
                        "type": "boolean",
                        "description": "Skip streamers whose bio contains no email address.",
                        "default": false
                    },
                    "maxStreamers": {
                        "title": "Max streamers per run",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Cap on streamer rows returned. Controls total cost.",
                        "default": 50
                    },
                    "dedupe": {
                        "title": "Skip streamers seen in previous runs",
                        "type": "boolean",
                        "description": "Remember returned streamers across runs and skip them. Turn on for scheduled prospecting.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
