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

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

Input example: vanity URL

{
  "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:

{
  "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

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.

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

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

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:

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:

{
  "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 — Steam Store game search, prices, review summaries, platforms, and release dates.
• Steam Game Reviews Scraper — public game-review records and review metadata.
• 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.