Usage Library

Library

Part of the Usage reference. · ← Previous: Authentication · Next: Store & discovery →

list

List games in your library (owned games merged with locally installed ones).

aurelia list [-i] [-s <TEXT>] [-c <NAME>] [-o] [-u] [--json]

Option	Description
-i, --installed	Only show installed games.
-s, --search <TEXT>	Filter by case-insensitive substring of the name.
-c, --collection <NAME>	Only show games in the named collection (by name or id). Static collections only.
-o, --online	Add an ONLINE column indicating whether each game appears to require an internet connection (see below).
-u, --check-updates	Compute update_available for installed games by comparing local and remote depot manifests (owned and Family-Shared). One manifest fetch per game, so slower than a plain listing. Off by default.
-j, --json	Emit JSON instead of a table.

The STATUS column shows installed, update (installed with an update available), or - (not installed). A non-default branch is shown in brackets after the name.

The COLLECTIONS column lists the collections each game belongs to (comma-joined names of the static collections whose membership includes it, while dynamic collections are skipped since they can't be resolved offline). It is empty (-) when a game is in no collection. The --collection <NAME> filter narrows the listing to a single collection's members, resolved by name (case-insensitive) or id. An unknown name is an error, and dynamic collections can't be used offline. The --json output includes a collections array per game.

Steam tooling (Proton, the Steam Linux Runtimes, and Steamworks Common Redistributables) is filtered out, so the list shows only real games rather than the runtime/redistributable app ids that share the library.

With --online, an extra ONLINE column reports whether the game looks like it requires a connection to play: yes, no, or ? (undetermined). Steam exposes no explicit flag for this, so it is inferred from the game's PICS store categories: a title is treated as online-required when it advertises an online-multiplayer category (MMO, Online PvP, Online Co-op) but no single-player support. This makes one PICS lookup per listed game, so it is slower than a plain listing and needs an active session. Without one the column reads ?. The --json output carries an online_required boolean (or null).

The LICENSE column shows whether the logged-in account holds a license for the game:

Value	Meaning
owned	The account has a license (the game is in its owned-games list).
family-shared	Installed locally but licensed to a different account, borrowed via Steam Family Sharing.
unlicensed	Installed under this account with no license record (e.g. redistributables, soundtrack/DLC, or a delisted free app).

The list includes Family-Shared games even when they are not installed: the full shared library offered by your Steam Family is queried and merged in (these show STATUS -). Family-Sharing is determined two ways, both requiring an active session: the Steam Families shared-library list, and, for installed games, comparing the LastOwner in the appmanifest against your SteamID. The --json output includes is_owned and is_family_shared booleans per game.

For installed games the --json output also carries a platform field ("windows", "linux" or "macos"), the platform of the depot actually on disk, detected from the installed files. It tells a driver whether the game runs natively or through Proton without re-deriving it (null when not installed or undetermined).

aurelia list
aurelia list --installed
aurelia list --search elden
aurelia list --json > library.json

Without an Aurelia session (you haven't run aurelia login, or you're offline), list falls back to the locally signed-in Steam client's own caches and still shows your full library: every game is reported as owned with STATUS - unless installed. This requires only that the Steam client itself is signed in. No network access is used. Running aurelia login re-enables the strictly richer network path (live ownership, update status, and not-installed Family-Shared titles).

account

Show account details for the logged-in user. Requires an active session.

aurelia account [--json]

aurelia account
aurelia account --json

Shows account name, SteamID, country, email (and validation state), authorized device count, and VAC ban count.

info

Show detailed information about one or more games. The metadata is fetched over Steam's CM connection (the StoreBrowse service), not the HTTPS storefront. A session is required only on a cache miss (see Caching below). A cached lookup works offline.

aurelia info <APP_ID>... [-e] [-n] [-l <LANGUAGE>] [-c <COUNTRY>] [--json]

Option	Description
<APP_ID>...	One or more app ids. Multiple ids are fetched together (see below).
-e, --extended	Also show the extended fields (see below). One extra HTTPS request per app, for system requirements.
-n, --no-cache	Bypass the local metadata cache and fetch fresh data from Steam.
-l, --lang <LANGUAGE> (alias --language)	Steam API language name for store text (descriptions, requirements, etc.), e.g. german, french, schinese. Defaults to the config language setting, then the system locale, then English.
-c, --country <CC> (alias --cc)	Two-letter ISO country code for the price region, e.g. DE, JP. Defaults to the config country setting, then the system locale, then US. An invalid code is rejected.
-j, --json	Emit JSON instead of formatted text.

By default info shows what the StoreBrowse protocol provides directly: type, developers, publishers, franchises, release date (and Early-Access/coming-soon state), price and discount (with the original price, the discount end date and the region), platforms, the Steam review summary, the store tags (up to 20), the age rating (with its descriptors), the short description, artwork URLs (header/capsule/hero/background/logo), and the list of DLC with names resolved. The DLC ids come from PICS appinfo and their names from a single batched StoreBrowse lookup, all over the CM connection, with no per-DLC web calls. A game that is not sold in the chosen region shows Region : not sold in <CC>.

The --json output includes an assets object with header, capsule (portrait cover), hero, background and logo URLs, derived from the StoreBrowse asset block (falling back to Steam's conventional CDN paths) so a front-end doesn't have to guess them. It also carries country, price_cents, original_price, original_price_cents, discount_end, discount_end_date, region_locked, purchase_options (packages and bundles), tags, rating, links, screenshots and trailers.

--extended adds fields that are not part of the base StoreBrowse record:

• Store genres and categories (resolved to names) and the Metacritic score, link and website, read from PICS appinfo over the CM connection.
• System requirements (minimum and recommended), the one part with no CM source, from a single HTTPS storefront request per app. If it fails, the requirements are left out and the rest of info still prints.

Since v0.1.37-2, user tags come from StoreBrowse instead of SteamSpy, so they show up without --extended. The extended.tags array in the JSON output is still filled, for older consumers.

Multiple app ids (one logon per batch)

info accepts several app ids at once and resolves them over a single Steam logon with one batched StoreBrowse call, so aurelia info <id1> <id2> <id3> costs one connection, far cheaper than running info once per id. (DLC-name lookups still happen per game.) An id with no store data is skipped with a warning rather than failing the whole command. A single unknown id still errors.

Caching

To avoid a Steam logon on every call (Steam throttles repeated logons, and front-ends like Heroic poll info often), the CM-sourced metadata (the StoreBrowse fields plus the DLC list) is cached to disk per app, language and price country under info_cache/<APP_ID>.<LANGUAGE>.<COUNTRY>.json in the config directory, so requests in different languages or regions never clobber each other. A cache hit serves the result with no network access at all (no logon, no StoreBrowse/PICS round-trip), so it also works offline.

• The cache time-to-live defaults to 6 hours. Override it (in seconds) with the AURELIA_INFO_CACHE_TTL environment variable, or set it to 0 to disable the cache.
• Pass --no-cache to ignore any cached copy and refresh from Steam (the fresh result is then written back to the cache).
• Since v0.1.37-2 the cache key includes the country, so after upgrading from an older version the first info call per app fetches fresh data.
• The --extended fields are not cached. They are always fetched live when --extended is given, so --extended always needs a session.

JSON output shape

With --json, the extended fields (when requested) are grouped under an "extended" key so the default object shape is unchanged. One id produces a single JSON object (as before). Several ids produce a JSON array of those objects, in the order requested.

aurelia info 690830                      # protocol-native fields, tags and rating included
aurelia info 690830 --extended           # + requirements, Metacritic, genres, categories
aurelia info 690830 --json               # single object
aurelia info 690830 570 730 --json       # array of three objects, one logon
aurelia info 690830 --no-cache           # force a fresh fetch
aurelia info 690830 --lang german        # store text in German (falls back to config, locale, English)
aurelia info 690830 --country DE         # quote the price for Germany
AURELIA_INFO_CACHE_TTL=0 aurelia info 690830   # bypass the cache for this run

For a side-by-side price comparison across regions, use price.

dlc

List a game's DLC together with its ownership and install state. Requires login (ownership is checked against your account).

aurelia dlc <APP_ID> [--json]

Option	Description
-j, --json	Emit JSON instead of formatted text.

A focused alternative to info when you only want the DLC list. The DLC ids come from PICS appinfo and their names, prices and release dates from a single batched StoreBrowse lookup (both over the CM connection, no storefront API). The text view has a PRICE column (in your price region) and the JSON entries carry price and release_date. If that store lookup fails, dlc prints a warning and still lists the DLC, without names or prices. Each entry is then annotated with:

• owned: your account holds a license for the DLC (an app ownership ticket is issued).
• installed: the DLC's content is present on disk (its depots are recorded in the base game's appmanifest).
• disabled: the DLC is listed in the base game's DisabledDLC, so Steam treats it as turned off.

In the text view the STATUS column collapses installed/disabled into not-installed, disabled, or enabled. The base game must be installed for the install/enable state to be meaningful. Otherwise every DLC reads as not-installed.

aurelia dlc 690830
aurelia dlc 690830 --json

drm

Verify a game's DRM tickets headlessly over the Steam CM connection, with no Steam client involved. Requires login.

aurelia drm <APP_ID> [--json]

Option	Description
--json	Emit JSON instead of formatted text.

Requests two things from Steam:

• App ownership ticket: issued only when the account holds a license for the app. It is the signed proof of ownership Steam DRM checks against.
• Encrypted app ticket: the serialized EncryptedAppTicket envelope, issued only for games whose developer configured an encrypted-ticket key in Steamworks. A refusal with eresult 2 almost always means the app simply doesn't use encrypted tickets. Steam also rate-limits the request to roughly one per app per minute (eresult 25).

The ownership check also runs automatically as a warn-only preflight before a standalone aurelia play of an owned, non-Family-Shared game (skipped offline): the launch always proceeds, but if Steam issues no ownership ticket you're warned that a DRM-protected title may not start without --steam.

aurelia drm 2062430
aurelia drm 2062430 --json

The --json output is { "app_id", "name", "owned", "ownership_ticket_bytes", "ownership_error", "encrypted_ticket": { "status", "bytes", "eresult", "error" } }.

achievements

Show the logged-in user's achievements for a game, with per-achievement unlock state. Requires an active session.

aurelia achievements <APP_ID> [-l <LANG>] [--json]

Option	Description
-l, --lang <LANG> (alias --language)	Language for names/descriptions (Steam API language name, e.g. english, german). When omitted, falls back to the config language setting, then the system locale, then english.
-j, --json	Emit JSON instead of a table.

Combines the game's achievement definitions and global rarity (Player.GetGameAchievements) with your unlock state and time (ClientGetUserStats), all over the Steam CM connection. The text view marks unlocked achievements (✓), the global unlock rate, and the unlock date, while hidden-and-still-locked ones are tagged (hidden). The --json output is { "app_id", "unlocked", "total", "achievements": [ { achievement_id, achievement_key, name, description, visible, image_url_unlocked, image_url_locked, rarity, unlocked, unlock_time, date_unlocked } ] } (rarity is the global unlock percentage; date_unlocked/unlock_time are null when locked). A game you've never launched still lists every achievement, all locked.

aurelia achievements 620
aurelia achievements 620 --lang german
aurelia achievements 620 --json

image

Download a game's cover/header artwork from the Steam CDN to the local image cache.

aurelia image <APP_ID> [-o <PATH>] [-f]
aurelia image <APP_ID> --list [--probe] [--json]

Option	Description
-o, --output <PATH>	Write the image to this path instead of the cache directory.
-f, --force	Re-download even if a cached copy already exists.
-l, --list	Don't download anything. List every store asset URL instead (see below).
-p, --probe	With --list: send a HEAD request to each URL and show its HTTP status. Requires --list.

The command prints the final path of the image. It tries the library capsule, then the header image, then the legacy capsule. No login is required (artwork is public).

With --list, image prints one row per asset: header, capsule, hero, background, logo, every screenshot, and each trailer's trailer_thumb and trailer URL. The asset list comes from the store record (served from the info cache when it has media, otherwise fetched, which needs a session). With --probe, the status column holds the HTTP code (ERR when the request failed). URLs are checked eight at a time, and a summary line reports how many failed. The --json output is { "app_id", "name", "probed", "assets": [ { "kind", "url", "status" } ] }.

aurelia image 1245620                 # cache it, print the cached path
aurelia image 1245620 -o cover.jpg    # save to a specific file
aurelia image 1245620 --force         # refresh the cached copy
aurelia image 1245620 --list          # every asset URL (art, screenshots, trailers)
aurelia image 1245620 --list --probe  # ... and HEAD-check each one