# Steam Community Email Scraper (`email_scraper/steam-community-email-scraper`) Actor

Steam Community Email Scraper extracts publicly available email addresses from Steam Community search results using targeted keywords, locations, and email domains. Build structured contact lists with custom filters, duplicate protection, and flexible search targeting.

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

## Pricing

from $1.49 / 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?

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 Community Email Scraper – Overview

**Steam Community Email Scraper** is an Apify Actor designed to extract publicly listed email addresses associated with Steam Community search results.

It helps marketers, researchers, developers, publishers, agencies, and lead-generation professionals turn targeted Steam Community search terms into structured contact data.

Instead of manually searching Steam Community pages and copying publicly visible contact information, you can provide keywords, optional geographic terms, preferred email domains, and exclusion words. The Actor searches for relevant Steam Community results and extracts matching email addresses from publicly available search-result descriptions.

> **📌 Steam Community Email Scraper**
>
> - Search Steam Community results using custom keywords
> - Extract publicly listed email addresses
> - Target specific email domains such as `@gmail.com`
> - Narrow searches by country, state, or city
> - Exclude unwanted descriptions with custom words or phrases
> - Remove duplicate email addresses
> - Store structured results in an Apify Dataset
> - Process multiple keyword and domain combinations

The easiest workflow is simple: enter your target keywords, optionally specify a location and email domains, choose the maximum number of emails, and run the Actor.

The resulting dataset contains the keyword, result title, description, URL, and extracted email address for each collected lead.

### 🔍 Steam Community Email Scraper – Key Features

The Actor focuses specifically on keyword-driven Steam Community email discovery. Its input options let you control how broad or narrow the search should be.

> **⚡ Key Features**
>
> - **Keyword-based search** — Search Steam Community results using one or multiple terms.
> - **Location targeting** — Add a country, state, or city to narrow relevant results.
> - **Custom email domains** — Search for specific domains such as `@gmail.com`, `@yahoo.com`, or `@outlook.com`.
> - **Email collection limits** — Define how many emails to target for each keyword + domain combination.
> - **Exclude words** — Skip result descriptions containing unwanted words or phrases.
> - **Duplicate protection** — Previously collected email addresses are not collected again.
> - **Structured dataset** — Results are pushed into an Apify Dataset in a consistent format.
> - **Progress persistence** — Collection progress is retained so interrupted processing can resume.
> - **Broad search support** — Multiple keywords and email domains can be combined for wider coverage.

The Actor is particularly useful when you already know the type of Steam Community profiles or businesses you want to discover.

For example, instead of searching only for `Game Developer`, you can use several related queries such as `Game Developer`, `Game Publisher`, `Game Creator`, and `Indie Game Developer`.

This approach can produce broader search coverage while keeping the resulting leads relevant to your intended audience.

### 📊 Steam Community Email Scraper – What Data You Can Extract

The Actor creates structured records from relevant Steam Community search results where a matching email address is publicly available in the result description.

The dataset view is configured around five primary output fields.

> **📦 Output Data**
>
> - **keyword** — The keyword used to discover the result.
> - **title** — The title of the Steam Community search result.
> - **description** — The publicly available search-result description associated with the result.
> - **url** — The URL associated with the discovered result.
> - **email** — The email address extracted from the result description.

This makes the output suitable for further filtering, analysis, enrichment, or export through Apify's dataset capabilities.

#### 📋 Example Output

```json
{
  "keyword": "Game Developer",
  "title": "Example Steam Community Profile",
  "description": "Game developer contact information example@example.com",
  "url": "https://steamcommunity.com/...",
  "email": "example@example.com"
}
```

The example above illustrates the output structure. Actual values depend entirely on the publicly available search results found during your run.

> **🔎 Important**
>
> - The Actor does not guarantee that every Steam Community result contains an email address.
> - Email extraction depends on an email address being publicly present in the searchable result content.
> - A target such as 100 emails is a collection target, not a guarantee that 100 matching public emails exist.
> - Narrow keywords, uncommon domains, or restrictive locations can significantly reduce results.

### 🚀 Steam Community Email Scraper – How to Use It

Using the Actor requires only a few configuration steps.

#### 1. 🔍 Enter Keywords

Add the Steam Community-related keywords you want to search.

Examples include:

- `Game Developer`
- `Game Publisher`
- `Game Creator`
- `Indie Game Developer`
- `Game Studio`
- `Steam Developer`

Multiple keywords are especially useful when your audience can be described in several ways.

#### 2. 🌍 Add an Optional Location

Use the **Region / Location** field when you want to narrow the search geographically.

Examples:

- `United States`
- `United Kingdom`
- `Canada`
- `Germany`
- `California`
- `Montreal`

Leave the field empty when you want a broader search without a geographic filter.

#### 3. 📧 Select Email Domains

The **E-mail domain suffixes** field controls which email domains the Actor searches for.

For example:

- `@gmail.com`
- `@yahoo.com`
- `@outlook.com`
- `@hotmail.com`
- `@icloud.com`

You can provide multiple domains to increase search coverage.

#### 4. 🎯 Set the Maximum Email Target

The **Max Emails** setting determines the collection target for each keyword + domain combination.

For example, if you use:

- 3 keywords
- 2 email domains
- Maximum = 20

the Actor processes all six keyword/domain combinations, with a target of up to 20 emails for each combination.

This means the potential target is up to 120 results across those combinations, subject to what can actually be discovered and duplicate protection.

#### 5. 🚫 Add Exclude Words

Use **Exclude words** when you want to skip descriptions containing particular words or phrases.

Examples:

- `crypto`
- `onlyfans`
- `casino`

Single-word exclusions are matched as whole words without considering letter case. Phrases are matched without considering letter case.

This is useful for removing irrelevant result types from your lead collection.

### 🛠️ How to Scrape Steam Community Emails with Keywords

The most practical approach is to combine several closely related keywords with relevant email domains.

For example, a gaming-related prospecting run could use:

```text
Game Developer
Game Publisher
Game Creator
Indie Game Developer
Game Studio
```

and:

```text
@gmail.com
@yahoo.com
@outlook.com
```

You can then add a location such as:

```text
United States
```

This creates a more targeted Steam Community email search rather than relying on one broad query.

> **💡 Search Strategy**
>
> - Start with 3–5 closely related keywords.
> - Use several relevant email domains.
> - Add a location only when geographic targeting is important.
> - Increase the email target when deeper collection is needed.
> - Use exclusion words when irrelevant profile descriptions appear.
> - If results are sparse, broaden your keywords or remove restrictive location filters.

### 🎯 Can You Search Steam Community Emails by Location?

Yes. The **Region / Location** input accepts a manually entered country, state, or city.

For example:

```text
keywords:
Game Developer
Game Studio
Game Publisher

location:
Canada
```

The location is used to narrow the search toward results associated with that geographic term.

However, location targeting does not guarantee that every discovered profile is physically located in that region. The Actor relies on searchable public result content, so geographic relevance depends on what is publicly indexed.

### 📧 Can You Search for Specific Email Domains?

Yes. The Actor supports custom email-domain suffixes.

For example, you can search specifically for:

```text
@gmail.com
```

or broaden the search with:

```text
@gmail.com
@yahoo.com
@outlook.com
@hotmail.com
```

Custom domains are also supported, making the feature useful when you are interested in a particular organization or business-domain pattern.

> **📌 Domain Targeting Tip**
>
> - More domains can increase search coverage.
> - Highly specific domains may produce fewer results.
> - Combining common and business domains can provide broader prospect coverage.
> - Results still depend on publicly searchable email information.

### 🚫 Can You Filter Out Unwanted Steam Community Results?

Yes. The **Exclude words** input lets you define words or phrases that should cause a search-result description to be skipped.

For example:

```text
crypto
onlyfans
casino
```

If an excluded term appears in a result description, that result is skipped rather than contributing an email address.

This gives you a practical way to improve the relevance of your collected Steam Community contacts.

### 💼 Steam Community Email Scraper – Use Cases

The Actor can support several legitimate research and lead-discovery workflows involving publicly available contact information.

> **🎯 Common Use Cases**
>
> - **Game developer research** — Find publicly listed contact emails associated with game developers.
> - **Publisher prospecting** — Build structured lists of publisher-related contacts.
> - **Game studio discovery** — Identify potentially relevant studios from targeted searches.
> - **Gaming market research** — Collect searchable contact information for research purposes.
> - **Agency prospecting** — Discover relevant gaming-related contacts for business outreach.
> - **Partnership research** — Find publicly listed contacts associated with potential collaboration opportunities.
> - **B2B lead research** — Organize publicly available business contact information into a structured dataset.
> - **Competitive research** — Search targeted Steam Community categories and organize discovered public contact information.

Use collected information responsibly and comply with applicable laws, platform rules, privacy requirements, and your intended outreach policies.

### ⚙️ Input

The Actor provides five configurable input fields.

| Input           | Type    | Description                                                     |
| --------------- | ------- | --------------------------------------------------------------- |
| `keywords`      | Array   | Keywords or queries used for Steam Community searches           |
| `location`      | String  | Optional country, state, or city used to narrow searches        |
| `customDomains` | Array   | Email-domain suffixes to search for                             |
| `maxEmails`     | Integer | Maximum email target for each keyword + domain combination      |
| `excludeWords`  | Array   | Words or phrases that cause matching descriptions to be skipped |

#### 🔹 Keywords

`keywords` is required.

You can enter one or multiple search terms. More specific combinations generally make it easier to target the type of Steam Community results you want.

#### 🔹 Location

`location` is optional.

Leave it empty for searches without a geographic term, or enter a country, state, or city to narrow the search.

#### 🔹 Custom Domains

`customDomains` controls which email suffixes are considered during collection.

The default configuration uses:

```text
@gmail.com
```

#### 🔹 Max Emails

`maxEmails` accepts values from **1 to 10,000**.

The configured target is applied independently to each keyword + domain combination.

For free users, the Actor applies a maximum of **100 emails** regardless of a higher requested target. Paid users do not have this Actor-level 100-email restriction.

#### 🔹 Exclude Words

`excludeWords` is optional and defaults to an empty list.

Use it when certain words or phrases should be excluded from the collection.

### 📤 Output

The results are stored in an Apify Dataset using the configured **Scraped Leads** table.

The primary visible fields are:

- `keyword`
- `title`
- `description`
- `url`
- `email`

The dataset format makes the collected records easy to inspect and use for subsequent data workflows.

> **📦 Structured Output**
>
> - One record represents a discovered email/result combination.
> - Duplicate email addresses are filtered during collection.
> - Results are pushed incrementally rather than waiting for the entire run to finish.
> - The dataset can be used as the structured result source for the Actor run.

### 💰 Pricing

The provided Actor configuration does not define a specific monetary price for using the Actor, so no fixed dollar amount is stated here.

The code does define different collection limits based on account status:

- **Free users:** Maximum of 100 emails.
- **Paid users:** No Actor-level 100-email restriction.
- **Local runs:** Treated as paid/unlimited by the Actor's plan-detection behavior.

Your actual Apify platform usage and run cost can depend on the execution environment and Apify account configuration.

### 🧠 Tips and Best Practices

For better Steam Community email discovery, search strategy matters.

> **💡 Better Results**
>
> - Use several related keywords instead of relying on one broad term.
> - Combine different job titles, business types, or gaming-related descriptions.
> - Add multiple email domains when broader contact coverage is needed.
> - Avoid overly restrictive locations unless geographic targeting is important.
> - Use exclude words to remove recurring irrelevant result categories.
> - Increase `maxEmails` when you want deeper collection.
> - Remember that a higher target cannot create emails that are not publicly searchable.
> - If results are sparse, broaden the search terms before assuming the Actor has failed.

A useful starting strategy is to begin with a broad set of relevant keywords, review the output, and then refine the next run based on the quality of the discovered results.

### 🔄 Progress and Duplicate Handling

The Actor maintains collection progress during processing and tracks email addresses that have already been collected.

This helps prevent the same email address from being repeatedly added to the dataset.

The collection process also has stopping conditions designed to avoid continuing indefinitely when search pages stop producing useful new email results.

These conditions can cause a run to finish before reaching the requested target when searchable results become exhausted or productivity becomes too low.

Therefore, **maxEmails should be treated as a target rather than a guaranteed result count**.

### ❓ Frequently Asked Questions

#### 🔹 What is Steam Community Email Scraper?

Steam Community Email Scraper is an Apify Actor that searches publicly indexed Steam Community results using user-defined keywords and extracts matching publicly listed email addresses into a structured dataset.

#### 🔹 How do I scrape Steam Community emails?

Enter your target keywords, optionally add a location, select email-domain suffixes, configure the email target, and run the Actor. Matching email addresses found in relevant searchable result descriptions are added to the dataset.

#### 🔹 Can I use multiple keywords?

Yes. The `keywords` input accepts multiple search terms, allowing you to target several related categories or descriptions during the same run.

#### 🔹 Can I target a specific country or city?

Yes. Enter a country, state, or city in the `location` field to narrow the search using that geographic term.

#### 🔹 Can I search only Gmail addresses?

Yes. Set the custom email-domain list to `@gmail.com` if Gmail addresses are your target.

#### 🔹 Can I search multiple email domains?

Yes. You can provide multiple email suffixes, such as `@gmail.com`, `@yahoo.com`, and `@outlook.com`.

#### 🔹 Why did I receive fewer emails than my maxEmails value?

`maxEmails` is a target, not a guarantee. The Actor can only collect emails that are publicly discoverable in matching search results. Narrow keywords, limited domains, locations, duplicates, excluded descriptions, and exhausted search results can all reduce the final count.

#### 🔹 How does the email limit work?

The configured target applies separately to each keyword + domain combination. For example, three keywords and two domains with a target of 20 can process six combinations, targeting up to 20 emails per combination.

#### 🔹 Does the Actor remove duplicate emails?

Yes. Email addresses already collected during the Actor's tracked progress are not collected again.

#### 🔹 What happens if I use exclude words?

If an excluded word or phrase appears in a result description, that description is skipped and its email address is not collected from that result.

#### 🔹 What output does the Actor provide?

The configured dataset view provides `keyword`, `title`, `description`, `url`, and `email` fields for collected results.

#### 🔹 Is every Steam Community profile guaranteed to have an email?

No. The Actor only extracts email addresses when matching public email information is available in searchable result content.

### 🆘 Support

If you need help with the Actor, have a question about the configuration, or want to discuss a custom modification, you can contact me directly.

> **📩 Support**
>
> - Contact me by email: **<alphascraper69@gmail.com>**
> - Custom Actor improvements and bespoke builds can also be discussed by email.

# Actor input Schema

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

A list of keywords or queries to search for.

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

Optional country, state or city used to narrow the search. Leave it empty to search without a geographic filter.

## `customDomains` (type: `array`):

List of custom email domains

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

How many addresses each search keyword + domain suffix combination may collect before the finder moves on to the next one. This is a per-combination target, not a run-wide total: with 3 keyword and 2 Domains and a limit of 20, the run works through all 6 combinations and aims for up to 20 addresses in each, so up to 120 overall. Lower values finish sooner and cost less; higher values dig deeper but never guarantee a fuller result, since the run can only find what is publicly listed.

## `excludeWords` (type: `array`):

Words or phrases you do not want to see.

## Actor input object example

```json
{
  "keywords": [
    "Game Developer",
    "Publisher",
    " Game Creator"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ],
  "maxEmails": 10,
  "excludeWords": []
}
```

# Actor output Schema

## `dataset` (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 = {
    "keywords": [
        "Game Developer",
        "Publisher",
        " Game Creator"
    ],
    "location": "",
    "customDomains": [
        "@gmail.com"
    ],
    "excludeWords": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("email_scraper/steam-community-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": [
        "Game Developer",
        "Publisher",
        " Game Creator",
    ],
    "location": "",
    "customDomains": ["@gmail.com"],
    "excludeWords": [],
}

# Run the Actor and wait for it to finish
run = client.actor("email_scraper/steam-community-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": [
    "Game Developer",
    "Publisher",
    " Game Creator"
  ],
  "location": "",
  "customDomains": [
    "@gmail.com"
  ],
  "excludeWords": []
}' |
apify call email_scraper/steam-community-email-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,email_scraper/steam-community-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/0RacFmESkK9WGHDOn/builds/ISHX0ZllNLMXR5jH3/openapi.json