# Steam Curators Finder - Followers, Genres & Contact Links (`that_red_bird/steam-curator-finder`) Actor

Find Steam curators for key outreach: followers, genres, last review, public website/YouTube/Twitter links, and 'curators who covered games like mine' by appid. No key, no login. A free alternative to Keymailer-style lists. Failed lookups are never charged.

- **URL**: https://apify.com/that_red_bird/steam-curator-finder.md
- **Developed by:** [mohamed alaya](https://apify.com/that_red_bird) (community)
- **Categories:** Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 curators

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Steam Curators Finder - Followers, Genres & Contact Links

Finds the Steam curators worth sending keys to. Give it the Steam app IDs of your game and games like it, and it returns the curators who reviewed them ("curators who covered games like mine"), ranked by how many they covered and how many followers they have, with the genres they cover and the contact links they publish. For indie developers and small publishers who would otherwise pay for a Keymailer / Woovit style list.

No API key, no login, no browser. It reads Steam's own public curator pages.

### Input examples

Curators who reviewed games like yours (put your game and 3-5 comparable titles):

```json
{ "appIds": ["1245620", "1091500", "1145360"], "maxCurators": 40, "minFollowers": 1000 }
```

Your game is unreleased: let Steam suggest similar games, then find their curators:

```json
{ "similarToAppIds": ["1145360"], "similarCount": 8, "requireContact": true }
```

Just the biggest active curators (no game needed):

```json
{ "maxCurators": 50, "minFollowers": 20000, "activeWithinDays": 180 }
```

`{}` works: it returns the 25 most-followed curators that reviewed something in the last year.

### Input guide

| Field | Meaning |
|---|---|
| `appIds` | Steam app IDs (or store URLs) of your game and similar games. |
| `similarToAppIds`, `similarCount` | Add Steam's "more like this" games for each app. |
| `maxCurators`, `minFollowers`, `activeWithinDays` | Result size and quality filters. |
| `includeContacts`, `requireContact` | Collect public links/emails from each curator page; optionally keep only curators that have any. |
| `includeReviews` | Add each curator's verdict and blurb for the requested games, with free-copy / compensation flags. |
| `maxCuratorsPerApp` | How deep to read Steam's per-game curator list (50 per request, most followed first). |

### Output fields

| Field | Meaning |
|---|---|
| `name`, `curatorId`, `curatorUrl`, `steamGroupUrl` | The curator on Steam. |
| `followers`, `highValueFollowers` | Steam's follower counts. |
| `totalReviews`, `recommended`, `notRecommended`, `informational` | What they have published. |
| `lastReviewDate` | Their latest review (a live curator reviews recently). |
| `genres` | The top tags of games they feature (Steam popular tags). |
| `website`, `youtube`, `twitter`, `twitch`, `discord`, `facebook`, `instagram`, `tiktok`, `bluesky`, `reddit`, `otherLinks`, `emails` | Public links listed on the curator page or in their description. |
| `coveredAppIds`, `coveredOfRequested`, `reviews` | Which of your requested games they reviewed, with verdict, blurb, review link, `receivedFreeCopy`. |

Sample row (shortened):

```json
{"type":"curator","curatorId":27826123,"name":"GamingTaylor","followers":56223,"lastReviewDate":"2026-10-02","genres":["Multiplayer","Action","Adventure","RPG"],"coveredOfRequested":"5/5","website":null,"hasContact":false}
```

### Use it with

- Export to a spreadsheet and sort by `coveredCount` then `followers` for your key-sending list.
- Run it for several comparable games, then pass the curators with contact links into an outreach tool.

### FAQ

**Why do many curators have no contact link?** Steam lets curators list links but many do not. Those rows still give you the Steam curator page, where Steam's own "contact" options (follow, comment, curator connect) apply.

**Does it send keys or emails?** No. It only lists curators.

**Is the data fresh?** It is read live from Steam on every run.

### Honest limits

- Steam does not publish curator email addresses; the `emails` field only contains addresses the curator wrote on their own page or description.
- Genres are derived from Steam's popular tags on the games a curator features, not a label Steam gives the curator.
- Only the first `maxCuratorsPerApp` curators per game are scanned (most-followed first), so small curators may be missed for games with thousands of reviews.
- This uses Steam's unofficial storefront endpoints, which Valve can change without notice.

### Price

Pay per event: **`curator` $0.002** per curator row. Example: a 50-curator outreach list = **$0.10**. Error rows are free.

# Actor input Schema

## `appIds` (type: `array`):

Steam app IDs or store URLs of your game and games like it (the number in store.steampowered.com/app/1245620/...). The Actor finds curators who reviewed them and ranks curators who covered the most. Leave empty (with Similar games empty) to list the most-followed active curators.

## `similarToAppIds` (type: `array`):

Steam app IDs. For each, the Actor takes Steam's 'more like this' games and adds the curators who covered those too. Good when your own game is unreleased or has no reviews yet.

## `similarCount` (type: `integer`):

How many 'more like this' games to add for each app in Find curators of games similar to.

## `maxCurators` (type: `integer`):

Maximum number of curators returned, best first (most games covered, then most followers).

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

Skip curators with fewer followers than this.

## `activeWithinDays` (type: `integer`):

Only curators whose latest review is at most this many days old. 0 turns the filter off. Inactive curators will not answer your key request.

## `includeContacts` (type: `boolean`):

Open each curator's Steam page to collect their public website / YouTube / Twitter / Discord links, emails and the genres they cover. Slower but this is the outreach data.

## `requireContact` (type: `boolean`):

Keep only curators that publish at least one external link or email. Needs Fetch contact links turned on.

## `includeReviews` (type: `boolean`):

Add each curator's review of the requested games: verdict, date, one-line blurb, link, and whether they received a free copy.

## `maxCuratorsPerApp` (type: `integer`):

How many curators to read from Steam's list for each game (50 per request, most-followed first). Raise it to dig deeper into small curators.

## `concurrency` (type: `integer`):

How many curator pages are opened at once. Keep it low to stay friendly to Steam.

## Actor input object example

```json
{
  "appIds": [],
  "similarToAppIds": [],
  "similarCount": 5,
  "maxCurators": 25,
  "minFollowers": 500,
  "activeWithinDays": 365,
  "includeContacts": true,
  "requireContact": false,
  "includeReviews": true,
  "maxCuratorsPerApp": 100,
  "concurrency": 3
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `downloadCsv` (type: `string`):

No description

## `summary` (type: `string`):

No description

## `count` (type: `string`):

No description

# 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 = {
    "appIds": [],
    "similarToAppIds": [],
    "similarCount": 5,
    "maxCurators": 25,
    "minFollowers": 500,
    "activeWithinDays": 365,
    "includeContacts": true,
    "requireContact": false,
    "includeReviews": true,
    "maxCuratorsPerApp": 100,
    "concurrency": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("that_red_bird/steam-curator-finder").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 = {
    "appIds": [],
    "similarToAppIds": [],
    "similarCount": 5,
    "maxCurators": 25,
    "minFollowers": 500,
    "activeWithinDays": 365,
    "includeContacts": True,
    "requireContact": False,
    "includeReviews": True,
    "maxCuratorsPerApp": 100,
    "concurrency": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("that_red_bird/steam-curator-finder").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "appIds": [],
  "similarToAppIds": [],
  "similarCount": 5,
  "maxCurators": 25,
  "minFollowers": 500,
  "activeWithinDays": 365,
  "includeContacts": true,
  "requireContact": false,
  "includeReviews": true,
  "maxCuratorsPerApp": 100,
  "concurrency": 3
}' |
apify call that_red_bird/steam-curator-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,that_red_bird/steam-curator-finder"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/jeEZpk93hVchjoWoE/builds/1mkOVo6AvVOxibyrt/openapi.json