# Steam Game Studio Lead Extractor (`ayeeyee/steam-game-studio-lead-extractor`) Actor

Verified game-studio sales leads from Steam: MX/DNS emails + phones + socials + tech stack scraped from the studio's OWN declared website (Steam appdetails), an A-D lead score, game catalog with reviews, and a studio-readiness signal. No API keys, no proxy. Per-result pricing.

- **URL**: https://apify.com/ayeeyee/steam-game-studio-lead-extractor.md
- **Developed by:** [Virtual Footprint LLC](https://apify.com/ayeeyee) (community)
- **Categories:** Lead generation, Business, Marketing
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.00 / 1,000 game studio lead with contacts

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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Steam Game Studio Lead Extractor

Turn Steam games into **verified game-studio sales leads**. Give it keywords, Steam app URLs, or app IDs, and it returns one lead per **studio** — MX/DNS-verified contact emails, phones, socials, and tech stack scraped from the studio's **own declared website** (the Steam `appdetails` `website` field), plus a game catalog with review traction, an A–D lead score, and a studio-readiness signal with a `newlyLaunched` flag.

> **Per-successful-result pricing.** You are charged only for studios that actually return a real contact signal (email/phone/social) — not for empty results, soundtracks, DLC, or studios with no website. No flat database fee.

- **No API keys, no residential proxy.** Uses Steam's public keyless store APIs (`storesearch`, `appdetails`, `appreviews`) and the studio's own public website.
- **ToS-clean.** Contact always comes from the studio's own declared site — Steam user / developer-profile personal data is never mined.
- **Quality-gated.** Soundtracks, DLC, demos, tools and bundles are filtered out by Steam `type` so only real shippable games roll up to a studio.
- **MCP-ready.** "Turn this Steam game / search into a verified studio lead" agent tool.

### What it does

1. **Discover** games by keyword (`storesearch`) and/or resolve explicit Steam app URLs / IDs (`appdetails`).
2. **Filter** to real games (`type` = `game` / `application`); optionally keep only games matching a Steam genre/category.
3. **Roll up** all of a studio's games to one lead, keyed by the first Steam `developer` (falling back to the first `publisher`).
4. **Enrich** the studio's own declared `website` for MX/DNS-verified emails, NANP phones, social profiles, and tech-stack fingerprint.
5. **Score** every lead A–D by signal richness (`leadScore`) and grade studio-readiness A–D (launch recency + review traction + reachability).
6. **Flag** games released within a trailing `launchedWithinDays` window as `newlyLaunched` (stateless rolling window — the "freshly launched studio" sales pitch).

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `apps` | array\<string> | — | Steam store URLs (`https://store.steampowered.com/app/<ID>/...`) or bare numeric app IDs. |
| `searchQueries` | array\<string> | — | Keywords to discover games via `storesearch` (e.g. `"cozy farming"`, `"metroidvania"`). |
| `maxPerQuery` | integer | `20` | Cap on games returned per search query (1–100). |
| `country` | string | `us` | Two-letter ISO Steam storefront country. |
| `lang` | string | `en` | Two-letter Steam store language. |
| `genre` | string | `""` | Keep only games whose Steam genres/categories contain this string (case-insensitive). Empty = no filter. |
| `launchedWithinDays` | integer | `0` | Flag games released within the trailing N days as `newlyLaunched` (0 = disabled). |
| `verifyEmails` | boolean | `true` | Validate the best contact email's domain against live MX/DNS records. |
| `concurrency` | integer | `3` | Games processed in parallel (1–5). Kept low — `appdetails` rate-limits (HTTP 429) under high concurrency. |
| `proxyConfiguration` | object | `{}` | Optional; only if you hit rate limits. |

Provide `apps` and/or `searchQueries`; at least one is required.

### Output

Each result is one studio lead:

| Field | Description |
|---|---|
| `studioName` | Primary studio name (first Steam `developer`, else first `publisher`). |
| `developers` / `publishers` | Steam developer / publisher lists (from the primary game). |
| `website` | The studio's own declared website (Steam `appdetails` `website`). `null` if none. |
| `gameCount` | Number of games rolled up for this studio. |
| `games[]` | Catalog: `appId`, `title`, `steamUrl`, `type`, `genres`, `categories`, `releaseDate`, `totalReviews`, `reviewScore`, `reviewScoreDesc`, `newlyLaunched`. |
| `newestReleaseDate` / `newlyLaunched` | Newest game's release + whether any game is in the rolling window. |
| `emails` | MX/DNS-cleaned, deduped contact emails from the studio's own site (own-domain ranked first, ≤25). |
| `emailVerified` | `true` if the best email's domain has a live MX/A record. |
| `phones` | Cleaned, validated NANP phones. |
| `socials` | `{platform: url}` (facebook, instagram, twitter/x, linkedin, youtube, tiktok, pinterest). |
| `techStack` | Detected tech (WordPress, Shopify, React, Cloudflare, Stripe, HubSpot, …). |
| `totalReviews` | Sum of review counts across the studio's games. |
| `studioReadiness` / `studioLabel` | A–D readiness grade + plain-English pitch-readiness line. |
| `leadScore` | A–D grade from signal richness (verified email + phone + social + tech). |
| `hasContact` | `true` if any email/phone/social was found (the charge trigger). |

When a studio has no website, or its site exposes no contact, the lead is returned honestly with `hasContact: false`, `emails: []`, `null` fields — **never fabricated**, and **not billed**.

### Real run sample

Run on 2026-07-15. Input: `apps: ["413150","105600","504230","588650","219740","1144200","523280","893050"]` → 7 studio leads, 6 with contact data. One lead has an **MX/DNS-verified email** (`verified_email` billed):

```json
{
  "studioName": "Maddy Makes Games Inc.",
  "developers": ["Maddy Makes Games Inc.", "Extremely OK Games, Ltd."],
  "publishers": ["Maddy Makes Games Inc."],
  "website": "http://www.celestegame.com",
  "gameCount": 1,
  "games": [{
    "appId": "504230", "title": "Celeste",
    "steamUrl": "https://store.steampowered.com/app/504230",
    "type": "game", "genres": ["Action", "Adventure", "Indie"],
    "releaseDate": "2018-01-25T00:00:00+00:00",
    "totalReviews": 67649, "reviewScore": 9,
    "reviewScoreDesc": "Overwhelmingly Positive", "newlyLaunched": false
  }],
  "emails": ["contact.celestegame@gmail.com"],
  "emailVerified": true,
  "phones": [],
  "socials": {},
  "techStack": ["Apache", "Google Analytics", "Google Tag Manager"],
  "totalReviews": 67649,
  "studioReadiness": "B",
  "studioLabel": "Strong prospect — active studio catalog and contactable.",
  "leadScore": "B",
  "hasContact": true
}
```

A separate run, `searchQueries: ["farming"]`, demonstrates **catalog rollup** — one lead per studio, all of a studio's games folded together:

```json
{
  "studioName": "GIANTS Software",
  "developers": ["GIANTS Software"],
  "website": "https://farming-simulator.com/",
  "gameCount": 5,
  "games": [
    {"title": "Farming Simulator 25", "releaseDate": "2024-11-12T00:00:00+00:00", "totalReviews": 19662, "reviewScoreDesc": "Very Positive"},
    {"title": "Farming Simulator 22", "releaseDate": "2021-11-21T00:00:00+00:00", "totalReviews": 32533, "reviewScoreDesc": "Very Positive"},
    {"title": "Farming Simulator 19", "releaseDate": "2018-11-19T00:00:00+00:00", "totalReviews": 27768, "reviewScoreDesc": "Very Positive"},
    {"title": "Farming Simulator 17", "releaseDate": "2016-10-24T00:00:00+00:00", "totalReviews": 7805, "reviewScoreDesc": "Very Positive"},
    {"title": "Farming Simulator 15", "releaseDate": "2014-10-30T00:00:00+00:00", "totalReviews": 4883, "reviewScoreDesc": "Very Positive"}
  ],
  "newestReleaseDate": "2024-11-12T00:00:00+00:00",
  "emails": [],
  "emailVerified": false,
  "socials": {
    "twitter": "https://twitter.com/farmingsim",
    "facebook": "https://www.facebook.com/giants.farming.simulator",
    "youtube": "https://www.youtube.com/giantssoftware",
    "instagram": "https://www.instagram.com/farmingsimulator/",
    "tiktok": "https://www.tiktok.com/@farmingsimulator"
  },
  "techStack": ["Apache"],
  "totalReviews": 92651,
  "studioReadiness": "B",
  "leadScore": "C",
  "hasContact": true
}
```

The same batch returned `Re-Logic` (`terraria.org`) with `hasContact: false`, `emails: []` — honestly empty because the site exposes no contact, and **not billed**. No fabricated emails or phones anywhere in the output.

### Pricing (pay-per-event)

| Event | Price | Charged when |
|---|---|---|
| `studio_lead` (primary) | $0.008 | Once per studio that returns at least one real contact signal (email/phone/social) + its game catalog. |
| `verified_email` | $0.003 | A studio yields at least one MX/DNS-validated contact email. |
| `studio_signal` | $0.001 | A studio has at least one game released within the `launchedWithinDays` window. |
| `apify-actor-start` (one-time) | $0.0001 | When the run starts. |

Primary event is priced well above per-run compute cost — there is zero upstream compose cost (self-contained: keyless Steam store APIs + the studio's own public website).

### Performance & cost

- A keyword query discovers ~10–50 app ids; each kept game costs one `appdetails` + one `appreviews` call; one studio site fetch for enrichment.
- Concurrency is capped low (default 3) to respect Steam's `appdetails` rate limit (HTTP 429, retried with backoff).
- Typical query (20 games → ~10 studios, 2–4 with verified contact): a few cents.

### Troubleshooting

- **No results / fewer studios than games:** soundtracks, DLC, demos, tools and bundles are dropped by `type`. Provide more `searchQueries` or explicit `apps`.
- **`hasContact: false` on a big studio:** Steam's `website` field is `null` for some games (e.g. AAA titles), so there is no studio site to enrich. Honest, not billed.
- **HTTP 429 / throttled runs:** lower `concurrency`, add a `proxyConfiguration`, or reduce `maxPerQuery`.
- **`newlyLaunched` flags too much:** Steam release dates are formatted strings; undated/"coming soon" games get `releaseDate: null` and are never flagged. Tune `launchedWithinDays`.

# Actor input Schema

## `apps` (type: `array`):

Steam store URLs (https://store.steampowered.com/app/<ID>/...) or bare numeric app IDs. Each is resolved via Steam's keyless appdetails endpoint.

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

Keywords to discover games (and thus studios) via Steam's keyless storesearch endpoint (e.g. 'deck building', 'cozy farming'). Each query returns up to `maxPerQuery` games.

## `maxPerQuery` (type: `integer`):

Cap on games returned per search query (1-100). Steam storesearch caps results server-side.

## `country` (type: `string`):

Two-letter ISO country code for the Steam storefront (default us).

## `lang` (type: `string`):

Two-letter language code for Steam store text (default en).

## `genre` (type: `string`):

Keep only games whose Steam genres or categories contain this string (e.g. 'Indie', 'RPG', 'Simulation'). Case-insensitive. Empty = no filter.

## `launchedWithinDays` (type: `integer`):

Flag games released within the trailing N days as `newlyLaunched` (rolling window, 0 = disabled). This is a stateless window filter, not a cross-run cursor.

## `verifyEmails` (type: `boolean`):

Validate the best contact email's domain against live MX/DNS records.

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

Games processed in parallel (1-5). Kept low because Steam's appdetails endpoint rate-limits (HTTP 429) under high concurrency.

## `proxyConfiguration` (type: `object`):

Optional. Only needed if you hit rate limits; the Actor works without a proxy (Steam's keyless store APIs).

## Actor input object example

```json
{
  "apps": [
    "https://store.steampowered.com/app/367520/Hollow_Knight/",
    "413150"
  ],
  "searchQueries": [
    "cozy farming",
    "deck building",
    "metroidvania"
  ],
  "maxPerQuery": 20,
  "country": "us",
  "lang": "en",
  "genre": "",
  "launchedWithinDays": 0,
  "verifyEmails": true,
  "concurrency": 3,
  "proxyConfiguration": {}
}
```

# Actor output Schema

## `results` (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 = {
    "apps": [
        "https://store.steampowered.com/app/367520/Hollow_Knight/"
    ],
    "searchQueries": [
        "cozy farming"
    ],
    "proxyConfiguration": {}
};

// Run the Actor and wait for it to finish
const run = await client.actor("ayeeyee/steam-game-studio-lead-extractor").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 = {
    "apps": ["https://store.steampowered.com/app/367520/Hollow_Knight/"],
    "searchQueries": ["cozy farming"],
    "proxyConfiguration": {},
}

# Run the Actor and wait for it to finish
run = client.actor("ayeeyee/steam-game-studio-lead-extractor").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 '{
  "apps": [
    "https://store.steampowered.com/app/367520/Hollow_Knight/"
  ],
  "searchQueries": [
    "cozy farming"
  ],
  "proxyConfiguration": {}
}' |
apify call ayeeyee/steam-game-studio-lead-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ayeeyee/steam-game-studio-lead-extractor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/d6R9Wj9ivQeAUg777/builds/xHMhaeEX1cLgiohAj/openapi.json