How to Publish a Game on Steam (2026): Costs and Steps

Learning how to publish a game on Steam is mostly paperwork, a store page and one upload tool, and none of it is as scary as forum threads make it sound. You sign up for Steamworks, Valve’s developer portal, pay a per-game fee, fill in tax and bank details, build a store page, upload your game files, and pass a review. The part that actually decides whether your game succeeds is what you do between creating the store page and pressing the release button.

This guide walks through every stage in order, gives you the real costs that Valve publishes, shows a working SteamPipe build script, and explains how to turn a browser game into something Steam will accept. If you are still deciding whether to make games at all, start with our beginner’s roadmap to becoming a game developer.

What publishing on Steam actually involves

Steam is Valve’s digital distribution platform for PC games, and it runs an open submission system called Steam Direct. There is no gatekeeper approving your idea in advance. Anyone who completes the steps and passes review can list a game. That openness is good news for hobbyists, and also the reason the store is crowded.

A few terms you will meet constantly:

• Steamworks: the partner site where you manage everything, from forms to store pages to builds.
• App ID: the unique number Valve gives your game once you pay the fee. Your store page, builds and achievements all hang off it.
• Depot: a bundle of files inside your app, usually one per operating system (for example, one depot for Windows, one for macOS).
• Build: one uploaded version of your game’s files. You can upload many and choose which one players get.
• SteamPipe: Valve’s content delivery system. You upload builds to it with a command-line tool called SteamCMD.
• Capsule: the promotional images that represent your game across the store, in search lists, sales and the library.
• Wishlist: a player’s “notify me” list. Wishlisted players get an alert when you launch or go on sale.

Steam is mainly a PC store, so it expects a desktop executable, not a web page. That matters if your game runs in a browser, and we will cover the fix below. Valve has also widened the formats it takes: Android APKs can now be published to Steam for its Steam Frame headset, though most indie developers will start with a Windows build.

How much it costs to publish a game on Steam

The direct cost is small. As of October 2026, Steam Direct charges US$100 per game, and Valve pays that fee back once the game earns US$1,000 in sales. On every sale, Valve keeps a share of revenue, 30% by default, with lower rates kicking in only for games that earn very large amounts.

Cost	Amount	Notes
Steam Direct fee	US$100 per game	Recouped after US$1,000 in sales
Revenue share	30% by default	Lower tiers only for very high earners
Updates and patches	No charge	Upload as many builds as you like
Free-to-play games	Same fee	A free game never earns it back

The fee is per app, so a demo usually lives under your main game rather than as a separate paid listing, while a sequel or spin-off needs its own fee. The hidden costs are elsewhere: capsule art, a trailer, music, and your time. Those are the parts where AI tools save the most money for a solo developer, and we will get to them.

Can you publish on Steam without paying? Only if a publisher signs your game and pays the fee for you. Otherwise the US$100 is the price of entry, and for most people it is the cheapest part of the whole project.

How to publish a game on Steam, step by step

Here is the full sequence. The order matters, because some steps involve waiting, and you want those waits running while you finish the game.

1. Create a Steamworks account and complete the paperwork

Sign up as a Steamworks partner with your Steam account. Valve asks for your legal name or company name, a bank account for payouts, and tax information. Non-US developers fill in a tax form that determines how much US tax is withheld; your country’s treaty with the US may reduce it. Valve also verifies your identity. Do this early, because verification can take a while and nothing else unlocks until it is done.

2. Pay the Steam Direct fee

Paying the fee creates your App ID. Valve applies a waiting period between paying and being allowed to release, and its Steamworks documentation lists the current timings. Pay months before launch, not the week of.

3. Build your store page and mark it “Coming Soon”

This is the most important marketing step. Your store page needs a description, capsule images, at least a handful of screenshots, ideally a trailer, system requirements, and tags. You also complete a content survey, which covers mature content and asks you to disclose any AI-generated content and how it is used. Valve reviews the page before it goes public, and once approved it appears as “Coming Soon” so players can wishlist it. Steam requires the page to be public for a period before release.

4. Collect wishlists

Wishlists are the closest thing indie developers have to a launch forecast. The cozy sewing game Dressmaker gathered more than 400,000 Steam wishlists before its September 2026 release and earned back its development costs within a day. Its path is worth copying: a short prototype shared on social video, a free build on itch.io, then a full game once the audience had proved itself. You do not need numbers like that, but you do need the store page live long enough for players to find it.

5. Upload your build with SteamPipe

Configure your depots in Steamworks, then upload the files with SteamCMD. Details and a script are in the next section.

6. Submit for review and release

Valve checks that the build launches, that it matches the store page, and that nothing breaks its rules. If something fails, you get notes, fix them and resubmit. Once approved, you set a release date and press the button yourself.

How to upload your build with SteamPipe (with a script)

Inside Steamworks, open your app’s SteamPipe settings and confirm your depot IDs. Valve’s SDK includes a folder layout with a content directory for your game files, a scripts directory for build scripts, and SteamCMD itself. A build script is a small text file in Valve’s VDF format that says which files go into which depot.

"AppBuild"
{
    "AppID" "1000"
    "Desc" "First playable build"
    "BuildOutput" "..\output\"
    "ContentRoot" "..\content\"
    "SetLive" ""

    "Depots"
    {
        "1001"
        {
            "FileMapping"
            {
                "LocalPath" "*"
                "DepotPath" "."
                "recursive" "1"
            }
        }
    }
}

Replace 1000 with your App ID and 1001 with your Windows depot ID, put your game files in content, then run the upload from the SDK’s command-line folder:

steamcmd +login your_build_account +run_app_build ..\scripts\app_build_1000.vdf +quit

Leaving SetLive empty means the build uploads without going live. You then set it live on a branch from the Steamworks site, which is the safest habit: test the build through your own Steam client on a private branch before pointing the public default branch at it. Then go back to the launch options in Steamworks and point Steam at your executable, for example MyGame.exe.

Turning a web game into a Steam build

Many vibe-coded and jam games run in a browser using HTML5 and JavaScript. Steam wants a desktop program, so the usual approach is to wrap the game in a desktop shell such as the open-source Electron or NW.js projects. A minimal Electron entry file looks like this:

const { app, BrowserWindow } = require('electron');

function createWindow() {
  const win = new BrowserWindow({
    width: 1280,
    height: 720,
    autoHideMenuBar: true
  });
  win.loadFile('index.html');
}

app.whenReady().then(createWindow);
app.on('window-all-closed', () => app.quit());

Put your game’s index.html and assets next to this file, package it with a tool such as electron-builder, and the resulting folder becomes your depot content. Games made in a traditional game engine skip this step, because the engine exports a Windows build directly.

Building a Steam-ready game and store assets with Sorceress

Steam handles distribution. What it cannot do is make the game, the art for the store page, or the trailer. That is where Sorceress fits, and its most relevant piece is WizardGenie, the AI game engine at the heart of the suite. You describe the game you want, and WizardGenie writes, runs and iterates on the code with you. It runs on the web with nothing to install, and as a Windows desktop app with an auto-updater; the desktop version gives you native file access and longer agent sessions, which helps when your project grows to Steam size. It works with the leading AI coding models, and you can switch models with your own API key.

A practical workflow for a first Steam game:

1. Prototype in WizardGenie. Describe one core mechanic and play it within the session. Keep iterating until the loop is fun on its own.
2. Export the build and test it in public. Host the prototype somewhere free, collect feedback, and only pay the Steam fee when people want more. This is the Dressmaker approach at indie scale.
3. Make the characters and art. Auto-Sprite v2 creates game-ready 2D sprites, characters, items and effects in any art style (it is a Pro tool). For 3D games, 3D Studio turns a typed idea into a rigged, animated, game-ready 3D character.
4. Score and voice it. Sound Studio covers AI music, sound effects and text-to-speech, with a built-in editor for trimming.
5. Produce the store page assets. AI Image Gen gives you every leading image model in one panel for key art and capsule concepts, and Image Expander can outpaint art (extend it beyond its borders) to fit different capsule shapes. AI Video Gen handles image-to-video and text-to-video for trailer shots, though your trailer should be mostly real gameplay.
6. Wrap and upload. Package the web build with a desktop shell as shown above, then push it through SteamPipe.

Two honest notes. First, keep store screenshots and trailer footage true to the game; Valve reviews for that and players punish misleading art. Second, record which assets are AI-generated as you go, so the content survey takes minutes rather than an afternoon. For the full list of tools, see the Sorceress tools guide.

How hard is it to publish a game on Steam? The common mistakes

Mechanically, the process is moderate: forms, a web page and a command-line upload. Most of the difficulty comes from timing and visibility. These are the mistakes that cost first-time developers the most:

• Making the store page last. A page that goes live a couple of weeks before launch has no wishlists. Put it up as soon as you have a few honest screenshots.
• Weak capsule art. The capsule is the first thing a player sees, often at thumbnail size. Test it small; if the title and genre are not readable at a glance, redo it.
• A trailer that opens with logos. Show gameplay in the first few seconds. Studio logos can wait or be cut.
• Wrong tags. Tags drive which players see your game. Pick the ones a fan of the genre would use, not aspirational ones.
• Skipping the private branch test. Uploading straight to the public branch is how launch-day builds fail to start. Always install your own build through Steam first.
• Too-large first project. A small, finished game teaches you the release pipeline. A huge unfinished one teaches you nothing about it.
• Vague AI disclosure. Be specific about what is generated and where; it avoids review delays.

If you have shipped a jam game before, knowing how to publish a game on Steam is mostly about adding planning around what you already do. If you have not, ship something tiny on the web first.

The full pipeline

Here is the whole release in one view, so you can plan backwards from your launch date:

1. Prototype the core loop and share it publicly for feedback.
2. Create a Steamworks account and finish identity, tax and bank details.
3. Pay the US$100 Steam Direct fee to get your App ID.
4. Build the store page with capsules, screenshots, trailer, tags and the content survey, then publish it as “Coming Soon”.
5. Collect wishlists while you finish the game, posting updates on the page.
6. Package the game as a desktop build, upload it with SteamPipe, and test it on a private branch.
7. Submit the build for review, fix any notes, set the release date and launch.

That is genuinely how to publish a game on Steam: a fee you will likely earn back, a few forms, one build script, and a store page that does the selling. The work that makes it worthwhile is the game itself, and with WizardGenie writing and running the code and the rest of Sorceress handling art, audio and trailer shots, a solo developer can cover every part of that list.