How to Create an Automated Game Uploader on My Website

Below is a guide to using SteamPipe, Valve's tool for delivering content to Steam. For more data on best practices for updating your game, run into Updating Your Game - Best Practices.

Introduction to the SteamPipe Content System

SteamPipe is the game/application content organization that powers Steam. SteamPipe includes the following features:

• Efficient and fast content delivery.
  
• Public and private "beta" branches, allowing multiple builds to exist tested.
  
• Elementary web-based management of builds - push out a new build or rollback to a previous build with but a few clicks.
  
• Power to see the update size of a build earlier setting it live.
  
• Power to share content betwixt multiple applications.
  
• Power to build installer discs from public or beta content.
  
• Games/apps stay available offline even after an update download has been started.
  
• All content is ever encrypted, and non-active versions are not visible to customers.
  
• A SteamPipe Local Content Server which can be used during development.

Note: There are a few concepts which are integral to SteamPipe, before getting started you should be familiar with all of the concepts outlined in the Applications documentation. Having even a basic agreement of how these pieces fit together will be very useful when uploading your production to Steam.

Steamworks Video Tutorial - Building Your Game in Steampipe

This tutorial introduces SteamPipe and steps through building a sample awarding for Steam via the Steamworks tools.
https://www.youtube.com/watch?5=SoNH-v6aU9Q

Steamworks Video Tutorial - Adding New Platforms and Languages

This tutorial walks you through adding new platforms and languages to your game by calculation depots to your app.
https://www.youtube.com/watch?v=PShS32hcing

SteamPipe Technical Details

SteamPipe uses the HTTP protocol for content delivery. Since downloads are regular web traffic, any third-party HTTP enshroud between the client and Steam servers will increase download speed. Content tin be hosted by external CDN providers, which tin exist easily added to our content network. Virtually consumer firewalls allow HTTP traffic and won't cake downloads.

SteamPipe has an efficient patching algorithm based on binary deltas, merely changing the modified portions of existing content files. When this content is updated, but these deltas need be sent. This means both developer and user transfers are smaller and faster. Near partners will find that using a SteamPipe Local Content Server non necessary since they can efficiently patch builds on individual branches.

Steam Build Account

Earlier you can create any builds on Steam, yous must have a Steam business relationship in your Steamworks account with the "Edit App Metadata" and "Publish App Changes To Steam" permissions granted. For security reasons information technology'due south recommended that you have a dedicated build business relationship with just those permissions, you may create a new Steam account for this purpose at https://shop.steampowered.com/bring together.

Any ambassador of your Steamworks account can add a Steam business relationship and grant the necessary permissions. More data on this process can be institute in the Managing Your Steamworks Business relationship documentation. An example of what this account might await like is:

Initial Setup for New SteamPipe Apps

Follow these steps to fix new SteamPipe apps:

1. Find the app ID for your application (this can be found by selecting the awarding on your homepage in Steamworks)
   
2. Go to the General Installation Settings folio for your app.
   
3. Define at least one launch option (the path and optionally, any arguments required to launch the game). Hover over the (?) to learn more well-nigh each field.

   The example below shows 5 launch options, 2 for Windows, 2 for macOS and one for Linux.
   Launch option 3 will only be shown on Windows if the user also owns the DLC specified.

   

4. Go to the Depots folio and add depots equally needed for this app. By default, a depot may already exist configured for your application.
   
   1. Click the default depot and change the proper name of the depot to a proper and recognizable proper noun (such as "Base Content" or "Windows Content").
      
   2. Go out the language set to [All languages] unless this is a language-specific depot.
      
   3. Leave the OS ready to [All OSes] unless this is an OS-specific depot (if the app is all-in-i, or is only PC or just Mac, it should be left to [All OSes]. Only specify for OS-specific game depots.
      
   4. Click Add New Depot to create boosted depots.
      
   5. Click Save Changes to relieve any changes fabricated.
      
5. One time you are done defining your depots, publish the changes that you have fabricated from the Publish page.
   
6. Your newly defined depots will need to exist included in a parcel to grant you ownership of them. Each game on Steam should have a Developer Comp package which is automatically granted to the accounts listed within your publisher group.
   You tin add the new depots to that parcel (and/or other packages that should take these depots) on the Associated Packages & DLC folio.

Note: If your executable is in a sub-binder of the principal installation folder, add the sub-folder name in the Executable field. Don't utilise leading slashes or dots.

Platform Note: Every bit shown above, macOS applications may be launched past specifying either an app bundle (Game.app) or a script/binary (Game.app/Contents/MacOS/Game). In general the app bundle format should exist preferred if possible equally it allows macOS to more correctly determine launch parameters in the fashion information technology would if launched manually outside of Steam.

One case of this to note is that currently applications that are launched through an app packet on Apple Silicon devices will launch the best architecture available in the application whereas direct binary launches will employ the same architecture as the Steam process (currently x86_64).

Setting upwards the SDK for SteamPipe uploads

Download and unzip the latest version of the Steamworks SDK on the machine you lot volition exist uploading builds on.

The SteamPipe tools can exist plant within the SDK in the tools folder which contains 2 relevant sub-directories.

The ContentBuilder directory is where your game content and SteamPipe build tools will live. This directory contains the following sub-directories:

• architect - This directory initially contains just steamcmd.exe which is the command line version of Steam.
  
• builder_linux - The linux version of steamcmd.
  
• builder_osx - The macOS version of steamcmd.
  
• content - This directory contains all game files that will be congenital into depots.
  
• output - This directory volition exist the location for build logs, chunk cache, and intermediate output. Note: This folder can be deleted or emptied at any time, just afterwards it'southward deleted, the side by side upload time will have longer.
  
• scripts - This directory is where you'll identify all of your build scripts for edifice your game depots.

It's recommended that you run steamcmd.exe direct in the architect folder for your platform once to bootstrap your build organization. This should populate your architect directory with all the files it needs to build depots.

The ContentServer directory contains the tools for running your ain SteamPipe Local Content Server if you cull to do then.

SteamCmd on macOS

To enable SteamCmd on macOS you must complete the following steps:

1. From the final, scan to the tools\ContentBuilder\builder_osx\osx32 binder
   
2. Run chmod +10 steamcmd
   
3. Browse up to the parent folder (tools\ContentBuilder\builder_osx)
   
4. Type fustigate ./steamcmd.sh
   
5. SteamCmd will then run and update to the latest build, leaving you in the SteamCmd prompt
   
6. Type get out and press return to exit the prompt

Yous can and so follow the rest of this documentation (substituting paths as appropriate) to create depot and app config files for uploading your content to Steam.

Creating SteamPipe Build Config Files

To upload files for your app with SteamPipe, you must create scripts which describe your build and each depot that volition be included in it. The example scripts shown here are in the Tools\ContentBuilder\scripts folder in the Steamworks SDK.

SteamPipe GUI Tool

If yous're running on Windows and would prefer a GUI tool to help create these config files and upload your builds you can use the SteamPipeGUI which is available in the tools folder of the Steamworks SDK. Included in the zip are additional instructions to get you started.

If you choose to use the GUI tool then reading the following sections is still recommended to assist yous become more than familiar with how the SteamPipe system works.

Simple Build Script

Let's start with the about basic build script possible. In our example we have a game (AppID chiliad) that has one depot (DepotID 1001) and want to upload all files from a content folder and it'due south subfolders. Nosotros only demand a single build script for that, take a expect at "simple_app_build.vdf" included in the SDK :

"AppBuild" { "AppID" "thou" // your AppID "Desc" "This is a simple build script" // internal description for this build "ContentRoot" "..\content\" // root content folder, relative to location of this file "BuildOutput" "..\output\" // build output binder for build logs and build enshroud files "Depots" { "1001" // your DepotID { "FileMapping" { "LocalPath" "*" // all files from contentroot folder "DepotPath" "." // mapped into the root of the depot "recursive" "1" // include all subfolders } } } }

Adjust the AppID and DepotID for your game as needed. To kick off a build you need to run steamcmd and laissez passer a couple of parameters :

tools\ContentBuilder\builder\steamcmd.exe +login <account_name> <password> +run_app_build ..\scripts\simple_app_build.vdf +quit

NOTE: Your showtime effort at running a build may fail due to Steam Guard. If the login fails due to Steam Guard, bank check your email for the Steam Baby-sit code, and run steamcmd as: steamcmd.exe "set_steam_guard_code <code>", and attempt again. After logging in with Steam Baby-sit once, a sentry file is used to verify the login is genuine.

If you are using steamcmd from a machine or VM that gets re-imaged oftentimes, you should include the scout and config file in your prototype then you won't be prompted for a Steam Baby-sit every time. The sentry file is located in <Steam>\ssfn<hashOfNumbers>, and the config file is located in <Steam>\config\config.vdf.

The post-obit steps occur during a SteamPipe build:

1. Steamcmd.exe will update itself to the latest version.
   
2. Steamcmd.exe is logging into the Steam backend using the given architect Steam account.
   
3. The app build start is registered with the MDS (Primary Depot Server), which will ensure the user has the proper privileges to modify this app.
   
4. For each depot included in the app build, a file list is generated based on the files in the content folder and the filter rules divers in depot build config file.
   
5. Each file is scanned and divided into pocket-sized chunks of nigh 1MB. If the depot has been built before, this partitioning will preserve as many of the unchanged chunks as possible.
   
6. New file chunks are compressed, encrypted, and then uploaded to the MDS.
   
7. A final manifest is generated for this depot version; each manifest is identified by a unique 64-bit manifest ID.
   
8. Once all depots accept been candy, the MDS finishes this app build and assigns information technology a global BuildID.
   
9. Subsequently the build is done, there may exist *.csm and *.csd files in the build ouput binder. These are temporary and can exist deleted, but they speed upwardly subsequent build times.

One time the build is consummate you can encounter it on your app builds folio, in this instance information technology would exist https://partner.steamgames.com/apps/builds/1000. At that place you can set that build live for the default co-operative or any beta branch and users volition exist able to download this update with a couple of minutes.

Advanced Build Scripts

If your app has a lot of depots with circuitous file mapping rules, you can create a depot build script for each depot which volition be referenced by the app build script. Kickoff allow's take a look at available parameters in the app build script:

• AppID - The AppID of your game. The uploading Steam partner account needs 'Edit App Metadata' privileges
  
• Desc - The description is only visible to you in the 'Your Builds' section of the App Admin panel. This can be changed at whatsoever time after uploading a build on the 'Your Builds' page.
  
• ContentRoot - The root folder of your game files, can be an absolute path or relative to the build script file.
  
• BuildOutput - This directory volition be the location for build logs, depot manifests, chunk caches, and intermediate output. For best performance, use a separate disk for your build output. This splits the disk IO workload, letting your content root deejay handle the read requests and your output deejay handle the write requests.
  
• Preview - This type of build only outputs logs and a file manifest into the build output folder. Building preview builds is a good fashion to iterate on your upload scripts and make sure your file mappings, filters and properties work as intended.
  
• Local - Prepare this to the htdocs path of your SteamPipe Local Content Server (LCS). LCS builds put content merely on your ain HTTP server and permit you lot to test the installation of your game using the Steam client.
  
• SetLive - Beta branch proper noun to automatically fix live after successful build, none if empty. Note that the 'default' branch tin not be set live automatically. That must be done through the App Admin panel.
  
• Depots - This section contains all file mappings, filters and file properties for each depot or references a separate script file for each depot

Instance app build script "app_build_1000.vdf" is using all options:

"AppBuild" { "AppID" "grand" // Your AppID "Desc" "Your build description hither" // internal clarification for this build "Preview" "1" // brand this a preview build only, nothing is uploaded "Local" "..\..\ContentServer\htdocs" // put content on local content server instead of uploading to Steam "SetLive" "AlphaTest" // gear up this build live on a beta branch "ContentRoot" "..\content\" // content root binder relative to this script file "BuildOutput" "D:\build_output\" // put build enshroud and log files on different drive for improve performance "Depots" { // file mapping instructions for each depot are in separate script files "1001" "depot_build_1001.vdf" "1002" "depot_build_1002.vdf" } }

This app build script references two depot build script files that specify all file mappings and file properties. The post-obit instructions are available in a depot build script ( and too if the section is included directly into the app build script).

• DepotID - The DepotID for this section
  
• ContentRoot - Lets you optionally override the ContentRoot folder from the app build script on a per depot ground
  
• FileMapping - This maps a single file or a set of files from the local content root into your depot. There tin be multiple file mappings that add files to the depot. The LocalPath parameter is a relative path to the content root binder and may contain wildcards like '?' or '*'. It will as well apply to matching files in subfolders if Recursive is enabled. The DepotPath parameter specifies where the selected files should announced in the depot (use just '.' for no special mapping)
  
• FileExclusion - will excluded mapped files once more and can likewise contain wildcards like '?' or '*'
  
• InstallScript - will marker a file as install scripts and will sign the file during the build process. The Steam client knows to run them for whatsoever application which mounts this depot.
  
• FileProperties - will mark a file with special flags:
  
  • userconfig - This file is modified by the user or game. It cannot exist overridden by an update, and information technology won't trigger a verification error if information technology's unlike from the previous version of the file.
    
  • versionedconfig - Like to userconfig, however if the file is updated in the depot, information technology volition be overwritten locally when the user's game updates. Simply update the file in the depot when there is a necessary format modify or bug set up.

Instance depot build script depot_build_1002.vdf showing use of all options:

"DepotBuild" { "DepotID" "1002" "ContentRoot" "C:\content\depot1002" // override ContentRoot from app build script "FileMapping" { // all source files and folders in ".\bin" will be mapped into binder ".\executables" in depot "LocalPath" "bin\*" "DepotPath" "executables\" "Recursive" "1" // include all subfolders } "FileMapping" { // override audio files in \\audio with German versions "LocalPath" "localization\german\audio\*" "DepotPath" "audio\" } "FileMapping" { // re-create install script for german version into depot root folder "LocalPath" "localization\german\german_installscript.vdf" "DepotPath" "." } "FileExclusion" "bin\server.exe" // exclude this file "FileExclusion" "*.pdb" // exclude all .PDB files everywhere "FileExclusion" "bin\tools*" // exclude all files nether bin\tools\ "InstallScript" "localization\german\german_installscript.vdf" "FileProperties" { "LocalPath" "bin\setup.cfg" "Attributes" "userconfig" // this file volition be modified during runtime } }

NOTE: Y'all tin can name these scripts what ever you lot want, but nosotros utilize the names app_build_<AppID> and depot_build_<DepotID> for consistency. If you lot know that you'll exist building apps on this machine, information technology might be a adept idea to create sub-directories in your scripts directory for each awarding, to assist organize each application's build scripts.

Managing Updates

After your app releases to customers, your customers will exist receiving the build marked equally the Default build. When uploading a new build it's always a skilful thought to exam it before shipping it to your customers, for more information on how to successfully practice this see Testing On Steam.

Debugging Build Issues

If your build wasn't successful, you should look in your output directory for error data, not the console where the build script was run. Well-nigh error information can exist found in the *.log files.
You tin use these Steam client commands and client-side files to debug issues:

• "app_status [appid]" - Shows the current state of the app on this client.
  
• "app_info_print [appid]" - Shows the current Steamworks configuration for this game (depots, launch options, etc.).
  
• "app_config_print [appid]" - Shows the current user configuration for this game (electric current language, install directory, etc.).
  
• file "logs\content_log.txt" - Lists all logged SteamPipe operations and errors.
  
• file "steamapps\appmanifest_[appid].acf" - Shows the electric current install state of this app (KeyValues).

Building Efficient Depots for SteamPipe

The old Steam content system would patch updates on a file level, which meant that if a single byte in a file inverse, the entire new file would exist downloaded by all users. This was especially inefficient if the game used pack files, which are collections of game content files in a single large file. Pack files can easily exceed 1 GB, and then updates often led to unnecessarily large downloads. A common mode to avert these big downloads was to add together new pack files that overrode content of already shipped pack files. That worked for updates, simply information technology injure new users long-term, since they ended upwardly downloading unused, already-patched content.

The new content system fixes this problem past splitting each file into roughly 1-MB chunks. Each chunk is then compressed and encrypted earlier existence distributed by the Steam content system. If the game content has large redundant parts, these chunks are reused and the user only has to download each repeated chunk once. However, the real strength of this organisation is building efficient update patches. While the system is edifice a patch, the new content is scanned for already known chunks. If it finds them, it reuses them. This ways if you alter or inject a few bytes in a big file, the user only has to download the changes.

This works well in most cases, but there are even so a few pitfalls that need to be avoided when designing the content layout of a game. Y'all may not desire to compress or encrypt your game information. This is already done for in-flight downloads and retail discs by the Steam content arrangement. If y'all do it also, it can reduce the effectiveness of delta patching. Compression and encryption are simply brash if each individual asset within a package file is separately compressed and/or encrypted. Otherwise, a alter to 1 asset volition always require downloading several other potentially unchanged avails.

If you package multiple assets in a single pack file, brand sure that with each re-packaging, no unnecessary changes are made. One problematic practice is including the full proper noun of the original source files on disk, considering the names may change, depending on the build machine. Another bad design is including build time stamps for each file. If possible, always add new content to the end of your pack files and keep the order of existing files. Also, proceed your pack file'southward metadata (offset and sizes to private assets) in 1 place and don't intersperse it with the asset data. Utilize a binary difference tool like BeyondCompare to await at 2 builds of your pack files to make sure that hundreds of unwanted changes don't show upward.

If you lot follow these rules you volition minimize patch sizes and only new content will need to be downloaded. Your customers will thanks for that and you will exist able to increase the quality of your product past shipping more updates.

If you suspect that your game packaging is not interacting well with the SteamPipe update process, please contact your Valve representative and we can look into enabling advanced features to help with this.

Building Retail Install Discs

To build retail install disc for SteamPipe games, you must first setup a build project file.
In this example, the SKU file is chosen "sku_goldmaster.txt":

"sku" { "proper noun" "Exam Game Installer" "appid" "202930" "disk_size_mb" "640" "included_depots" { "one" "202931" "2" "202932" } }

Some tips to keep in mind:

• Create a new binder where the retail disc images will exist written to, e.chiliad., "D:\retail_disks". Only depots in the included_depots sections are added; in that location is no exclude section anymore.
  
• You tin can apply Steam.exe (with the -dev and -panel control-line parameters) or steamcmd.exe to build installer images. In both cases, use the "build_installer" command.
  
• Log on with a Steam business relationship that owns the game and all depots you want to put on the retail disc. Otherwise, the business relationship doesn't need special rights, then anyone can build installer discs.
  
• If you use Steam.exe, stop all other downloads.
  
• Go to the panel page and run the build_installer command:

  build_installer sku_goldmaster.txt "D:\retail_disks"

  The build can take a while since all depots are re-downloaded the first time.
  
• If yous're building a GM using a local content server, run:
  @localcontentserver "webserver"
build_installer sku_goldmaster.txt "D:\retail_disks" local
  The spew refers to 'Backup' since 'Retail install Disk' and local game backups are basically the same.
  
• Once you run into "Backup finished for AppID...", the install deejay images are ready. You tin observe more details about the fill-in build in logs\backup_log.txt.
  
• There are new folders (Disk_1, Disk_2, and and then on) in "D:\retail_disks", each not bigger than 640 MB, as specified with "disk_size_mb". Each deejay folder contains a "sku.sis" file and a .csd and .csm for each depot. Bigger depots span across multiple disks. All retail install disk content is always encrypted (unlike local game backup files). Copy the SDK GM setup files (setup.exe, setup.ini, etc.) into the folder of your first deejay and the retail disc installer is complete.
  
• When creating a GM for macOS be sure to open the goldmaster/disk_assets/SteamRetailInstaller.dmg image on a Mac. Then take the app that is in there and re-create information technology to the root of your media. You will probably want to alter the name of the install app, brand the icon and decorate the window to only show the installer.
  
• When creating a multi-disc GM for macOS, be sure the volume name for each disc matches. The volume name becomes function of the mount path, and if the names don't match the installer won't be able to find the next disc.

Optionally building a retail installer from a beta branch

The process above will create a retail installer based on the default branch. If y'all need to create an installer based on a beta branch, you must starting time create a beta branch named "baseline". Then use the following command to build from the baseline branch:

build_installer <projection file> <target binder> <beta key> <beta pwd> steamcmd ex: build_installer sku_goldmaster.txt "D:\retail_disks" baseline superSecret script ex: steamcmd.exe +login user_name password +build_installer "..\Build\GameDataSku.txt" c:\destination beta_key beta_password +get out

Installing DLC from a retail installer

In some circumstances, you lot may wish to create a retail installer that includes your DLC packages. In such cases, the procedure to create the installer requires only a few changes.
In "sku_goldmaster.txt", include the DLC AppIDs under the "included_depots" section. Once you lot have run the "build_installer" process, find the generated sku.sis file for the installer and open it with a text editor.
Add the DLC AppID in the "apps" section. For example, if I had a game with AppID m and DLC AppID 1010, I would suit the "apps" section as follows:

"apps" { "0" "1000" "1" "1010" }

This will ensure that Steam checks for ownership of the DLC and prompt the user for a key if the DLC is non owned by the account that they are logging into on Steam.

Edifice a retail installer for multiple App IDs on a single disc/install package

To build a GM containing multiple Steam Pipe apps. Build each app installer one by one just indicate them all to the same output folder. Each build will merge itself with the already existing install prototype.

Customizing a Retail install deejay

Encounter Customizing a gold master for more than details on customizing your retail install disk.

Preloading Games earlier Release

By default, all content is ever encrypted, on all retail discs and on all content servers. Switching a game to preload manner means owners can download the content, but it stays encrypted on the users' disk and tin can't be played. One time the game becomes officially released, Steam will decrypt the preloaded content and the user can play the game.

Switching a game to preload fashion is recommended in these cases:

• Shipping retail discs with production keys before the game is actually available (0-twenty-four hour period piracy).
  
• Games that run a pre-purchase and are larger than 20GBs in size.

Please submit a ticket to Steam Publishing if you believe your game requires preloading.

Building DLC

DLC is built as a depot of the base game. Run into the Downloadable Content (DLC) documentation for more information.

Troubleshooting SteamPipe

"Login Failure: Business relationship Login Denied Failed" when logging in via steamcmd

Cause: Probably SteamGuard is preventing login. Resolution:

• Cheque the e-mail associated with the account you are trying to log on with and look for an email from Steam Support. Re-create the code from that e-mail.
  
• Run the following steamcmd: set_steam_guard_code <code>
  
• Re-Attempt login from steamcmd: Steam>login <buildaccount> <password>

General Troubleshooting for Download Issues

• Restart calculator, modem, router, etc.
  
• Verify firewall settings. The new system requires port eighty (HTTP) and all other Steam ports, listed hither.
  
• Temporarily disable local Anti-Virus or Spam-Blocker programs.
  
• Check the Steam download region under Settings->Downloads. It should match your location.
  
• Stop the download, uninstall, and reinstall the game (clear manifest caches).
  
• Exit Steam, delete the two folders appcache and depotcache in your Steam install folder.
  
• Try to ready your Steam download region to some other location far abroad. This might work if a content server near you is serving bad data.

My Mac and/or Linux Builds aren't installing any files. Why?

If you're testing via Steam the installation of your game or application across multiple platforms, you may run into a situation where the build deploys on Windows but doesn't deploy any files on Mac or Linux despite your SteamPipe process being setup to upload Mac and/or Linux depots. There is a step that is hands missed which involves calculation your alternating Depots to the Packet being deployed. You tin can check what depots are included in a parcel via the following steps:

1. Navigate to your App Admin page
   
2. From the View Associated Items section, click All Associated Packages, DLC, Demos and Tools.
   
3. Click on the title of the Package you're attempting to download
   
4. Review the Depots Included section
   
5. Apply the Add/Remove Depots to ensure the correct fix of Depots are assigned to the Package

At that place are a number of discussion threads near this that may also assist:

• Empty binder after installing the game
  
• Unity Builds for PC/Mac/Linux
  
• Preparing Content for Mac Packaging

Running steamcmd.exe results in the post-obit fault: "SteamUpdater: Error: Steam needs to be online to update. Please ostend your network connectedness and attempt again."

Resolution: Go to Internet Options->Connections->Lan Settings and check Automatically detect settings.

Running the app build results in the post-obit error: "ERROR! Failed 'DepotBuild for scriptname.vdf' - status = half-dozen."

Possible Causes:

• Business relationship does not have permissions for the app.
  
  • Check that the app ID is correct in the app_build.vdf.
    
  • Cheque that the build account has proper permissions to the app ID.
    
• Steamcmd cannot observe the depot contents.
  
  • Check that the "contentroot" value in the app_build script is a valid path relative to the location of the script file.
    
  • Check that the "LocalPath" value in the depot_build script is a valid path relative to the path in the app_build script. Check that the path contains actual content.
    

Running the app build results in the following error: "ERROR! Failed to get application info for app NNNNN (check login and subscription)"

This means that Steam can't retrieve information nigh the app, either because it doesn't exist or the user doesn't have access to the app.

• Check that the NNNNN is the app ID you were assigned for the app.
  
• Bank check that the app ID is correct in the app_build.vdf.
  
• If it is a new app ID, check that the Steamworks app admin configuration has been published. New apps should take a Steam Piping install directory on the config tab, a depot on the depot tab, and all changes published on the publish tab.
  
• If all of that looks right, make sure that your account owns the app ID.

"An fault occurred while installing [AppName] (Invalid content configuration)" at launch fourth dimension

Possible Causes:

• No build has been set up live on the branch yous're trying to install from.
  Resolution: Set your build live on a branch past going to https://partner.steamgames.com/apps/builds/<YourGameAppId>, and select that branch in the Steam client (as described here).
  
• Invalid game launch options.
  Resolution: Verify the launch options on the Installation tab in the app admin for your game https://partner.steamgames.com/apps/config/<YourGameAppId>.
  
• You don't ain the Depot IDs that make up the game.
  Resolution: Make sure the necessary depots are added to the development subscription (Encounter Editing packages for additional details).

"Error code 15" at launch fourth dimension

This is the CEG servers rejecting the request to CEG the exe. Check the release country on the game page. If information technology is not 'playable', you will need to request Steam keys that override the release land.

"The Steam Servers are likewise busy to handle your request... Error Code (2)" at launch time

This is the CEG servers failing to notice a matching CEG exe. Double cheque that you accept a working CEG executable on the CEG tab of your app admin. Click the 'status' push to make sure that it'south propped.

I tin can't call back what that steamcmd command was or how it worked

Utilise the 'find' control in steamcmd to search for whatsoever steamcmd command. It will do partial matching on the command name and it will list out the command syntax.

Steam>find build_installer ConVars: Commands: build_installer : <project file> <target binder> <beta key> <beta pwd>

ortiziiii1978.blogspot.com

Source: https://partner.steamgames.com/doc/sdk/uploading

Share this post