# Steam Email Scraper (`fastdataapi/steam-email-scraper`) Actor

Steam Email Scraper finds public Steam pages with contact emails from your keywords: page title, snippet, link and email, one row per match. Filter by location and email domain. No Steam account or login. Export as JSON, CSV or Excel, or use the API.

- **URL**: https://apify.com/fastdataapi/steam-email-scraper.md
- **Developed by:** [Fast Data API](https://apify.com/fastdataapi) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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 Email Scraper — Public Developer Page Emails

Steam Email Scraper is a steam game developer email scraper that searches Google for public Steam pages showing a contact email that matches your keyword, then returns the page title, snippet, link and email address as one row per match. **No Steam account, login or cookies are required** - the actor never visits Steam's own search. Every result is structured JSON, ready to pass directly to a CRM, a cold-outreach pipeline or an AI lead-scoring agent. Start with one keyword, then add more to build a full list of developer and publisher contacts.

![Steam Email Scraper: every page and email from Steam pages as JSON](https://api.apify.com/v2/key-value-stores/Lg9lp51Levfro6SrV/records/k-steam-email-hero.webp)

***

### What data can I extract with Steam Email Scraper?

Using this Steam page email API, you will be able to extract the following Steam page data:

| 🌐 Network | 🔑 Keyword | 📝 Title | 📄 Description |
|---|---|---|---|
| 🔗 Page URL | 📧 Email address | | |

***

### How to use Steam Email Scraper

The actor works as a steampowered.com email finder by keyword, built for publishing managers, QA recruiters and outreach teams who want a list of real developer and publisher contact emails from Steam developer pages in one run.

**Copy to your AI assistant:**

```text
`steam-email-scraper` is an Apify Actor that returns emails found on public Steam pages as structured JSON: source network, the keyword that found it, page title, page snippet, page URL and email address. Use it whenever someone needs to find emails on steam without cookies, a login, or a browser - cold-outreach lead lists for publishing and porting deals, recruiting studios by genre, and market research on which developer pages publish a contact address. Inputs: keywords (array of strings, required - one Google search per keyword), location (string, optional city or region), emailDomains (array of strings, optional - keep only these email domains, e.g. "@gmail.com"), maxEmails (integer 1-100000, default 10 - maximum emails per keyword, lower on the free plan), proxyConfiguration (object, optional - leave default for automatic proxy selection).
```

#### Step by step

1. [Create a free Apify account](https://console.apify.com/sign-up).
2. Open [Steam Email Scraper](https://apify.com/fastdataapi/steam-email-scraper) in the Apify Store.
3. Enter one or more Steam-related keywords.
4. Click **Start**.
5. Download or stream your results in JSON, CSV or Excel.

#### How to scale Steam Email Scraper to bulk

Add as many keywords as you like in one run - each one runs its own Google search series, and up to three keywords are searched at the same time, so a 30-keyword batch still finishes well under running them one by one. Raise `maxEmails` per keyword to pull more per search, up to 100,000. For very large keyword lists, split them across a few runs, or schedule repeat runs through the Apify API.

***

### ✨ Features

Steam Email Scraper fetches clean, structured developer and publisher leads from Steam ⚡ at low cost 💸. Built to scrape steam developer emails from public developer pages, it's ideal for cold-outreach lead generation, publishing and porting prospecting, QA recruiting and market research on a niche of studios.

It extracts, per result:

- **Source network** – which platform the result came from (steampowered.com or steamcommunity.com)
- **Keyword** – the search term that found this result
- **Title** – the public page's title
- **Description** – the page's visible text snippet
- **Page URL** – direct link to the Steam page
- **Email** – the email address shown publicly on that page

⚡ Widens the search automatically across developer pages, recency filters and common contact terms when a keyword hasn't hit its limit yet.

***

### Use cases 💡

- **Publishing manager** — use this steam lead generation tool to shortlist studios by genre and keyword.
- **QA recruiter** — scrape steam developer emails to build an outreach pipeline for testing contracts.
- **Partnership manager** — find steam publisher email addresses to shortlist potential co-publishing deals.
- **Market researcher** — see which public Steam developer pages in a niche share contact details.
- **AI agent builder** — pipe the JSON results into a lead-scoring or outreach pipeline automatically.

***

### Why choose this actor?

1. **Up to 100,000 emails per keyword.** Each keyword acts as a steam contact email extractor against public Steam pages, returning from 1 up to 100,000 matching emails, with as many keywords as you like in one run.
2. **Widens the search automatically.** When the first pass hasn't reached your limit, up to 15 further search variants - developer pages, a one-year and one-month recency filter, and common contact terms - run next, each de-duplicated against the ones before it.
3. **Three keywords at a time.** Up to 3 keywords run concurrently in one job, each paginated up to 30 Google result pages per search pass, across both steampowered.com and steamcommunity.com.

***

### ⬇️ Input

![Steam Email Scraper input: keywords, location, email domains and max emails](https://api.apify.com/v2/key-value-stores/Lg9lp51Levfro6SrV/records/k-steam-email-input.webp)

The actor takes one or more keywords - the only required field - plus optional location and email-domain filters to narrow the search.

| Parameter | Required | Type | Description | Example value |
|---|---|---|---|---|
| keywords | ✅ Yes | array | One or more search keywords; each is searched separately on public Steam pages. | `["indie developer", "game publisher"]` |
| location | No | string | Optional city or region. Only pages mentioning this place are kept. Default: worldwide. | `"Vietnam"` |
| emailDomains | No | array | Keep only emails of these domains (the `@` is optional). Default: any domain. | `["@gmail.com"]` |
| maxEmails | No | integer | Maximum emails to collect per keyword, 1-100,000. Default: `10`. Free-plan users are capped at 20/keyword/run and 200/month. | `50` |
| engine | No | string | Processing engine; only `"legacy"` is available. Default: `"legacy"`. | `"legacy"` |
| proxyConfiguration | No | object | Connection settings; leave default for automatic proxy selection. | `{"useApifyProxy": true}` |

***

### Free plan limits

Users on the Apify free plan can fetch up to 20 items per run (all keywords together) and 200 items per month. When the limit is reached, the run finishes successfully with a status message explaining the limit. Upgrade to any paid Apify plan to remove these limits.

***

#### Example input

```json
{
  "keywords": ["indie developer", "game publisher"],
  "location": "Vietnam",
  "emailDomains": ["@gmail.com"],
  "maxEmails": 50,
  "engine": "legacy",
  "proxyConfiguration": { "useApifyProxy": true }
}
```

***

### ⬆️ Output

![Steam Email Scraper output: one row per match with network, keyword, title and email](https://api.apify.com/v2/key-value-stores/Lg9lp51Levfro6SrV/records/k-steam-email-output.webp)

Every result is one typed, normalized JSON item with the same six fields on every run - network, keyword, title, description, url and email. Download as JSON, CSV or Excel, or find steam publisher email addresses directly through the Apify API.

#### Example output

```json
[
  {
    "network": "steampowered.com",
    "keyword": "indie developer",
    "title": "Steam Developer: Absam Studios",
    "description": "Developer page for Absam Studios, a husband-and-wife indie studio. Official contact: contact@absamstudios.com.",
    "url": "https://store.steampowered.com/developer/absamstudios",
    "email": "contact@absamstudios.com"
  }
]
```

***

### How does it work?

This steam email address scraper never visits Steam's own search. Instead, for each keyword it searches Google for public Steam pages that mention your keyword and show a contact email, using rotating proxies and automatic retries so a single blocked page never stops the run. When Google hides a result's real destination behind a redirect link, the actor resolves it before deciding whether the page is really on Steam. It then reads the title, snippet and any visible email straight from the search result, carefully reconciling addresses that got split or truncated by Google's own formatting instead of returning a half-correct guess. The output schema stays the same no matter how Google's result page layout changes.

***

### How do you integrate Steam Email Scraper into your stack?

It works with the automation tools you already use - no-code platforms can call it directly once it is running as an Apify Actor.

#### No-code tools (n8n, Make, LangChain)

In n8n, use the Apify node's "Run an Actor" action, or the HTTP Request node pointed at the actor's run-sync endpoint with your Apify token. In Make, use the Apify app's "Run an Actor" module followed by "Get Dataset Items" to pull the results into your scenario. In LangChain, install `langchain-apify` and wrap the actor with `ApifyActorsTool()` to let an agent call it as a tool.

***

### Is it legal to scrape Steam data?

Scraping publicly available web data, including public search-engine results, is generally permitted in most jurisdictions when no login or access restriction is bypassed. Steam Email Scraper only returns information a public Google search already shows - the page title, a text snippet and any email address visible in that snippet. It never logs into Steam or accesses private data. Email addresses come from publicly listed text; using them is subject to anti-spam law such as CAN-SPAM and data-protection law such as GDPR, so storing and emailing these addresses must comply with the rules that apply to you. Consult legal counsel if your use case involves bulk storage of personal data.

***

### Frequently asked questions

#### What fields does Steam Email Scraper return?

It returns the source network, the keyword that found the result, the page title, a text snippet, the page URL and the email address - see [the data fields section](#what-data-can-i-extract-with-steam-email-scraper) for the full list.

#### Does Steam Email Scraper require a Steam account or login?

No. As a steamcommunity.com email finder, the actor only reads public Google search results and never logs in to Steam or uses cookies.

#### What happens if a keyword has no public results with an email?

The actor returns zero rows for that keyword and moves on to the next one - no error is raised. Try a broader keyword, remove the location filter, or add more email domains.

#### Can I search multiple keywords at once?

Yes. Pass multiple strings in the `keywords` array; each one runs as its own search, with up to 3 keywords processed at the same time.

#### Does Steam Email Scraper return data in a format LLMs can use directly?

Yes. Every row is typed, normalized JSON with consistent field names - no HTML parsing or selectors needed. Pass it straight to an LLM, index it into a vector store, or feed it to an agent tool.

#### What happens when Google changes its result page layout?

The actor's output schema stays the same. The search-result parsing is kept up to date so your calls keep returning the same six fields with no changes on your end.

#### Can I use Steam Email Scraper without managing proxies myself?

Yes. Proxy rotation and retrying blocked pages happen automatically on the actor's side, including a fresh connection after a captcha or block. You send one request and get structured JSON back - no proxy accounts or browser setup needed.

#### Which fields work best for AI training data and partnership-prospecting pipelines?

For outreach text, use the title and description fields, which carry the page's visible wording. For structured scoring or deduplication, use the keyword, url and email fields - all are plain strings, no normalization needed.

***

### Your feedback

Found a bug or missing a field? Open a ticket in the actor's Issues tab on Apify. We read every report and ship fixes, so the actor keeps working as Google and Steam change.

# Actor input Schema

## `keywords` (type: `array`):

One or more keywords (e.g. marketing, coach, photographer, fitness). Each keyword is searched separately on public Steam pages and every email found is returned with the keyword that found it. More specific keywords give more targeted leads.

## `location` (type: `string`):

Optional city or region (e.g. London, New York, Dubai). Only pages that mention this place are kept. Leave empty to search worldwide.

## `emailDomains` (type: `array`):

Keep only emails of these domains, e.g. @gmail.com, @outlook.com, @hotmail.com, @yahoo.com, @icloud.com or a business domain like @yourcompany.com (the @ is optional). The domains also sharpen the search. Leave empty to collect emails of any domain.

## `maxEmails` (type: `integer`):

How many emails to collect per keyword (1 - 100,000). A keyword stops earlier when no more public results with an email are available. Free plan users are limited to 20 items per run in total (across all keywords) and 200 items per month; paid plans have no limit.

## `engine` (type: `string`):

Processing engine. Only 'legacy' is available.

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

How the actor connects. Leave it as it is and a suitable Apify proxy is selected automatically. When a page is blocked the actor retries with a fresh proxy session (up to 3 attempts per page). You can also choose your own Apify proxy groups or custom proxy URLs.

## Actor input object example

```json
{
  "keywords": [
    "marketing"
  ],
  "location": "",
  "emailDomains": [
    "@gmail.com"
  ],
  "maxEmails": 10,
  "engine": "legacy",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Dataset rows: network, keyword, title, description, url, email.

# 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 = {
    "keywords": [
        "marketing"
    ],
    "emailDomains": [
        "@gmail.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fastdataapi/steam-email-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 = {
    "keywords": ["marketing"],
    "emailDomains": ["@gmail.com"],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("fastdataapi/steam-email-scraper").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 '{
  "keywords": [
    "marketing"
  ],
  "emailDomains": [
    "@gmail.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call fastdataapi/steam-email-scraper --silent --output-dataset

```

## MCP server setup

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

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/HAmKu5uEbpKWr3UpN/builds/z3KPB5oXFizGjEslc/openapi.json