Steam is one of the largest gaming platforms in the world, with over 50,000 games and millions of daily active users. Whether you're building a game market research tool, tracking prices, or analyzing player reviews, Steam's public API makes it surprisingly easy to get data — no API key required.
In this guide, I'll show you how to use Steam's public REST endpoints to search games, fetch details, and pull reviews using nothing but Python and requests.
Why Steam Data Matters
Game developers, market researchers, and indie studios all need Steam data:
- Price tracking — monitor sales and regional pricing
- Review sentiment — understand what players love or hate
- Market research — find gaps in genres or trending themes
- Competitor analysis — track player counts and ratings
The good news? Steam exposes three clean REST endpoints that return JSON. No authentication, no rate limit headaches (within reason), no scraping HTML.
The Three Key Endpoints
Steam gives you everything through these public APIs:
- Store Search — find games by keyword
- App Details — full metadata for any game
- App Reviews — player reviews with ratings
Let's walk through each one.
1. Searching for Games
The store search endpoint lets you find games by keyword:
import requests
url = "https://store.steampowered.com/api/storesearch/"
params = {
"term": "civilization",
"l": "english",
"cc": "US"
}
response = requests.get(url, params=params)
data = response.json()
for item in data["items"]:
price = item.get("price", {})
cost = f"${price.get('final', 0) / 100:.2f}" if price else "Free"
print(f"{item['name']} (AppID: {item['id']}) - {cost}")
This returns a list of matching games with their AppIDs, names, logos, and prices. The AppID is your key to everything else.
Pro tip: The cc parameter controls the country for pricing. Change it to GB, DE, or JP to compare regional prices.
2. Getting Game Details
Once you have an AppID, you can pull the full details:
import requests
appid = 570 # Dota 2
url = f"https://store.steampowered.com/api/appdetails?appids={appid}"
response = requests.get(url)
data = response.json()
if data[str(appid)]["success"]:
game = data[str(appid)]["data"]
print(f"Name: {game['name']}")
print(f"Type: {game['type']}")
print(f"Developer: {', '.join(game.get('developers', []))}")
print(f"Publisher: {', '.join(game.get('publishers', []))}")
print(f"Genres: {', '.join(g['description'] for g in game.get('genres', []))}")
print(f"Release: {game.get('release_date', {}).get('date', 'TBA')}")
print(f"Metacritic: {game.get('metacritic', {}).get('score', 'N/A')}")
print(f"Free: {game.get('is_free', False)}")
The response is rich — you get descriptions, screenshots, system requirements, DLC lists, categories, and more. For paid games, you also get price info with currency and discount percentages.
Batch requests: You can request multiple AppIDs at once by comma-separating them: appids=570,730,440. This is much faster than individual calls.
3. Pulling Player Reviews
The reviews endpoint is where things get really interesting for analysis:
import requests
appid = 570 # Dota 2
url = f"https://store.steampowered.com/appreviews/{appid}"
params = {
"json": 1,
"language": "english",
"num_per_page": 20,
"filter": "recent",
"purchase_type": "all"
}
response = requests.get(url, params=params)
data = response.json()
summary = data["query_summary"]
total = max(summary["total_reviews"], 1)
print(f"Total reviews: {summary['total_reviews']:,}")
print(f"Positive: {summary['total_positive']:,} ({summary['total_positive']/total*100:.1f}%)")
print(f"Negative: {summary['total_negative']:,}")
for review in data["reviews"][:5]:
voted = "+" if review["voted_up"] else "-"
hours = review["author"]["playtime_forever"] // 60
print(f"\n{voted} ({hours}h played): {review['review'][:150]}...")
Each review includes the author's playtime, helpful votes, comment count, and whether it was received for free. You can paginate through all reviews using the cursor parameter.
Filter options: Use filter=recent for newest, filter=updated for recently updated, or filter=all for the default sort.
Putting It Together: A Game Research Script
Here's a practical example that searches for a genre and builds a dataset:
import requests
import time
def research_games(keyword, max_results=10):
search = requests.get(
"https://store.steampowered.com/api/storesearch/",
params={"term": keyword, "l": "english", "cc": "US"}
).json()
results = []
for item in search["items"][:max_results]:
appid = item["id"]
time.sleep(1) # Be respectful
details = requests.get(
f"https://store.steampowered.com/api/appdetails?appids={appid}"
).json()
if not details[str(appid)]["success"]:
continue
game = details[str(appid)]["data"]
reviews = requests.get(
f"https://store.steampowered.com/appreviews/{appid}",
params={"json": 1, "language": "english", "num_per_page": 0}
).json()
summary = reviews.get("query_summary", {})
total = max(summary.get("total_reviews", 1), 1)
results.append({
"name": game["name"],
"appid": appid,
"developer": ", ".join(game.get("developers", [])),
"genres": ", ".join(g["description"] for g in game.get("genres", [])),
"total_reviews": summary.get("total_reviews", 0),
"positive_pct": round(summary.get("total_positive", 0) / total * 100, 1),
"is_free": game.get("is_free", False)
})
return results
games = research_games("roguelike")
for g in games:
print(f"{g['name']}: {g['positive_pct']}% positive ({g['total_reviews']:,} reviews)")
Rate Limits and Best Practices
Steam doesn't publish official rate limits, but from experience:
- Add 1-second delays between requests
- Cache responses — game details don't change often
- Use batch endpoints where available
- Set a proper User-Agent header
For production workloads or large-scale data collection, consider using a managed solution like Steam Scraper on Apify which handles rate limiting, retries, and data formatting automatically.
What You Can Build
With these three endpoints, you can build:
- Price comparison tools across regions
- Review sentiment dashboards for game studios
- Genre trend trackers for market research
- Wishlist monitors that alert on sales
- Competitor analysis tools for indie devs
Steam's public API is one of the most generous in the gaming industry. No API key, no OAuth dance, just clean JSON endpoints that return rich data. Start building!
Top comments (0)