Steam Manifest Files Explained: .manifest, AppManifest, Depot and Lua Files
A practical map of Steam manifest file types, IDs, local library records, package helpers, and the safest next step for each task.
On this page
Searches for Steam manifest files often mix several different things: a depot manifest, a local appmanifest file, a Lua script, a JSON metadata file, or a complete package assembled for a third-party workflow. Those files can appear next to each other in guides and archives, but they do not perform the same job. A small naming difference can change whether Steam is reading local library state, a tool is describing a content snapshot, or a script is simply helping another program parse metadata.
The useful question is not only “where can I download a manifest?” It is “which file does my task actually require, and what can that file prove?” This guide keeps the vocabulary separate, explains the ID chain behind a Steam app, and gives a decision path for readers who need to inspect a local library, create an appmanifest starter, find a package by AppID, or work with a Lua-oriented tool.
The examples use common Steam terminology, but they do not promise a current package, ownership, license, or access to content. Availability changes with the app, depot, branch, account, platform, language, and source. Use the map below to reduce mismatches, keep backups, and route each task to the existing page that is designed for it.
What Are Steam Manifest Files?
In everyday Steam discussions, “manifest” usually means a structured record that describes content or local state. A depot manifest is associated with a particular content snapshot, while a local appmanifest file is an ACF record that helps the Steam client connect an AppID with an installation in one library. Both are metadata, but they live at different layers. Neither is the playable game folder, a save file, or a license.
A manifest can tell a tool how files, depots, builds, or installation state relate to one another. It cannot by itself prove that a file is official, current, complete, or usable for every account. If a page promises that one manifest file will unlock ownership, recreate missing content, or bypass Steam checks, treat that claim as a red flag. The safe interpretation is narrower: a manifest is a description or state record that still needs to be checked against Steam and the intended workflow.
Metadata is not content
The file that describes an installation or depot is much smaller than the game data it refers to. Keep the record, the payload, and the account or client permissions conceptually separate.
The Main Steam Manifest File Types Compared
The word “manifest” becomes much easier to use once the extension and location are visible. A depot .manifest belongs to content metadata; appmanifest_<AppID>.acf belongs to a local Steam library; Lua, JSON, VDF, and key files are helpers that may travel with a third-party package. The installed files under steamapps/common are the payload, not a manifest.
Use the table as a first-pass classifier. It is intentionally conservative: if you do not know the AppID, the library, the depot, or the source of a file, inspect a copy and verify the context before moving it.
| File or location | What it usually represents | Do not assume |
|---|---|---|
| Depot .manifest | Metadata for a depot content snapshot, often associated with a build or ManifestID | It is not the installed game and does not grant access |
| appmanifest_<AppID>.acf | Local app state in a Steam library's steamapps folder | It is not the same as a depot manifest or a license |
| Lua file | A script or configuration input for a particular tool workflow | It is not proof of ownership, current depot data, or a complete package |
| JSON, VDF, or key file | Structured metadata or helper data carried by some packages | A familiar extension does not prove the file is safe or current |
| steamapps/common/<Game> | The installed game payload and its ordinary folders | The folder alone may not make Steam recognize the installation |
| depotcache or content output | Cached or downloaded depot-related data | It is not automatically the live library installation |
Start with the extension and the path
A file name, parent folder, and matching AppID together are more useful than a download page that only says “manifest.”
How AppID, DepotID, and ManifestID Connect
AppID identifies the application or product at the top level. A base game, demo, DLC, soundtrack, tool, and test application can each have a different AppID. That is why an AppID copied from a search result should be checked against the intended store entry before it is used in a file name or generator.
A DepotID identifies a content subdivision inside an application. A game may have separate depots for Windows, Linux, macOS, language packs, optional content, or shared files. A ManifestID identifies a particular version or snapshot of a depot. The chain is therefore often described as AppID → DepotID → ManifestID, but the chain does not mean that every AppID exposes every depot or that every ManifestID is available to every account or branch.
When a package contains several IDs, check that they describe the same title, platform, branch, and intended version. A mismatched DLC AppID, a depot from another platform, or a stale ManifestID can make a technically valid-looking package fail in practice. Keep the IDs as evidence for comparison, not as a guarantee that a tool can fetch or install the content.
| ID | Layer | Useful check |
|---|---|---|
| AppID | Application or product | Compare with the official store URL and the exact edition |
| DepotID | Content subdivision | Check platform, language, DLC, and shared-content context |
| ManifestID | Depot snapshot | Check branch, build, source date, and whether the snapshot is actually available |
IDs narrow the question
An AppID tells you which product is involved; DepotID and ManifestID help describe which content slice and snapshot are being discussed. None of them replaces Steam's current client or account checks.
Local Library Records vs Downloadable Package Files
A local appmanifest_<AppID>.acf is part of a Steam library's bookkeeping. It normally sits directly inside a library's steamapps directory, beside folders such as common, and helps Steam associate an app with an install directory and local state. If the ACF is missing or mismatched, Steam may show an Install button even when a common folder still contains large files. The repair task is to preserve the library and let Steam discover or verify the correct folder.
A depot manifest package has a different job. It can describe depots, versions, and file relationships for an authorized workflow, but it does not replace the appmanifest record and does not turn a downloaded archive into an installed library. Lua, JSON, VDF, and key files may support a third-party tool, yet they remain package inputs rather than Steam's authoritative local state. Mixing the two layers is the reason many “manifest file” instructions sound contradictory.
Two different repair questions
If Steam forgot a local installation, read the AppManifest file guide. If you need an AppID-based package or depot metadata, use the finder or downloader flow instead of copying a random ACF.
Choose the Right Next Step for Your Task
The best page depends on the action you are trying to complete. Do not start with a file extension alone. Start with the desired result, confirm the AppID, and then use the narrowest workflow that exposes the right inputs and warnings.
The following sequence is designed to keep changes reversible. It also prevents a reader looking for an explanation from being sent straight to a package download, and prevents a reader repairing a local library from treating a depot manifest as an ACF replacement.
| Your goal | Use this route | Why it fits |
|---|---|---|
| Understand the vocabulary and file boundaries | This guide | Explains .manifest, ACF, Lua, JSON, VDF, and the ID chain |
| Inspect or recreate a local appmanifest starter | AppManifest Generator and its guide | Focuses on appmanifest_<AppID>.acf fields and reversible local checks |
| Find an AppID from a game name | AppID Finder | Reduces base-game, DLC, demo, and edition mistakes |
| Check or prepare an AppID-based manifest package | Steam Manifest Finder or Downloader | Keeps package availability and download intent separate from local ACF repair |
| Create a small Lua starter | Steam Lua Generator | Explains that a local Lua starter is not a depot package or ownership record |
- Identify the exact product
Confirm the title, edition, platform, and AppID. Do not use a DLC, demo, soundtrack, or tool ID when you mean the base game.
- Name the file layer
Decide whether you are dealing with a local ACF, a depot .manifest, a Lua helper, or the installed game folder.
- Preserve the original
Close Steam before changing local records, copy the existing file, and record the full library path and file name.
- Check the source and date
Prefer documented first-party context or a transparent repository. Treat “latest,” “safe,” and “official” as claims that need evidence.
- Make one controlled change
Do not replace several files at once. A single change makes it easier to identify whether the AppID, path, package, or client state caused the result.
- Validate in the intended client
Let Steam or the relevant tool inspect the result, then check the library, file path, build, and error state before keeping the change.
The finish line is a verified result
A file that parses is not automatically a file that matches the game, library, platform, branch, or current content state.
Source, Update, and Version Checks
Manifest-related pages often use words such as updated, current, complete, or verified. Those words should be tied to a source and a check date. Valve's documentation explains the application and depot model, but it does not make a community package current. A repository release date, a package timestamp, or a tool's own claim is only one piece of evidence and may not match the branch or platform you need.
Before importing a package, compare the AppID, DepotID, ManifestID, platform, language, branch, and any release notes shown by the source. If the source is a community repository, inspect its history and documentation rather than trusting a mirror that hides the file list behind an installer. If there is no stable, verifiable file URL, keep the official documentation or release page as the reference instead of inventing a direct download link.
No verified date, no latest claim
This guide explains file roles; it does not label a package as current or official without a source, platform, and check date.
Safety and Ownership Boundaries
Manifest files can be useful for backup, troubleshooting, version comparison, and authorized library management. They can also be presented in unsafe ways. Do not run an executable installer merely because it arrived beside a .manifest or .lua file. Do not enter a Steam password, API key, session cookie, or payment detail into a mirror that is not the documented service. Keep archives inspectable and separate from your live library until the contents and source are understood.
This site does not provide instructions to bypass ownership, DRM, licensing, account restrictions, branch access, or security checks. A manifest, Lua file, AppID, DepotID, or ManifestID is not a license. If a search query asks how to obtain files for a game a person does not own, the responsible answer is to stop at the authorization boundary and use the official Steam account, store, support, or developer documentation.
Inspect before import
The safest package is one whose source, purpose, IDs, and intended client are clear before it touches a library or account.
Common Steam Manifest File Mistakes
The most common mistake is treating every file named manifest as interchangeable. A depot .manifest, appmanifest_<AppID>.acf, and a tool's Lua package can all be text-based, yet replacing one with another will not repair the same problem. A second mistake is copying a file from a different library or edition because the filename looks familiar. Always compare the actual AppID, install directory, platform, and source context.
Another failure pattern is changing files while Steam is open, deleting the original before making a backup, or allowing a client to start a new download into the wrong folder. Pause first, preserve evidence, and make one change. If the result is a large unexpected download, an Install button, an update loop, or a validation error, stop and re-check the library path and IDs rather than adding more random files.
| Mistake | Safer correction |
|---|---|
| Using a depot .manifest as an appmanifest ACF | Identify the file layer and use the AppManifest guide for local library state |
| Mixing base-game and DLC IDs | Compare the exact store entry and AppID before generating or importing |
| Trusting a random “latest” mirror | Record the source, date, platform, branch, and visible release notes |
| Editing while Steam is running | Exit the client, back up the file, then make one controlled change |
| Deleting content to force discovery | Preserve the common folder and let Steam verify or rediscover it first |
When in doubt, reduce the scope
The right next action is usually to verify the ID, path, and file type—not to download a larger archive or edit more metadata.
Steam Manifest Files FAQ
Official and technical references
- Steamworks Documentation — Applications and Depots — Valve's official explanation of application and depot organization.
- Steamworks Documentation — Building and Publishing — Valve's official context for builds, depots, and publishing workflows.
- Steam Support — Verify Integrity of Game Files — Official Steam support context for validating local game files.
- Valve Developer Community — Add Non-Steam Game Files to Steam — Community technical background on local Steam library file behavior; not a Valve support guarantee.