Syncing Steam Game Library Data to Excel

Alright, let’s talk about a little side project that ended up saving me a surprising amount of time. As a gamer and a data enthusiast, I like to keep track of my game library—playtime, genres, you name it. For years, I was manually updating a spreadsheet whenever I remembered to. It was a tedious process, and I realized I was wasting a good hour or two every month just on data entry. That’s when I decided to automate it. This guide will walk you through the exact process I built to pull Steam library data directly into an Excel file, so you can spend more time gaming and less time logging.

Prerequisites

Before we dive in, make sure you have the following ready. This whole setup shouldn’t take more than 20 minutes if you have these on hand.

• A Steam API Key. You can get one for free from the Steam Community Developer page.
• Your 64-bit Steam ID. If you don’t know it, you can find it using a tool like SteamID.io.
• Python 3 installed on your system.
• A few Python libraries: requests, pandas, and openpyxl. You’ll install these in your project environment.

The Guide: Step-by-Step

Step 1: Project Setup

First things first, let’s get our workspace organized. Create a new directory for this project. I’ll skip the standard virtualenv setup since you likely have your own workflow for that. Just make sure you’re working in an isolated environment. Once that’s active, you’ll need to install the necessary packages. You can do this by running a command like pip install requests pandas openpyxl python-dotenv in your terminal.

Next, create two files in your project directory: config.env for our secrets and steam_sync.py for our script.

Step 2: Storing Your Credentials

Never hardcode API keys or personal IDs in your scripts. It’s a security risk and a pain to update. Instead, we’ll use our config.env file. Open it and add your credentials like this:

STEAM_API_KEY="YOUR_API_KEY_HERE"
STEAM_ID="YOUR_64_BIT_STEAM_ID_HERE"

Replace the placeholder text with your actual key and ID. The python-dotenv library will allow our script to read these values securely.

Step 3: The Python Script

Now for the main event. Open steam_sync.py and let’s build this out. I’ll break down each part of the code so you understand the logic behind it, not just copy-pasting.

First, we import our libraries and load the environment variables from config.env.

import os
import requests
import pandas as pd
from dotenv import load_dotenv

# Load environment variables from config.env
load_dotenv('config.env')

# Retrieve credentials
API_KEY = os.getenv('STEAM_API_KEY')
STEAM_ID = os.getenv('STEAM_ID')

Next, we’ll define the function that fetches the data. This function constructs the API URL, makes the request, and includes basic error handling. If the request fails, it’s better to know why than to have the script crash silently.

def get_owned_games(api_key, steam_id):
    """Fetches a user's owned games from the Steam API."""
    url = "http://api.steampowered.com/IPlayerService/GetOwnedGames/v0001/"
    params = {
        'key': api_key,
        'steamid': steam_id,
        'format': 'json',
        'include_appinfo': True,
        'include_played_free_games': True
    }

    try:
        response = requests.get(url, params=params)
        response.raise_for_status()  # This will raise an HTTPError for bad responses (4xx or 5xx)
    except requests.exceptions.RequestException as e:
        print(f"API Request failed: {e}")
        return None

    data = response.json()
    return data.get('response', {}).get('games', [])

Pro Tip: The `include_appinfo=True` parameter is a lifesaver. Without it, the API only returns App IDs, and you’d have to make a separate API call for every single game to get its name. This one flag saves hundreds of potential requests.

Now we need to process that data. The API returns a JSON object, but we want a clean, tabular format for Excel. This is where Pandas shines. We’ll convert the list of games into a DataFrame, select the columns we care about, and do a little cleanup.

def process_game_data(games_list):
    """Processes the raw game data into a clean Pandas DataFrame."""
    if not games_list:
        print("No game data to process.")
        return pd.DataFrame()

    df = pd.DataFrame(games_list)

    # We only want a few specific columns
    columns_to_keep = ['name', 'playtime_forever', 'playtime_2weeks']
    df = df[columns_to_keep]

    # Convert playtime from minutes to hours for better readability
    df['playtime_forever'] = round(df['playtime_forever'] / 60, 2)
    
    # Check if 'playtime_2weeks' exists before converting, as it may be absent
    if 'playtime_2weeks' in df.columns:
        df['playtime_2weeks'] = round(df['playtime_2weeks'] / 60, 2)
    else:
        df['playtime_2weeks'] = 0 # Add the column with a default value if it's missing

    # Rename columns to be more descriptive
    df.rename(columns={
        'name': 'Game Title',
        'playtime_forever': 'Total Playtime (Hours)',
        'playtime_2weeks': 'Playtime Last 2 Weeks (Hours)'
    }, inplace=True)
    
    # Sort by total playtime, descending
    df = df.sort_values(by='Total Playtime (Hours)', ascending=False)
    
    return df

Finally, let’s bring it all together in a main execution block that calls our functions and saves the result to an Excel file.

def main():
    """Main function to run the sync process."""
    if not API_KEY or not STEAM_ID:
        print("Error: STEAM_API_KEY or STEAM_ID not found in config.env")
        return

    print("Fetching Steam library data...")
    games = get_owned_games(API_KEY, STEAM_ID)

    if games is not None:
        print(f"Found {len(games)} games. Processing...")
        games_df = process_game_data(games)
        
        if not games_df.empty:
            output_filename = 'My_Steam_Library.xlsx'
            games_df.to_excel(output_filename, index=False, engine='openpyxl')
            print(f"Successfully saved data to {output_filename}")
        else:
            print("No data was processed to save.")

if __name__ == "__main__":
    main()

Step 4: Automation

Running this script manually is fine, but the real power is in automation. In my production setups, I use system schedulers to handle this. For example, on a Linux system, you can set up a cron job to run this script automatically. To run it every Monday at 2 AM, your cron entry might look like this:

0 2 * * 1 python3 steam_sync.py

Just remember that the command needs to be executed from within your project directory for the relative paths to work, or you’ll need to use full paths in your script and cron command.

Common Pitfalls

Here’s where I usually mess things up, so hopefully you can avoid these.

• Invalid Steam ID: Make sure you’re using your 64-bit numeric Steam ID, not your custom URL or login name. The API is very specific about this.
• API Rate Limits: While this script is efficient, if you modify it to make calls for every game, you can hit the API rate limit. Steam is pretty generous, but it’s something to be aware of if you expand this project.
• Missing Playtime Data: The ‘playtime_2weeks’ field doesn’t appear for games you haven’t played recently. My script now checks if the column exists before trying to process it, preventing a nasty KeyError that used to trip me up.

Conclusion

And there you have it. A simple, robust script that automates the tedious task of tracking your game library. This is a great foundation—you can easily expand it to pull more data, visualize your playtime with other libraries like Matplotlib, or even push the data to a different destination like a Google Sheet. By automating these small, repetitive tasks, we free up valuable time to focus on more complex engineering challenges. Or, you know, to actually play some of the games in that library.

Darian Vance

Lead Cloud Architect & DevOps Strategist

With over 12 years in system architecture and automation, Darian specializes in simplifying complex cloud infrastructures. An advocate for open-source solutions, he founded TechResolve to provide engineers with actionable, battle-tested troubleshooting guides and robust software alternatives.

🤖 Frequently Asked Questions