Steam Integration

Track your game deployments on Steam with build status monitoring.

Table of contents

1. Overview
2. Configuration
   1. Connection Settings
   2. Credentials
3. Setup Steps
   1. 1. Get Your Publisher Key
   2. 2. Find Your App ID
   3. 3. Add the Integration
   4. 4. Configure Monitoring
4. Features
   1. Deployment Tracking
   2. Build Status
   3. Branch Information
   4. Linking to Build Runs
5. API Endpoints
   1. Steam Partner API
   2. ButterStack API
6. Webhook Support
   1. Deployment Webhook (from your build pipeline)
7. Deployment Statuses
8. Integration with SteamCMD
   1. Typical Upload Flow
   2. Build VDF Example
9. Troubleshooting
   1. Connection Failed
   2. App Not Found
   3. Build Status Not Updating
   4. Rate Limiting
10. Limitations
11. Best Practices

Overview

ButterStack integrates with Steam via the Partner Web API to track your deployments:

• Build status monitoring
• Branch/beta information
• Depot version tracking
• Live build detection
• Deployment lifecycle tracking

This is Stage 5 of the Asset Lineage Pipeline - tracking when your builds reach players.

Configuration

Connection Settings

Credentials

Setup Steps

1. Get Your Publisher Key

1. Log into Steamworks Partner Site
2. Go to Users & Permissions
3. Click Manage Group Permissions
4. Generate or copy your Publisher Web API Key

Note: This key has access to all your apps. Keep it secure.

2. Find Your App ID

Your App ID is visible in the Steamworks dashboard URL:

https://partner.steamgames.com/apps/landing/480
                                           ^^^
                                         App ID

3. Add the Integration

1. Go to Project Settings > Integrations
2. Click Add Integration
3. Select Steam
4. Enter your App ID and Publisher Key
5. Click Test Connection
6. Save the integration

4. Configure Monitoring

Set which branch to monitor (default is public):

• public - Main release branch
• beta - Beta testing branch
• Custom branch names as configured in Steamworks

Features

Deployment Tracking

ButterStack tracks the deployment lifecycle:

pending → submitted → uploading → in_review → approved → live
                                           ↘ rejected

When you upload a build to Steam, ButterStack:

1. Detects the new build via API polling
2. Creates a Deployment record
3. Links it to the associated BuildRun
4. Tracks status changes until the build goes live

Build Status

Check if a specific build is live:

• Which depot version is on which branch
• When the build was set live
• Build ID and description

Branch Information

View all branches/betas for your app:

• Branch name
• Access requirements (password, time-limited)
• Current build ID

Linking to Build Runs

Deployments automatically link to BuildRuns when:

1. Build completes in Jenkins
2. Build is uploaded to Steam
3. ButterStack matches the build based on:
   • Timestamp proximity
   • Build description/notes
   • Manual linking

API Endpoints

Steam Partner API

ButterStack uses these Steam endpoints:

ButterStack API

List Deployments:

GET /api/v1/projects/{project_id}/deployments

Get Deployment:

GET /api/v1/projects/{project_id}/deployments/{deployment_id}

Create Deployment (manual):

POST /api/v1/projects/{project_id}/deployments
{
  "platform": "steam",
  "build_run_id": 123,
  "steam_app_id": "480",
  "steam_branch": "public"
}

Webhook Support

Steam doesn’t support outbound webhooks. ButterStack uses polling instead.

Deployment Webhook (from your build pipeline)

If you want faster detection, call ButterStack when you upload:

POST /webhooks/deployment?token={webhook_token}
{
  "platform": "steam",
  "event": "uploaded",
  "steam_app_id": "480",
  "build_id": "12345678",
  "branch": "public"
}

Deployment Statuses

Integration with SteamCMD

ButterStack tracks deployments made via SteamCMD.

Typical Upload Flow

1. Build completes in Jenkins
2. Jenkins runs SteamCMD to upload:

   steamcmd +login user pass +run_app_build app_build.vdf +quit
   

3. ButterStack detects new build via API polling
4. Deployment record created and linked

Build VDF Example

"AppBuild"
{
    "AppID" "480"
    "Desc" "Build 123 - PROJ-456 new weapons"
    "ContentRoot" "./build/Steam"
    "BuildOutput" "./build/output"
    "Depots"
    {
        "481"
        {
            "FileMapping"
            {
                "LocalPath" "*"
                "DepotPath" "."
                "recursive" "1"
            }
        }
    }
}

Troubleshooting

Connection Failed

Error: Invalid publisher key

• Verify key is from Publisher Web API (not regular Steam API)
• Check key hasn’t been regenerated
• Ensure account has app access

App Not Found

Error: App ID not found

• Verify App ID is correct
• Ensure your publisher account has access to the app

Build Status Not Updating

• Check poll interval (default 5 minutes)
• Verify branch name matches exactly
• Review ButterStack logs for API errors

Rate Limiting

Error: 429 Too Many Requests

• Increase steam_poll_interval
• Steam limits API calls per key

Limitations

• Read-only: ButterStack cannot trigger uploads to Steam
• Polling-based: No real-time webhooks from Steam
• Publisher key required: Regular Steam API keys won’t work
• No store page access: Only app/depot build information

Best Practices

1. Secure your publisher key - It has broad access
2. Use meaningful build descriptions - Helps with linking
3. Set appropriate poll interval - Balance freshness vs API limits
4. Integrate with Jenkins - Notify ButterStack when uploading
5. Track multiple branches - Create separate integrations per branch if needed