Steamworks DLC Not Detected in Unity Build - App Ownership Query and Depot Config Fix - How to Fix

Problem: Your Unity game runs through Steam, but DLC stays locked even for accounts that should own it. In many teams, the store page and package look correct, yet in-game checks still report "not owned."

Common symptoms:

DLC content button remains disabled for tester accounts
BIsDlcInstalled or ownership checks always return false
behavior works in one branch/build but fails in another
base game is detected correctly, but DLC is never unlocked

This issue usually comes from a mismatch between runtime ownership checks and Steamworks package/depot configuration, not a random Unity bug.

Why this spikes now (2026 release lanes)

This issue is showing up more often in 2026 because teams are shipping faster DLC drops while moving between Steam branches, package edits, and entitlement smoke tests in tighter windows. That creates more opportunities for stale DLC App ID mappings, branch-to-package drift, and ownership checks firing before Steam callbacks settle in the running build.

If your team uses launch-week hotfix branches, treat this as a release-gate issue: verify entitlement behavior in the exact branch and package state you plan to ship, not just in one previously green QA build.

Maintenance note (May 2026): teams running same-day DLC pushes alongside branch promotions are seeing more false negatives caused by stale package publish state and delayed callback-driven ownership refresh. Keep one standardized entitlement smoke run immediately after each package edit or branch publish to avoid reopening already-fixed runtime code.

Root Cause

Steam DLC detection can fail when one or more of these happen together:

wrong DLC App ID is hardcoded or loaded from stale config
Steam API initializes too late, so ownership is queried before Steam is ready
callbacks are not pumped regularly, so entitlements never update
tester account owns base app but not the package containing the DLC App ID
DLC depot/package settings are incomplete or assigned to the wrong branch

In short: your code asks for ownership, but Steam does not have matching entitlement state for the queried DLC App ID in that runtime context.

Quick Fix Checklist

Confirm each queried DLC App ID matches the exact Steamworks DLC app.
Initialize Steam early and block DLC checks until API init succeeds.
Pump Steam callbacks every frame while game is running.
Validate tester account ownership for the DLC package, not only the base app.
Re-check branch/package/depot assignment for the build being tested.

Step 1 - Verify DLC App ID wiring in Unity

Create one source of truth for DLC IDs:

list every DLC name and App ID in a shared config file
reference that config from your unlock logic
log the App ID used in each ownership query during test builds

If your code references an old ID after DLC cloning or migration, ownership checks will fail even when users bought the right package.

Step 2 - Initialize Steam before ownership checks

Run Steam startup before any entitlement logic:

start Steam API in your bootstrap sequence
verify initialization result and log failure reasons
delay DLC unlock checks until Steam init confirms ready

If checks run during menu startup before Steam is ready, you can cache a false result and keep DLC locked for the whole session.

Step 3 - Pump callbacks and refresh entitlements

Make sure your game calls SteamAPI_RunCallbacks() continuously in the runtime loop.

Then:

trigger ownership refresh after login/session ready
re-check ownership after returning from Steam overlay purchase flow
avoid one-time-only checks at process start

Many "not detected" bugs are callback timing bugs, not actual ownership failures.

Step 4 - Validate package ownership in Steamworks

In Steamworks admin, verify:

DLC App ID is linked to the intended package
tester account is granted access to that package in the correct environment
branch used by QA includes matching depots and manifest state

A common trap is granting access to a package variant that does not include the DLC App ID currently queried by the game build.

Step 5 - Rebuild a clean entitlement smoke test

Use one deterministic QA pass:

launch Steam client with target test account
launch build from Steam library (not direct executable)
log Steam init state, queried DLC App IDs, and ownership results
verify DLC UI unlock and load one DLC asset path
restart game once and verify unlock persists

Treat this as a release gate for every DLC update.

Verification checklist

After fixes, confirm:

at least two tester accounts detect DLC correctly
DLC entitlement updates after overlay purchase without full reinstall
unlock state survives restart and scene reload
logs show expected App IDs and successful ownership checks
QA can reproduce pass results on the target release branch

Alternative fixes

If detection fails only in Editor

Use Editor-only guardrails and test DLC in a Steam-launched build. Editor runs often miss real Steam runtime conditions.

If only one DLC fails while others work

Compare App ID mapping and package assignment for that single DLC. Usually one item has stale ID or package drift.

If testers pass but production users fail

Audit branch publish timing and package rollout windows. Ownership can appear inconsistent during incomplete package/depot publication.

If DLC is purchased but unlock appears only after restarting Steam

Treat this as callback or entitlement refresh timing drift first:

confirm SteamAPI_RunCallbacks() runs continuously after login
trigger one ownership re-check after returning from overlay purchase flow
log account id, branch, queried DLC App ID, and ownership result together

If restart is still required, revalidate package assignment and branch publish status in Steamworks before changing gameplay code.

Prevention tips

Keep a versioned DLC App ID registry in source control.
Add startup logs for Steam init and queried DLC IDs in non-release builds.
Add a pre-release checklist for package/depot alignment per branch.
Re-run entitlement smoke tests after any Steamworks package edit.

Release-week hardening tips

Freeze DLC App ID mapping and package names 48 hours before your candidate build unless a blocker is confirmed.
Keep one entitlement smoke script per DLC so QA can rerun the same pass after every depot publish.
Record Steam branch, build ID, and queried App IDs together in every verification note to reduce triage time during launch week.

FAQ

Why does DLC unlock for developers but not for QA accounts?

Developer accounts often have broader package entitlements. QA may only own base app or a different package variant.

Should I rely on one ownership check at startup only?

No. Run callback pumping continuously and refresh checks at key runtime transitions, including post-purchase and session re-entry.

Can launching the executable directly break DLC detection?

Yes. Always test from Steam library for entitlement-sensitive validation, especially near release.

Why does DLC pass in one beta branch but fail in release-candidate branch?

Because branch build content and package entitlement state can drift independently. Re-verify the queried DLC App ID, package membership, and depot assignment for the exact branch that produced the candidate build.

What if package or depot changes are correct but ownership still looks stale for 10-20 minutes?

Treat short-lived mismatch windows as publish-propagation timing first, not immediate code regressions. Re-run the same Steam-launched entitlement smoke with timestamped logs, then compare branch id, package publish time, and callback activity before making new gameplay changes.