Steam Library Data Export Tool: Let AI Help You Pick Games from Your Backlog

A Small Open-Source Tool Born from "Game Choice Paralysis"

As game libraries keep growing, many players find themselves trapped in the same predicament: faced with hundreds of unfinished games, they can't decide which one to play next. Reddit developer TohnoCoding recently open-sourced a small console tool called Steam Library Data Exporter, designed precisely to solve this "paradox of choice" pain point.

The core functionality of this Steam library export tool is straightforward: after you set your Steam profile to public, it calls the Steamworks Web API to fetch your user and game data, then generates a JSON file as a complete snapshot of your library. The Steamworks Web API is a set of RESTful HTTP interfaces that Valve offers to developers, allowing third-party programs to access public data on the Steam platform through standard GET/POST requests. Commonly used endpoints include IPlayerService/GetOwnedGames (retrieves a user's owned games and playtime) and ISteamUserStats/GetPlayerAchievements (retrieves achievement data). These endpoints can only access data from users who have set their profiles to "public" — this serves both as a functional prerequisite and a layer of privacy protection by design.

The development motivation behind it is worth noting. The author mentioned being deeply moved after playing the indie game 1000xRESIST — a narrative adventure game released in 2024 by Canadian indie studio sunset visitor. The game received critical acclaim upon release and ranked highly in multiple year-end awards. Wrapped in a sci-fi shell, it tells a profound story about memory, identity, and cultural trauma, with its narrative structure deeply influenced by oral history and the Asian immigrant experience. It demands almost nothing in terms of mechanical skill, with virtually no traditional "combat" or "skill challenges" — the core experience is built entirely on exploration, dialogue, and emotional resonance. The author candidly admitted that with age, his reflexes have slowed considerably. He wanted to compile a list of his games, feed it to an AI/large language model, describe his tastes, limitations, preferences, and desired game characteristics, and let the AI recommend suitable titles from his ever-growing backlog.

How Steam Library Data Exporter Works

Prerequisites and Workflow

From a technical standpoint, this is a classic "microtool." The entire workflow is streamlined to the bare minimum:

• Obtain a Steamworks API Key (the repository provides instructions on how to apply). API Keys can be requested for free on the Steam developer page — each Steam account can get one. Valve imposes lenient rate limits on API calls but reserves the right to ban abusive usage.
• Find your Steam64 User ID (detailed instructions also included). A Steam64 ID (also known as SteamID64) is a 64-bit integer that uniquely identifies each user on the Steam platform, typically in the format of a 17-digit number like 76561198XXXXXXXXX. Steam actually uses multiple ID formats — the legacy SteamID (e.g., STEAM_0:1:12345678), SteamID3 (e.g., [U:1:24691357]), and SteamID64 — all of which are interconvertible, but the Web API uniformly uses SteamID64 as its parameter. Users can find theirs through the "Account Details" page in the Steam client or by using third-party lookup tools like steamid.io.
• Enter both parameters into the console application

The program then iterates through all games in your account and generates a JSON file on your desktop. The entire project is open-sourced under the MIT License, allowing free use and modification. The GitHub repository is at github.com/TohnoCoding/SteamLibraryDataExporter. The MIT License originated at the Massachusetts Institute of Technology and is one of the most popular open-source licenses on GitHub today. It permits anyone to freely use, copy, modify, merge, publish, distribute, sublicense, and sell copies of the software, with the sole requirement of retaining the original copyright notice. Unlike copyleft licenses such as GPL, MIT does not require derivative works to also be open-sourced, making it extremely friendly for commercial use and secondary development.

Exported Data Structure in Detail

Based on the real sample provided by the author, the exported fields are quite pragmatic. Each game includes the following information:

• AppId / Name: The game's application ID and title
• PlaytimeForever: Total playtime (formatted as hours:minutes:seconds)
• PlaytimeLast2Weeks: Playtime in the last two weeks
• HasAchievements / TotalAchievements / ObtainedAchievements: Achievement system data
• AchievementPercentage: Achievement completion percentage
• LastPlayed: Last played timestamp (ISO 8601 format)

ISO 8601 is an international standard for date and time representation established by the International Organization for Standardization. The most common format is YYYY-MM-DDTHH:MM:SSZ, for example 2025-01-15T08:30:00Z. The T separates the date from the time, and the trailing Z indicates Coordinated Universal Time (UTC). The key advantage of this standard is eliminating ambiguity between date formats used in different countries — for instance, 01/02/2025 means January 2nd in the US but February 1st in most European countries. In API design and data exchange, ISO 8601 has become the de facto standard, facilitating programmatic parsing and cross-system interoperability.

Taking 1000xRESIST from the sample as an example, the data shows a total playtime of 20 hours and 16 minutes, with 11 hours and 42 minutes invested in the last two weeks, all 32 achievements unlocked, and 100% completion. For unplayed games like Amerzone, most fields are null — the data structure handles empty values cleanly.

Data Export + LLM: A New Paradigm for Personalized Game Recommendations

The tool itself isn't technically complex — it's essentially a wrapper around public Web APIs. But what makes it truly interesting is the emerging usage paradigm it reveals: exporting personal structured data and handing it to large language models for personalized analysis and recommendations.

Traditional game recommendations rely on platform algorithms (like Steam's Discovery Queue), which are typically based on collaborative filtering and sales popularity. These approaches struggle to capture a player's nuanced, verbalized preferences — such as "I want something narrative-driven, not mechanically demanding, with puzzle elements." Collaborative Filtering is one of the most classic algorithmic paradigms in recommendation systems. Its core idea is: "things liked by people with similar behavior to yours are things you might like too." It comes in two main varieties: user-based collaborative filtering finds "neighbor users" with behavior patterns similar to the target user, then recommends items those neighbors enjoyed but the target user hasn't encountered; item-based collaborative filtering calculates similarity between items and recommends items similar to ones the user already likes. These algorithms rely on aggregate behavioral statistics, making them unable to understand nuanced preferences expressed in natural language, and they tend to fall into "popularity bias" — over-recommending popular games with abundant user data while overlooking niche indie gems that might perfectly match a user's taste.

When players convert their play history (playtime, achievement completion, recent activity) into structured JSON and pair it with natural language descriptions of their preferences, LLMs can perform semantic recommendations that more closely mirror human thinking. The recommendation capability of large language models is fundamentally a different paradigm from traditional recommendation systems: traditional systems map users and items into numerical vectors and find matches through mathematical methods like cosine similarity, while LLMs can parse complex semantic requests like "I want a game with a relaxed pace, no need for fast reflexes, but with deep worldbuilding" and match them against the vast corpus of game reviews, community discussions, and official descriptions accumulated during training. This means LLMs can handle "soft preferences" that traditional recommendation systems cannot encode. Of course, LLMs have limitations too: their recommendations are bounded by the training data cutoff date, they may lack knowledge of newly released games, and they cannot capture real-time group behavior trends the way collaborative filtering can.

In other words, the author used this small tool to build a bridge: connecting the objective data of "what I've played, for how long, and how much I've completed" with the subjective expression of "what I enjoy, what I'm good at, and what I'm looking for" — turning AI into a personal game advisor that truly understands you.

Recommendation Value of Each Data Field

Looking closely at the exported fields, you'll notice they're quite meaningful for AI-powered recommendations:

• Total playtime reflects depth of engagement — long playtime often represents genuine interest
• Achievement completion rate distinguishes "briefly tried" from "deeply completed" — 100% completion is a strong preference signal
• Last played time reveals recent interest trends

Combined, these dimensions allow AI to construct a remarkably multidimensional player profile, enabling personalized game recommendations that are more precise than what platform algorithms typically offer.

Insights Behind a Small Tool: Personal Data Applications in the AI Era

Though small in scale, this tool reflects an important trend in personal data applications in the AI era: more and more users are proactively exporting and organizing their data scattered across various platforms, using it as raw material to "feed" to LLMs. Whether it's a Steam game library, reading history, listening history, or fitness data — as long as it can be exported in a structured format, it can serve as input for personalized AI services. This trend actually aligns with the "Right to Data Portability" established in the EU's General Data Protection Regulation (GDPR) — users have the right to obtain their personal data in a structured, machine-readable format and transfer it to other service providers. While Steam didn't open its API because of GDPR, the philosophy of "users owning and actively leveraging their own data" is becoming mainstream.

Of course, it's worth noting that tools like this depend on public account profiles and API Keys, which involves certain privacy considerations. Fortunately, such microtools typically run locally, are open-source and transparent, and offer controllable data flows — this tool's MIT license and desktop-local export design embody the principle of "keeping data in your own hands."

For players tormented by choice paralysis, rather than being led around by platform algorithms, why not export your data yourself and let AI pick your next game based on your real preferences? This is perhaps why a small tool with just a few dozen lines of code can resonate so widely.

Key Takeaways