egs-api

Async Rust client for the Epic Games Store API. Handles authentication, asset management, download manifest parsing (binary + JSON), and Fab marketplace integration.

Built on reqwest / tokio.

Features

• Authentication — OAuth login via authorization code, exchange token, or refresh token. Session resume and invalidation.
• Assets — List owned assets, fetch catalog metadata (including DLC trees), retrieve asset manifests with CDN download URLs.
• Download Manifests — Parse Epic's binary and JSON manifest formats. Exposes file lists, chunk hashes, and custom fields needed to reconstruct downloads.
• Fab Marketplace — List Fab library items, fetch Fab asset manifests with signed distribution points, and download Fab manifests. Search and browse listings with filtering, view listing details, UE format specs, ownership, and pricing.
• Cosmos / Unreal Engine — Cookie-based session for unrealengine.com. EULA management, account details, and engine version blob listing.
• Account — Account details, bulk account ID lookup, friends list (including pending requests).
• Entitlements — Query all user entitlements (games, DLC, subscriptions).
• Library — Paginated library listing with optional metadata.
• Tokens — Game exchange tokens and per-asset ownership tokens (JWT).
• Cloud Saves — List, query, and delete cloud save files.
• Uplay Integration — Query and redeem Ubisoft activation codes via Epic's GraphQL store API.

Quick Start

Add to Cargo.toml:

[dependencies]
egs-api = "0.9"
tokio = { version = "1", features = ["macros", "rt-multi-thread"] }

use egs_api::EpicGames;

#[tokio::main]
async fn main() {
    let mut egs = EpicGames::new();

    // Authenticate with an authorization code obtained from:
    // https://www.epicgames.com/id/api/redirect?clientId=34a02cf8f4414e29b15921876da36f9a&responseType=code
    let code = "your_authorization_code".to_string();
    if egs.auth_code(None, Some(code)).await {
        println!("Logged in as {}", egs.user_details().display_name.unwrap_or_default());
    }

    // List all owned assets
    let assets = egs.list_assets(None, None).await;
    println!("You own {} assets", assets.len());

    // Get detailed info for the first asset
    if let Some(asset) = assets.first() {
        if let Some(info) = egs.asset_info(asset).await {
            println!("{}: {}", info.id, info.title.unwrap_or_default());
        }
    }
}

Authentication Flow

Epic uses OAuth2 with a launcher client ID. The typical flow is:

1. Open the authorization URL in a browser — the user logs in and is redirected to a JSON page containing an authorizationCode.
2. Pass that code to egs.auth_code(None, Some(code)).
3. On success, egs.user_details() contains the session tokens.

To persist the session across runs, serialize egs.user_details() (it implements Serialize / Deserialize) and restore it later with egs.set_user_details(saved) followed by egs.login() which will use the refresh token to re-authenticate.

Authorization URL:

https://www.epicgames.com/id/login?redirectUrl=https%3A%2F%2Fwww.epicgames.com%2Fid%2Fapi%2Fredirect%3FclientId%3D34a02cf8f4414e29b15921876da36f9a%26responseType%3Dcode

See the auth example for a complete interactive flow with token persistence.

Examples

The crate ships with examples covering every endpoint. Run them with:

# First: authenticate and save a token
cargo run --example auth

# Then run any of these (they reuse the saved token):
cargo run --example account              # Account details, ID lookup, friends, external auths, SSO
cargo run --example entitlements         # List all entitlements
cargo run --example library              # Paginated library listing
cargo run --example assets               # Full pipeline: list → info → manifest → download manifest
cargo run --example game_token           # Exchange code + ownership token
cargo run --example fab                  # Fab search, browse, listing detail, library, downloads
cargo run --example cosmos               # Cosmos session, EULA, account, engine versions
cargo run --example catalog              # Catalog items, offers, bulk lookup
cargo run --example commerce             # Currencies, prices, billing, quick purchase
cargo run --example status               # Service status (lightswitch API)
cargo run --example presence             # Update online presence
cargo run --example client_credentials   # App-level auth + library state tokens
cargo run --example cloud_saves          # Cloud save file listing + management
cargo run --example uplay                # Ubisoft activation code queries

API Overview

The public API is the EpicGames struct. It wraps an internal HTTP client with cookie storage and bearer token management. Most methods return Option<T> or Vec<T> (swallowing transport errors); Fab methods return Result<T, EpicAPIError> to expose timeout/error distinctions.

Authentication

Epic Games Store

Cloud Saves

Uplay / Store Integration

Fab Marketplace

Cosmos / Unreal Engine

Account & Social

Commerce

Status & Presence

Download Manifest Format

The DownloadManifest struct handles Epic's binary manifest format (with JSON fallback). The binary format is little-endian, optionally zlib-compressed:

Header (41 bytes):
  magic(u32) → header_size(u32) → size_uncompressed(u32) →
  size_compressed(u32) → sha_hash(20 bytes) → compressed(u8) → version(u32)

Body (zlib-compressed):
  Meta:   feature_level, is_file_data, app_id, app_name, build_version, launch_exe, ...
  Chunks: guid(16 bytes) × N, hash(u64) × N, sha(20 bytes) × N, group(u8) × N, ...
  Files:  filename × N, symlink_target × N, sha_hash(20 bytes) × N, install_tags × N, chunk_parts × N
  Custom: key-value pairs (e.g., BaseUrl, CatalogItemId, BuildLabel)

Use DownloadManifest::parse(data) to parse either format. Access file lists via file_manifest_list, chunk info via chunk_hash_list, and custom fields via custom_field(key).

Architecture

EpicGames (public facade, src/lib.rs)
  └── EpicAPI (internal, src/api/mod.rs)
        ├── login.rs    — OAuth: start, resume, invalidate
        ├── egs.rs      — Assets, manifests, library, cloud saves, tokens
        ├── account.rs  — Account details, friends, entitlements
        ├── fab.rs      — Fab marketplace: library, downloads, search, browse
        ├── cosmos.rs   — Cosmos session, EULA, account, engine versions
        └── store.rs    — Uplay/Ubisoft code redemption (GraphQL)

EpicGames is the consumer-facing struct. It delegates to EpicAPI which holds the reqwest::Client (with cookie store) and UserData (session state). API methods are split across files via impl EpicAPI blocks.

License

MIT