# Steam Public Player Profile Lookup Scraper (`automation-lab/steam-player-profile-lookup`) Actor

Resolve SteamID64 values and Steam Community profile URLs into normalized public identity, online state, privacy indicators, avatars, canonical links, and optional profile text.

- **URL**: https://apify.com/automation-lab/steam-player-profile-lookup.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.96 / 1,000 item extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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 Public Player Profile Lookup Scraper

Resolve SteamID64 values and Steam Community profile URLs into clean public player records. This **steam public player profile lookup** is designed for gaming-community enrichment, moderation tooling, directory maintenance, and recurring profile-state snapshots.

It returns one normalized dataset item per supplied player: SteamID64, current display name, online state, visibility/privacy indicator, avatar URLs, canonical profile URL, and optional public profile text. It does **not** collect games, playtime, badges, groups, activity feeds, email addresses, or private fields.

### What can you do with this Actor?

- Enrich a community member list with current public Steam identity.
- Resolve vanity profile URLs to stable SteamID64 identifiers.
- Check whether supplied profiles are public, friends-only, or unavailable.
- Build timestamped snapshots for scheduled change detection.
- Export normalized records to JSON, CSV, Excel, a webhook, or your database.
- Keep avatar and profile links current without maintaining a Steam scraper.

Every run processes only the identifiers and URLs you supply. The Actor does not search for people by name.

### Who is it for?

**Gaming community operators** can reconcile member-submitted Steam profiles and maintain a current directory.

**Trust and safety teams** can attach a stable SteamID64 and visibility status to user-provided profile links.

**Researchers and analysts** can produce repeatable public-profile snapshots without mixing profile identity with games or activity.

**Developers and data teams** can feed a narrow, typed Steam identity record into ETL, CRM, moderation, or monitoring workflows.

Choose [Steam Scraper](https://apify.com/automation-lab/steam-scraper) when you need Steam Store game search, prices, reviews, or release metadata instead of player profiles.

### Why use this Steam player lookup?

- Accepts both numeric SteamID64 values and `/profiles/...` or `/id/...` URLs.
- Resolves vanity URLs into canonical SteamID64 profile URLs.
- Uses Steam Community's small public XML representation, without a Steam Web API key.
- Distinguishes `found` and `not_found` records.
- Preserves privacy indicators instead of pretending hidden profile text is available.
- Deduplicates equivalent supplied targets within a run.
- Adds `scrapedAt` to support downstream snapshot comparisons.
- Applies bounded retries for temporary network and Steam service failures.

### Input

Provide at least one value in `profileIds` or `startUrls`.

| Field | Type | Default | Description |
| --- | --- | ---: | --- |
| `profileIds` | string array | — | SteamID64 identifiers beginning with `7656119`. |
| `startUrls` | URL array | — | HTTPS `steamcommunity.com/profiles/<SteamID64>` or `steamcommunity.com/id/<vanity>` URLs. |
| `maxItems` | integer | `100` | Maximum unique supplied profiles to process, from 1 to 1,000. |

You may combine both input routes. Exact duplicates are removed before requests are made.

#### Input example: SteamID64 batch

```json
{
  "profileIds": [
    "76561198000000000",
    "76561197960287930"
  ],
  "maxItems": 2
}
```

#### Input example: vanity URL

```json
{
  "startUrls": [
    { "url": "https://steamcommunity.com/id/gabelogannewell" }
  ],
  "maxItems": 1
}
```

### Getting started

1. Open the Actor in Apify Console.
2. Add one or more SteamID64 values, Steam Community profile URLs, or both.
3. Keep `maxItems` small for your first validation run.
4. Click **Start** and wait for the run to finish.
5. Open the default dataset to inspect normalized profile records.
6. Export the dataset or connect it to your integration.
7. For monitoring, schedule the same input and compare rows by `steamId64` and `scrapedAt`.

### Output fields

| Field | Meaning |
| --- | --- |
| `input` | Original identifier or URL supplied by the user. |
| `lookupStatus` | `found` or `not_found`. |
| `steamId64` | Resolved stable Steam account identifier, or `null`. |
| `displayName` | Current public Steam display name. |
| `onlineState` | Public online-state value returned by Steam. |
| `stateMessage` | Human-readable public presence message. |
| `privacyState` | Public privacy label such as `public` or `friendsonly`. |
| `visibilityState` | Numeric Steam visibility code; `3` means public. |
| `isPublic` | Convenience boolean derived from `visibilityState`. |
| `avatarIconUrl` | Small public avatar image URL. |
| `avatarMediumUrl` | Medium public avatar image URL. |
| `avatarFullUrl` | Full-size public avatar image URL. |
| `profileUrl` | Canonical SteamID64 profile URL when resolved. |
| `customUrl` | Optional public vanity name. |
| `headline` | Optional public profile headline. |
| `summary` | Optional public profile summary. |
| `location` | Optional self-declared public location. |
| `realName` | Optional self-declared public real name. |
| `memberSince` | Optional public account-creation label. |
| `scrapedAt` | UTC timestamp of the observation. |

Optional text fields are omitted when Steam does not expose them. Core unavailable values are `null` on a `not_found` record.

### Example output

This shortened example reflects real Actor output:

```json
{
  "input": "76561198000000000",
  "lookupStatus": "found",
  "steamId64": "76561198000000000",
  "displayName": "jolyne cujoh",
  "onlineState": "offline",
  "stateMessage": "Offline",
  "privacyState": "public",
  "visibilityState": 3,
  "isPublic": true,
  "avatarFullUrl": "https://avatars.fastly.steamstatic.com/9b07ffdad4718b9b131aa2df88478a8ff45181eb_full.jpg",
  "profileUrl": "https://steamcommunity.com/profiles/76561198000000000",
  "memberSince": "July 17, 2008",
  "scrapedAt": "2026-09-04T20:32:38.934Z"
}
```

Display names, presence, privacy, and optional text can change after this snapshot.

### Privacy and unavailable profiles

A friends-only profile can still expose limited identity, state, and avatar fields through Steam's public representation. The Actor reports those fields and sets `isPublic` to `false`; it does not attempt to bypass the profile's settings.

A syntactically valid target that Steam says does not exist produces a typed `not_found` record. Invalid identifiers, unsupported hosts, and non-profile paths fail the run so input errors do not look like real missing accounts.

### How much does it cost to look up Steam player profiles?

The Actor uses pay-per-event pricing:

- **$0.004** once per run for the `start` event.
- Per profile record, with the current BRONZE rate shown below.

At a BRONZE item price of **$0.0016 per profile**, estimated totals are:

| Useful profiles | Estimated total |
| ---: | ---: |
| 1 | $0.0056 |
| 10 | $0.0200 |
| 100 | $0.1640 |
| 1,000 | $1.6040 |

Higher subscription tiers receive lower item rates. Successful and explicit missing-profile lookup records are both charged under the single `item` event because each is a completed lookup result. Failed requests and rejected inputs do not produce item charges.

Always check the live pricing panel for the tier that applies to your Apify account.

### Scheduling profile snapshots

A schedule reruns the same watchlist at an interval you choose. Use `steamId64` as the stable join key and compare fields such as:

- `displayName`
- `onlineState`
- `privacyState`
- `isPublic`
- avatar URLs
- optional public headline or summary

The Actor emits current observations, not a historical change table. Store or compare prior datasets in your own workflow if you need alerts or history.

### Integrations and automation patterns

**Community enrichment:** submit member-provided URLs, then join output to your member table by SteamID64.

**Visibility monitoring:** schedule a compact watchlist and alert when `privacyState` differs from the prior snapshot.

**Vanity URL normalization:** resolve changing vanity URLs once, then retain canonical SteamID64 values downstream.

**Data warehouse ingestion:** use a webhook or API client to load each timestamped dataset into a snapshot table.

**Spreadsheet review:** export the overview view to CSV or Excel for moderators and community managers.

### Run through the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~steam-player-profile-lookup/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"profileIds":["76561198000000000"],"maxItems":1}'
```

To wait for completion and receive dataset items directly, use the `run-sync-get-dataset-items` endpoint.

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~steam-player-profile-lookup/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"startUrls":[{"url":"https://steamcommunity.com/id/gabelogannewell"}],"maxItems":1}'
```

Keep your token in an environment variable. Do not commit it to source control.

### JavaScript API example

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/steam-player-profile-lookup').call({
    profileIds: ['76561198000000000', '76561197960287930'],
    maxItems: 2,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Python API example

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/steam-player-profile-lookup').call(run_input={
    'startUrls': [{'url': 'https://steamcommunity.com/id/gabelogannewell'}],
    'maxItems': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with Apify MCP

Add the Actor to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/steam-player-profile-lookup"
```

For **Claude Desktop**, **Cursor**, or **VS Code**, add this HTTP MCP server in the client's MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/steam-player-profile-lookup"
    }
  }
}
```

Example prompts:

- "Look up these SteamID64 values and return display name, privacy state, and canonical URL."
- "Resolve this Steam vanity URL and tell me whether its public profile is visible."
- "Run my Steam profile watchlist and format the snapshot for a spreadsheet."

### Limits and reliability

- A run accepts at most 1,000 unique targets.
- The Actor performs direct requests; it does not expose or automatically enable paid proxy fallback.
- Temporary network errors, HTTP 429, and temporary 5xx responses are retried up to three total attempts.
- A persistent upstream failure fails the run visibly.
- Steam may change or retire its public XML profile representation.
- Presence and profile values are observations at run time, not guaranteed real-time events.
- Private settings determine which optional fields Steam exposes.
- The Actor does not find accounts from names, emails, phone numbers, or external gaming handles.

### Responsible use and legality

This Actor accesses only anonymously visible Steam Community profile data. Use it for a lawful purpose and follow Steam's terms, Apify's terms, and privacy/data-protection rules that apply to you.

Do not use public profile information for harassment, unwanted surveillance, identity deception, or discriminatory decisions. Avoid collecting more profiles or retaining personal text longer than your purpose requires. Respect deletion and access requests where applicable.

You are responsible for your input list, processing purpose, retention policy, and downstream use.

### Troubleshooting

#### The run says my input is unsupported

Use a 17-digit SteamID64 beginning with `7656119`, or an HTTPS URL whose host is exactly `steamcommunity.com` and whose path starts with `/profiles/` or `/id/`. Store/game/group URLs are outside this Actor's scope.

#### Why are headline, summary, or location missing?

Steam does not expose those fields for every account. Optional public text is omitted rather than filled with guessed values.

#### Why is a profile `not_found`?

Steam returned a structured missing-profile response for that valid identifier or vanity URL. Check the source URL in a browser and confirm it has not changed.

#### Why did the whole run fail?

Check the run log for input validation, rate limiting, or an unexpected Steam response. Retry a temporary service failure later; do not repeatedly rerun malformed input.

### FAQ

#### Does this Actor require a Steam API key or login?

No. It uses an anonymously accessible public profile representation and does not accept Steam credentials.

#### Does it return games, playtime, badges, groups, or activity?

No. The contract is intentionally profile-only. This keeps rows predictable and avoids implying access to hidden or unrelated data.

#### Can it search Steam players by display name?

No. Supply a SteamID64 or Steam Community profile URL. Display names are not stable or unique enough to identify an account safely.

### Related Automation Lab Actors

- [Steam Scraper](https://apify.com/automation-lab/steam-scraper) — Steam Store game search, prices, review summaries, platforms, and release dates.
- [Steam Game Reviews Scraper](https://apify.com/automation-lab/steam-game-reviews-scraper) — public game-review records and review metadata.
- [Steam Live Player Count Monitor](https://apify.com/automation-lab/steam-live-player-count-monitor) — current concurrent-player counts for Steam apps.

These Actors cover game and app workflows; this Actor remains focused on supplied public player profiles.

### Support

If a supported profile URL consistently returns an unexpected result, open an issue from the Actor page with:

- a non-sensitive example input;
- the run URL;
- the expected field or behavior;
- the observed output or error.

Do not include Apify tokens, Steam credentials, private account data, or unrelated personal information.

# Actor input Schema

## `profileIds` (type: `array`):

SteamID64 identifiers to resolve. You can combine these with profile URLs; duplicates are removed.

## `startUrls` (type: `array`):

Public steamcommunity.com/profiles/<SteamID64> or steamcommunity.com/id/<vanity> URLs.

## `maxItems` (type: `integer`):

Maximum number of unique supplied profiles to process.

## Actor input object example

```json
{
  "profileIds": [
    "76561198000000000",
    "76561197960287930"
  ],
  "startUrls": [
    {
      "url": "https://steamcommunity.com/id/gabelogannewell"
    }
  ],
  "maxItems": 10
}
```

# Actor output Schema

## `overview` (type: `string`):

Typed Steam player lookup records in the overview dataset view.

# 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 = {
    "profileIds": [
        "76561198000000000",
        "76561197960287930"
    ],
    "startUrls": [
        {
            "url": "https://steamcommunity.com/id/gabelogannewell"
        }
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/steam-player-profile-lookup").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 = {
    "profileIds": [
        "76561198000000000",
        "76561197960287930",
    ],
    "startUrls": [{ "url": "https://steamcommunity.com/id/gabelogannewell" }],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/steam-player-profile-lookup").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 '{
  "profileIds": [
    "76561198000000000",
    "76561197960287930"
  ],
  "startUrls": [
    {
      "url": "https://steamcommunity.com/id/gabelogannewell"
    }
  ],
  "maxItems": 10
}' |
apify call automation-lab/steam-player-profile-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/steam-player-profile-lookup"
        }
    }
}
```

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/fRCmTkMo0XGev6X6E/builds/9lSlqjZtsHt8fOvfB/openapi.json