Struct SteamUser 

pub struct SteamUser {
    pub session: Session,
    /* private fields */
}

Steam Community web client.

Provides HTTP-based interactions with Steam Community endpoints.

SteamUser implements Clone. All clones share the same cookie jar (Arc<Jar>) and rate-limiter (Arc<SteamRateLimiter>), so they stay in sync for cookies and rate limits. The time_offset is copied by value at clone time.

Fields

session: Session

Session state (cookies, steam_id, etc.).

Implementations

impl SteamUser

pub fn new(cookies: &[&str]) -> Result<Self, SteamUserError>

Creates a new SteamUser client with the provided cookies.

Convenience wrapper over SteamUser::builder with default timeouts and user-agent. Use the builder when you need to tweak any of those.

Arguments

• cookies - A slice of cookie strings in “name=value” format.

Errors

Returns a SteamUserError if the cookies are invalid or could not be parsed.

pub fn builder() -> SteamUserBuilder

Returns a builder for configuring a new SteamUser.

Use the builder to override defaults (timeouts, user-agent, retry count) or to set a per-session rate limit at construction time instead of via Self::with_rate_limit.

pub fn with_rate_limit( self, requests_per_minute: u32, burst: u32, ) -> Result<Self, SteamUserError>

Sets a per-session rate limit for this SteamUser.

This limit is applied in addition to the global IP-wide limit.

Errors

Returns an error if requests_per_minute or burst is zero.

pub fn steam_id(&self) -> Option<SteamID>

Returns the current SteamID if the user is logged in.

pub fn get(&self, url: impl IntoUrl) -> SteamRequestBuilder

Creates a GET request with default query parameters (e.g., language set to English).

Arguments

• url - The target URL for the GET request.

pub fn post(&self, url: impl IntoUrl) -> SteamRequestBuilder

Creates a POST request to the specified URL.

This method returns a SteamRequestBuilder which automatically appends the session ID to form or multipart data if it’s available.

pub fn get_path(&self, path: impl Display) -> SteamRequestBuilder

Creates a GET request using a relative path resolved against the current #[steam_endpoint]’s host.

Panics

Panics if called outside a #[steam_endpoint]-annotated method.

pub fn post_path(&self, path: impl Display) -> SteamRequestBuilder

Creates a POST request using a relative path resolved against the current #[steam_endpoint]’s host.

Panics

Panics if called outside a #[steam_endpoint]-annotated method.

pub fn get_path_on(&self, host: Host, path: impl Display) -> SteamRequestBuilder

Creates a GET request against an explicit Steam host, regardless of the current #[steam_endpoint] (if any).

Use when a Steam endpoint is reached on a host other than the one declared by the enclosing method’s #[steam_endpoint] attribute — for example, a Help-host URL composed at runtime from inside a Community-host method.

Cookies, sessionid injection, and the per-host rate limiter are applied exactly as in get_path.

pub fn post_path_on( &self, host: Host, path: impl Display, ) -> SteamRequestBuilder

Creates a POST request against an explicit Steam host. See Self::get_path_on for the use case.

pub fn external_get(&self, url: impl IntoUrl) -> RequestBuilder

Creates a GET request to a non-Steam URL using the external client.

Use only for URLs that are NOT on Steam-owned hosts — for example, fetching a user-supplied avatar image from an arbitrary CDN. Steam cookies are not attached, the Steam rate limiter is not engaged, and middleware (retry, tracing) is bypassed.

Returns a plain reqwest::RequestBuilder, not a SteamRequestBuilder, because session-id injection and Steam-specific behaviour are inappropriate for external hosts.

pub fn external_post(&self, url: impl IntoUrl) -> RequestBuilder

Creates a POST request to a non-Steam URL using the external client. See Self::external_get for the use case.

pub fn request(&self, method: Method, url: impl IntoUrl) -> SteamRequestBuilder

Creates a request with the specified HTTP method and URL, including common query parameters.

This is a low-level method used by get and post. It sets the default language and includes the session ID in the query parameters if it’s available.

pub async fn get_with_manual_redirects( &self, url: &str, ) -> Result<String, SteamUserError>

Performs a GET request with manual redirect handling.

This is needed for pages like trade offers where Steam redirects through /market/eligibilitycheck/ which can fail with automatic redirect following. Uses a temporary no-redirect client and manually follows the redirect chain.

pub fn get_session_id(&mut self) -> &str

Returns the current session ID, generating one from cookies if it’s not already cached.

pub fn is_logged_in(&self) -> bool

Returns true if the client session has a Steam ID and session ID, suggesting the user is logged in.

Note: This does not verify the session with Steam servers; use logged_in() for a definitive check.

pub fn set_mobile_access_token(&mut self, token: String)

Sets the mobile access token used for two-factor authentication (2FA) operations.

pub fn set_refresh_token(&mut self, token: String)

Sets the refresh token used for token enumeration and renewal.

pub fn set_access_token(&mut self, token: String)

Sets the access token.

pub fn get_web_cookies(&self) -> String

Returns the cookies formatted as a string for web requests.

This constructs the cookies using the access token and Steam ID, similar to the “simple” cookie logic in steam-auth.

pub async fn logged_in(&self) -> Result<(bool, bool), SteamUserError>

Verifies the current login status by making a request to Steam.

Returns a tuple containing:

• bool - Whether the user is actually logged in.
• bool - Whether the account is currently restricted by Family View.

pub async fn renew_access_token(&mut self) -> Result<(), SteamUserError>

Renews the current access token using the stored refresh token.

This is typically used when an access token has expired.

pub async fn get_auth_session_info( &self, qr_challenge_url: &str, ) -> Result<CAuthenticationGetAuthSessionInfoResponse, SteamUserError>

Retrieves authentication session information for a given QR challenge URL.

This is used during the QR code login process to get details about the pending session.

pub async fn get_client_js_token(&self) -> Result<ClientJsToken, SteamUserError>

Retrieves the Steam Chat client JS token.

This token is used for authenticating with the Steam Chat WebSocket connection. It is fetched from https://steamcommunity.com/chat/clientjstoken.

Returns

Returns a ClientJsToken struct if successful.

Errors

Returns a SteamUserError if the request fails or the user is not logged in.

impl SteamUser

pub async fn get_steam_wallet_balance( &self, ) -> Result<WalletBalance, SteamUserError>

Retrieves the Steam Wallet balance(s) and account currency.

Scrapes the Steam Community home page to extract the main wallet balance and any pending balances.

Returns

Returns a WalletBalance struct containing:

• main_balance: The current available balance (e.g., “$10.00”).
• pending: Any pending balance awaiting verification.
• currency: The currency symbol or code extracted from the balance string.

Errors

Returns [SteamUserError::Other("Not logged in")] if the session is not authenticated.

Example

let wallet = user.get_steam_wallet_balance().await?;
if let Some(balance) = wallet.main_balance {
    println!("Current balance: {}", balance);
}

pub async fn get_amount_spent_on_steam(&self) -> Result<String, SteamUserError>

Retrieves the total amount spent on Steam for the current account.

Scrapes the Steam Help page to determine the lifetime spending on the account. This is often used to check if an account is “limited” (spent less than $5.00).

Returns

Returns a String representing the total amount spent (e.g., “$150.42”).

Example

let spent = user.get_amount_spent_on_steam().await?;
println!("Lifetime spend: {}", spent);

pub async fn parental_unlock(&self, pin: &str) -> Result<(), SteamUserError>

Unlocks Steam Parental Controls using the provided PIN.

Sends a POST request to https://steamcommunity.com/parental/ajaxunlock.

Arguments

• pin - A 4-digit PIN code as a string.

Errors

• Returns [SteamUserError::Other("Incorrect PIN")] if the PIN is wrong.
• Returns [SteamUserError::Other("Too many invalid PIN attempts")] if locked out.

Example

match user.parental_unlock("1234").await {
    Ok(_) => println!("Unlocked!"),
    Err(e) => eprintln!("Failed to unlock: {}", e),
}

pub async fn get_purchase_history( &self, ) -> Result<Vec<PurchaseHistoryItem>, SteamUserError>

Retrieves the Steam purchase history for the current account.

Scrapes the account purchase history page at https://store.steampowered.com/account/history/.

Returns

Returns a Vec<PurchaseHistoryItem> containing all visible purchase history entries.

Errors

Returns an error if the request fails or the page cannot be parsed.

Example

let history = user.get_purchase_history().await?;
for item in history {
    println!("{}: {} - {}", item.date, item.transaction_type, item.total);
}

pub fn parse_purchase_history_html( html: &str, ) -> Result<Vec<PurchaseHistoryItem>, SteamUserError>

Pure parsing function for the purchase history page HTML.

Extracted for easier testing and offline parsing.

pub async fn redeem_wallet_code( &self, wallet_code: &str, ) -> Result<RedeemWalletCodeResponse, SteamUserError>

Redeems a Steam wallet code to add funds to the account.

Posts to https://store.steampowered.com/account/ajaxredeemwalletcode/.

Arguments

• wallet_code - The Steam wallet code to redeem (e.g., “XXXXX-XXXXX-XXXXX”).

Returns

Returns a RedeemWalletCodeResponse containing the result of the redemption.

Errors

Returns an error if the request fails. Common error codes in the response:

• success: 1 - Code redeemed successfully
• success: 2 with detail: 14 - Invalid code
• success: 2 with detail: 15 - Already redeemed
• success: 2 with detail: 53 - Rate limited

Example

let result = user.redeem_wallet_code("XXXXX-XXXXX-XXXXX").await?;
if result.success == 1 {
    println!(
        "Redeemed! New balance: {:?}",
        result.formatted_new_wallet_balance
    );
} else {
    println!("Failed with detail: {:?}", result.detail);
}

pub async fn get_account_details( &self, ) -> Result<AccountDetails, SteamUserError>

Fetches and parses the Steam authorized-devices page.

Scrapes https://store.steampowered.com/account/authorizeddevices and extracts every JSON data blob embedded by Steam into the page:

Field	Source attribute
active_devices	data-active_devices
revoked_devices	data-revoked_devices
two_factor_status	data-two_factor_status
user_info	data-userinfo
hw_info	data-hwinfo
page_config	data-config
store_user_config	data-store_user_config (includes WebAPI JWT)
notifications	data-steam_notifications
broadcast_user	data-broadcastuser
account_name	data-accountName
email	data-email
phone_hint	data-phone_hint
latest_android_app_version	data-latest_android_app_version
requesting_token_id	data-requesting_token_id

Errors

Returns [SteamUserError::Other("Not logged in")] if the session is unauthenticated (Steam redirects to the Sign In page).

Example

let page = user.get_account_details().await?;
println!("Account: {:?}", page.account_name);
println!("Country: {:?}", page.country);
println!("Security: {:?}", page.account_security());
println!("Active sessions: {}", page.active_devices.len());

impl SteamUser

pub async fn get_friend_activity( &self, start: Option<u64>, ) -> Result<FriendActivityResponse, SteamUserError>

Retrieves the friend activity feed.

Fetches activity items from the authenticated user’s activity feed, including game purchases, achievements, wishlist additions, and more.

Arguments

• start - Optional Unix timestamp to start fetching from (for pagination).

Returns

Returns a FriendActivityResponse containing activities and pagination info.

Example

let response = user.get_friend_activity(None).await?;
for activity in response.activities {
    println!("Activity: {:?}", activity.activity_type);
}
// Fetch next page if available
if let Some(next_start) = response.next_request_timestart {
    let next_page = user.get_friend_activity(Some(next_start)).await?;
}

pub async fn get_friend_activity_full( &self, ) -> Result<Vec<FriendActivity>, SteamUserError>

Retrieves the complete friend activity feed by fetching all pages.

This method will continue fetching pages until no more activities are available. Use with caution as this may make many HTTP requests.

Returns

Returns a Vec<FriendActivity> containing all activities from the feed.

Example

let all_activities = user.get_friend_activity_full().await?;
println!("Found {} total activities", all_activities.len());

pub async fn comment_user_received_new_game( &self, steam_id: SteamID, thread_id: u64, comment: &str, ) -> Result<ActivityCommentResponse, SteamUserError>

Comments on a friend’s game purchase activity.

Arguments

• steam_id - The SteamID of the user who received the game.
• thread_id - The thread ID of the activity (from FriendActivity::thread_id).
• comment - The comment text to post.

Returns

Returns an ActivityCommentResponse with the result of the operation.

Example

let friend_id = SteamID::from(76561198012345678u64);
let result = user
    .comment_user_received_new_game(friend_id, 1234567890, "Nice game!")
    .await?;
println!("Comment posted: {}", result.success);

pub async fn rate_up_user_received_new_game( &self, steam_id: SteamID, thread_id: u64, ) -> Result<ActivityCommentResponse, SteamUserError>

Upvotes (likes) a friend’s game purchase activity.

Arguments

• steam_id - The SteamID of the user who received the game.
• thread_id - The thread ID of the activity (from FriendActivity::thread_id).

Returns

Returns an ActivityCommentResponse with the result of the operation.

Example

let friend_id = SteamID::from(76561198012345678u64);
let result = user
    .rate_up_user_received_new_game(friend_id, 1234567890)
    .await?;
println!(
    "Upvoted: {}, total upvotes: {}",
    result.has_upvoted, result.upvotes
);

pub async fn delete_comment_user_received_new_game( &self, steam_id: SteamID, thread_id: u64, comment_id: &str, ) -> Result<ActivityCommentResponse, SteamUserError>

Deletes a comment from a friend’s game purchase activity.

Arguments

• steam_id - The SteamID of the user who received the game.
• thread_id - The thread ID of the activity (from FriendActivity::thread_id).
• comment_id - The ID of the comment to delete.

Returns

Returns an ActivityCommentResponse with the result of the operation.

Example

let friend_id = SteamID::from(76561198012345678u64);
let result = user
    .delete_comment_user_received_new_game(friend_id, 1234567890, "6407003171827779878")
    .await?;
println!("Deleted: {}", result.success);

impl SteamUser

pub async fn get_my_comments(&self) -> Result<Vec<UserComment>, SteamUserError>

Retrieves all comments from the current user’s profile.

This is a convenience method that calls Self::get_user_comments with the authenticated user’s Steam ID.

Returns

Returns a Vec<UserComment> containing all comments on the user’s profile.

Example

let comments = user.get_my_comments().await?;
println!("You have {} comments on your profile.", comments.len());

pub async fn get_user_comments( &self, steam_id: SteamID, ) -> Result<Vec<UserComment>, SteamUserError>

Retrieves all comments from the specified Steam profile.

This method handles pagination automatically, fetching all available comments by repeatedly querying the Steam Community servers.

Arguments

• steam_id - The SteamID of the user whose profile comments you want to retrieve.

Returns

Returns a Vec<UserComment> containing all comments found on the profile.

Example

let target_sid = SteamID::from(76561197960287930);
let comments = user.get_user_comments(target_sid).await?;
for comment in comments {
    println!("{}: {}", comment.author.name, comment.content);
}

pub async fn post_comment( &self, steam_id: SteamID, message: &str, ) -> Result<Option<UserComment>, SteamUserError>

Posts a comment on the specified Steam profile.

Sends a POST request to the Steam Community server to add a new comment.

Arguments

• steam_id - The SteamID of the profile to post the comment on.
• message - The text content of the comment.

Returns

Returns Ok(Some(UserComment)) containing the newly posted comment if successful, or Ok(None) if the comment was posted but could not be parsed from the response.

Example

let target_sid = SteamID::from(76561197960287930);
let comment = user
    .post_comment(target_sid, "Hello from rust-steam!")
    .await?;
if let Some(c) = comment {
    println!("Posted comment with ID: {}", c.id);
}

pub async fn delete_comment( &self, steam_id: SteamID, gidcomment: &str, ) -> Result<(), SteamUserError>

Deletes a specific comment from the specified Steam profile.

Arguments

• steam_id - The SteamID of the profile where the comment is located.
• gidcomment - The unique ID of the comment to delete (e.g., “1234567890”).

Returns

Returns Ok(()) if the comment was successfully deleted.

Example

let target_sid = SteamID::from(76561197960287930);
user.delete_comment(target_sid, "1234567890").await?;

impl SteamUser

pub async fn begin_file_upload( &self, file_path: impl AsRef<Path>, ) -> Result<BeginFileUploadResult, SteamUserError>

Initiates a file upload to Steam’s servers.

This is the first step in a multi-part upload process. It notifies Steam about the file being uploaded and retrieves the destination host and headers required for the actual transfer.

Arguments

• file_path - The path to the local image file to be uploaded.

Returns

Returns a BeginFileUploadResult containing the upload destination and required credentials.

Example

let upload_init = user.begin_file_upload("path/to/image.png").await?;
println!("Upload initiated for: {}", upload_init.ugcid);

pub async fn do_file_upload( &self, file_path: impl AsRef<Path>, begin_result: &BeginFileUploadResult, ) -> Result<(), SteamUserError>

Performs the actual file data transfer using the details from a previous Self::begin_file_upload call.

This method sends the raw file bytes via a PUT request to the host specified in begin_result.

Arguments

• file_path - The path to the local file to be uploaded.
• begin_result - The result from a successful call to Self::begin_file_upload.

Example

let init = user.begin_file_upload("image.png").await?;
user.do_file_upload("image.png", &init).await?;

pub async fn commit_file_upload( &self, params: CommitFileUploadParams, ) -> Result<CommitFileUploadResponse, SteamUserError>

Finalizes and commits an uploaded file on the Steam servers.

This is the final step in the upload process. Once committed, the file becomes available on Steam’s content delivery network.

Arguments

• params - A CommitFileUploadParams struct containing necessary identifiers and metadata.

Returns

Returns a CommitFileUploadResponse containing the final URL of the uploaded image.

Example

let commit_params = steam_user::types::CommitFileUploadParams {
    file_name: init.file_name,
    file_sha: init.file_sha,
    file_image_width: init.file_image_width,
    file_image_height: init.file_image_height,
    file_type: init.file_type,
    ugcid: init.ugcid,
    timestamp: init.timestamp,
    hmac: init.hmac,
    friend_steamid: None,
};
let response = user.commit_file_upload(commit_params).await?;
if let Some(res) = response.result {
    if let Some(details) = res.details {
        println!("Uploaded image URL: {}", details.url);
    }
}

impl SteamUser

pub async fn add_friend(&self, user_id: SteamID) -> Result<(), SteamUserError>

Sends a friend request to a user.

Arguments

• user_id - The SteamID of the user to add.

Example

let target = SteamID::from(76561197960287930);
user.add_friend(target).await?;

pub async fn remove_friend( &self, user_id: SteamID, ) -> Result<(), SteamUserError>

Removes a user from the friend list.

Arguments

• user_id - The SteamID of the friend to remove.

Example

let target = SteamID::from(76561197960287930);
user.remove_friend(target).await?;

pub async fn accept_friend_request( &self, user_id: SteamID, ) -> Result<(), SteamUserError>

Accepts a pending friend request from a user.

Arguments

• user_id - The SteamID of the user whose request to accept.

Example

let requester = SteamID::from(76561197960287930);
user.accept_friend_request(requester).await?;

pub async fn ignore_friend_request( &self, user_id: SteamID, ) -> Result<(), SteamUserError>

Ignores or declines a pending friend request.

Arguments

• user_id - The SteamID of the user whose request to ignore.

pub async fn set_communication_block( &self, user_id: SteamID, block: bool, ) -> Result<(), SteamUserError>

Sets or removes a communication block (block/unblock) for a user.

Arguments

• user_id - The SteamID of the user to block or unblock.
• block - true to block, false to unblock.

pub async fn block_user(&self, user_id: SteamID) -> Result<(), SteamUserError>

Blocks all communication from a specified user.

pub async fn unblock_user(&self, user_id: SteamID) -> Result<(), SteamUserError>

Unblocks a previously blocked user.

pub async fn get_friends_list( &self, ) -> Result<HashMap<SteamID, i32>, SteamUserError>

Retrieves the friend list with relationship status codes.

Fetches a list of friends and their relationship status (e.g., 3 for Friend, 2 for Request Sent, etc.).

Returns

Returns a HashMap<SteamID, i32> where the key is the SteamID and the value is the relationship status integer.

pub async fn get_friends_details( &self, ) -> Result<FriendListPage, SteamUserError>

Retrieves the friend list for the currently authenticated user with full profile details.

Scrapes the user’s friends page to gather detailed information about each friend.

Returns

Returns a Vec<FriendDetails> containing information like usernames, online status, and avatars.

pub async fn get_friends_details_of_user( &self, user_id: SteamID, ) -> Result<FriendListPage, SteamUserError>

Retrieves the friend list for a specific Steam account with full details.

Arguments

• user_id - The SteamID of the user whose friend list you want to retrieve.

pub async fn follow_user(&self, user_id: SteamID) -> Result<(), SteamUserError>

Follows a user on Steam to see their public activity in your activity feed.

pub async fn unfollow_user( &self, user_id: SteamID, ) -> Result<(), SteamUserError>

Unfollows a previously followed user.

pub async fn search_users( &self, query: &str, page: u32, ) -> Result<CommunitySearchResult, SteamUserError>

Searches for Steam Community users by their profile name.

Arguments

• query - The search string.
• page - The results page number (starting from 1).

pub async fn create_instant_invite(&self) -> Result<String, SteamUserError>

Creates an instant friend invite link for the current user.

This generates a short link (e.g., https://s.team/p/XXXX-XXXX/TOKEN) that anyone can use to instantly add you as a friend without searching.

pub async fn get_quick_invite_data( &self, ) -> Result<QuickInviteData, SteamUserError>

Retrieves the primary quick invite token and associated metadata for the current user.

pub async fn get_current_quick_invite_tokens( &self, ) -> Result<QuickInviteTokensResponse, SteamUserError>

Retrieves all active quick invite tokens for the authenticated user.

pub async fn get_following_list(&self) -> Result<FriendListPage, SteamUserError>

Retrieves the list of players the current user is following.

Returns

Returns a Vec<FriendDetails> containing information about each followed user.

pub async fn get_following_list_of_user( &self, user_id: SteamID, ) -> Result<FriendListPage, SteamUserError>

Retrieves the list of players a specific user is following.

Arguments

• user_id - The SteamID of the user whose following list to retrieve.

pub async fn get_my_friends_id_list( &self, ) -> Result<Vec<SteamID>, SteamUserError>

Retrieves a simple list of friend SteamIDs for the current user.

This method uses the AJAX API to fetch only SteamIDs of confirmed friends, filtering out pending requests and other relationship types.

Returns

Returns a Vec<SteamID> containing the SteamIDs of all confirmed friends.

pub async fn get_pending_friend_list( &self, ) -> Result<PendingFriendList, SteamUserError>

Retrieves the list of pending friend requests (both incoming and outgoing).

Returns

Returns a PendingFriendList containing both sent and received friend invites.

pub async fn remove_friends( &self, steam_ids: &[SteamID], ) -> Result<(), SteamUserError>

Removes multiple friends at once.

Arguments

• steam_ids - A slice of SteamIDs to remove from the friend list.

pub async fn unfollow_users( &self, steam_ids: &[SteamID], ) -> Result<(), SteamUserError>

Unfollows multiple users at once.

Arguments

• steam_ids - A slice of SteamIDs to unfollow.

pub async fn unfollow_all_following(&self) -> Result<(), SteamUserError>

Unfollows all users the current user is following.

pub async fn cancel_friend_request( &self, steam_id: SteamID, ) -> Result<(), SteamUserError>

Cancels a pending outgoing friend request.

Arguments

This is equivalent to removing a friend - the same API endpoint is used.

• steam_id - The SteamID of the user whose friend request to cancel.

pub async fn get_friends_in_common( &self, steam_id: SteamID, ) -> Result<Vec<FriendDetails>, SteamUserError>

Retrieves mutual friends between the current user and another user.

Arguments

• steam_id - The SteamID of the user to find mutual friends with.

Returns

Returns a Vec<FriendDetails> containing mutual friends.

pub async fn get_friends_in_group( &self, group_id: SteamID, ) -> Result<Vec<FriendDetails>, SteamUserError>

Retrieves friends who are members of a specific group.

Arguments

• group_id - The SteamID of the group.

Returns

Returns a Vec<FriendDetails> containing friends who are in the group.

pub async fn get_friends_gameplay_info( &self, app_id: u32, ) -> Result<GameplayInfoResponse, SteamUserError>

Retrieves friends’ gameplay stats for a specific app.

Arguments

• app_id - The App ID of the game to query.

Returns

Returns a GameplayInfoResponse containing gameplay info.

pub async fn get_friend_since( &self, steam_id: SteamID, ) -> Result<Option<String>, SteamUserError>

Retrieves the date when a friendship with a user started.

Arguments

• steam_id - The SteamID of the friend.

Returns

Returns Some(String) with the friendship date (e.g., “13 June, 2023”) or None if not found.

pub async fn accept_quick_invite_link( &self, invite_link: &str, ) -> Result<(), SteamUserError>

Accepts a friend request via a quick invite link.

Quick invite links are in the format https://s.team/p/XXXX-XXXX/TOKEN or https://steamcommunity.com/user/XXXX/TOKEN.

Arguments

• invite_link - The full quick invite URL.

Example

user.accept_quick_invite_link("https://s.team/p/abcd-efgh/mytoken")
    .await?;

pub async fn accept_quick_invite_data( &self, steamid_user: &str, invite_token: &str, ) -> Result<(), SteamUserError>

Accepts a friend request via quick invite data (steamid and token).

This is the lower-level method that accept_quick_invite_link uses internally.

Arguments

• steamid_user - The SteamID of the user who created the invite.
• invite_token - The unique invite token.

Returns

Returns Ok(()) on success, or an error with the failure code.

impl SteamUser

pub async fn join_group(&self, group_id: SteamID) -> Result<(), SteamUserError>

Joins a Steam group.

Arguments

• group_id - The SteamID of the group to join.

pub async fn leave_group(&self, group_id: SteamID) -> Result<(), SteamUserError>

Leaves a Steam group.

Arguments

• group_id - The SteamID of the group to leave.

pub async fn get_group_members( &self, group_id: SteamID, ) -> Result<Vec<SteamID>, SteamUserError>

Retrieves the list of member SteamIDs for a given group.

Fetches the members list by scraping the group’s XML members list at https://steamcommunity.com/gid/<id>/memberslistxml/?xml=1.

Arguments

• group_id - The SteamID of the group.

Returns

Returns a Vec<SteamID> containing all members of the group.

pub async fn post_group_announcement( &self, group_id: SteamID, headline: &str, content: &str, ) -> Result<(), SteamUserError>

Posts an announcement to a Steam group.

Arguments

• group_id - The SteamID of the group.
• headline - The title of the announcement.
• content - The body text of the announcement.

pub async fn kick_group_member( &self, group_id: SteamID, member_id: SteamID, ) -> Result<(), SteamUserError>

Kicks a member from a Steam group.

Arguments

• group_id - The SteamID of the group.
• member_id - The SteamID of the member to kick.

pub async fn send_image_message( &self, _image_path: impl AsRef<Path>, _steam_id: SteamID, ) -> Result<CommitFileUploadResponse, SteamUserError>

pub async fn invite_user_to_group( &self, user_id: SteamID, group_id: SteamID, ) -> Result<(), SteamUserError>

Invites a user to a Steam group.

Arguments

• user_id - The SteamID of the user to invite.
• group_id - The SteamID of the group to invite them to.

pub async fn invite_users_to_group( &self, user_ids: &[SteamID], group_id: SteamID, ) -> Result<(), SteamUserError>

Invites multiple users to a Steam group in a single request.

Arguments

• user_ids - A slice of SteamIDs of the users to invite.
• group_id - The SteamID of the group.

pub async fn respond_to_group_invite( &self, group_id: SteamID, accept: bool, ) -> Result<(), SteamUserError>

Responds to a Steam group invitation by accepting or ignoring it.

This is the core function for handling group invitations. Use the convenience methods Self::accept_group_invite or Self::ignore_group_invite for simpler usage.

Arguments

• group_id - The SteamID of the group whose invitation to respond to.
• accept - If true, accepts the invite; if false, ignores/declines it.

Returns

• Ok(()) on success.
• Err(SteamUserError) if the request fails or the response indicates failure.

pub async fn accept_group_invite( &self, group_id: SteamID, ) -> Result<(), SteamUserError>

Accept a pending Steam group invitation.

This is a convenience wrapper around Self::respond_to_group_invite with accept = true.

Arguments

• group_id - The SteamID of the group whose invitation to accept.

Returns

• Ok(()) on success.
• Err(SteamUserError) if the request fails.

pub async fn ignore_group_invite( &self, group_id: SteamID, ) -> Result<(), SteamUserError>

Ignore/decline a pending Steam group invitation.

This is a convenience wrapper around Self::respond_to_group_invite with accept = false.

Arguments

• group_id - The SteamID of the group whose invitation to ignore.

Returns

• Ok(()) on success.
• Err(SteamUserError) if the request fails.

pub async fn get_group_overview( &self, options: GroupOverviewOptions, ) -> Result<GroupOverview, SteamUserError>

Fetches an overview of a group, including member counts, headline, and summary.

Arguments

• options - A crate::types::GroupOverviewOptions struct specifying the group and pagination settings.

Returns

Returns a crate::types::GroupOverview struct with the gathered information.

pub async fn get_group_steam_id_from_vanity_url( &self, vanity_url: &str, ) -> Result<String, SteamUserError>

Resolves a group vanity URL to its SteamID.

Arguments

• vanity_url - The group’s vanity URL (e.g., “valve” for steamcommunity.com/groups/valve)

Returns

Returns the group’s SteamID64 as a string, or an error if not found.

Example

let group_id = client.get_group_steam_id_from_vanity_url("valve").await?;

pub async fn get_group_info_xml( &self, gid: Option<SteamID>, group_url: Option<&str>, page: Option<u32>, ) -> Result<GroupInfoXml, SteamUserError>

Gets group information via the XML API.

Arguments

• gid - Optional group SteamID. If provided, uses /gid/{id}/memberslistxml/.
• group_url - Optional group vanity URL. If provided, uses /groups/{url}/memberslistxml/.
• page - Page number (1-indexed, default 1).

Returns

Returns a crate::types::GroupInfoXml struct with group details and member list.

pub async fn get_group_info_xml_full( &self, gid: Option<SteamID>, group_url: Option<&str>, ) -> Result<GroupInfoXml, SteamUserError>

Gets full group information via the XML API, paginating through all members.

Arguments

• gid - Optional group SteamID.
• group_url - Optional group vanity URL.

Returns

Returns a crate::types::GroupInfoXml struct with all members across all pages.

pub async fn get_invitable_groups( &self, user_steam_id: SteamID, ) -> Result<Vec<InvitableGroup>, SteamUserError>

Gets the list of groups that a user can be invited to.

Arguments

• user_steam_id - The SteamID of the user to check invitable groups for.

Returns

Returns a list of crate::types::InvitableGroup that the user can be invited to.

pub async fn invite_all_friends_to_group( &self, group_id: SteamID, ) -> Result<(), SteamUserError>

Invites all friends to a Steam group.

For each friend, checks if the group is invitable, and if so, sends an invite.

Arguments

• group_id - The SteamID of the group to invite friends to.

Returns

Returns Ok(()) on completion. Individual invite failures are silently ignored.

impl SteamUser

pub async fn get_user_inventory_contents( &self, user_id: SteamID, appid: AppId, context_id: ContextId, ) -> Result<Vec<EconItem>, SteamUserError>

Retrieves the contents of a specific user’s inventory.

This method handles pagination automatically and fetches all items for the given application and context.

Arguments

• user_id - The SteamID of the inventory owner.
• appid - The Steam App ID (e.g., 730 for CS:GO, 440 for TF2).
• context_id - The inventory context ID (usually 2).

Returns

Returns a Vec<EconItem> containing all items in the specified inventory.

pub async fn get_inventory( &self, appid: AppId, context_id: ContextId, ) -> Result<Vec<EconItem>, SteamUserError>

Retrieves the inventory of the currently authenticated user.

Convenience method that calls Self::get_user_inventory_contents for the current session.

pub async fn get_inventory_trading( &self, appid: AppId, context_id: ContextId, ) -> Result<Value, SteamUserError>

Retrieves the authenticated user’s inventory in the legacy JSON format used by the trading UI.

This format includes the rgInventory and rgDescriptions structures.

pub async fn get_price_overview( &self, appid: AppId, market_hash_name: &str, ) -> Result<PriceOverview, SteamUserError>

Retrieves current price statistics for a specific market item.

Arguments

• market_hash_name - The unique name used on the Steam Community Market (e.g., “Clutch Case”).

pub async fn get_inventory_trading_partner( &self, appid: AppId, partner: SteamID, context_id: ContextId, ) -> Result<Value, SteamUserError>

Retrieves a trading partner’s inventory in the legacy trading JSON format.

pub async fn get_inventory_history( &self, cursor: Option<InventoryCursor>, ) -> Result<InventoryHistoryResult, SteamUserError>

Retrieves the inventory history for the authenticated user.

This includes detailed records of items added or removed via trades, drops, market actions, etc.

Arguments

• cursor - Optional InventoryCursor for paginated results. Use None for the first page.

pub async fn get_full_inventory_history( &self, ) -> Result<Vec<InventoryHistoryItem>, SteamUserError>

Fetches the entire inventory history by automatically iterating through all pages.

WARNING: This can make many requests for accounts with extensive history.

pub async fn get_active_inventories( &self, ) -> Result<Vec<ActiveInventory>, SteamUserError>

Retrieves a list of apps that have items in the authenticated user’s inventory.

This method parses the user’s inventory page to extract information about which games have items and how many items are in each inventory.

Returns

Returns a Vec<ActiveInventory> containing information about each app with inventory items, including the app ID, game icon, game name, and item count.

impl SteamUser

pub async fn get_gem_value( &self, appid: AppId, assetid: AssetId, ) -> Result<GemValue, SteamUserError>

Retrieves the gem value of a specific Steam inventory item.

Arguments

• appid - The App ID of the item.
• assetid - The unique asset ID of the item in the user’s inventory.

pub async fn turn_item_into_gems( &self, appid: AppId, assetid: AssetId, expected_value: u32, ) -> Result<GemResult, SteamUserError>

Converts a Steam inventory item into gems (Goo).

Arguments

• appid - The App ID of the item.
• assetid - The unique asset ID of the item.
• expected_value - The expected gem value (usually obtained from Self::get_gem_value).

pub async fn open_booster_pack( &self, appid: AppId, assetid: AssetId, ) -> Result<Vec<EconItem>, SteamUserError>

Unpacks a Steam booster pack.

Arguments

• appid - The App ID of the game for the booster pack.
• assetid - The unique asset ID of the booster pack in your inventory.

pub async fn create_booster_pack( &self, appid: AppId, use_untradable_gems: bool, ) -> Result<BoosterResult, SteamUserError>

Creates a booster pack for the specified game using Steam gems.

Arguments

• appid - The App ID of the game to create a booster for.
• use_untradable_gems - If true, untradable gems will be used first.

pub async fn get_booster_pack_catalog( &self, ) -> Result<Vec<BoosterPackEntry>, SteamUserError>

Retrieves the booster pack catalog for the authenticated user.

Returns a list of games for which the user is eligible to create booster packs, including the gem cost and next available creation time.

pub async fn get_my_listings( &self, start: u32, count: u32, ) -> Result<(Vec<MarketListing>, Vec<Value>, u32), SteamUserError>

Retrieves the currently active market listings for the authenticated user.

Arguments

• start - The starting index (offset) for results.
• count - The number of results to fetch (max 100).

Returns

Returns a tuple containing:

• Vec<MarketListing>: The list of active market listings.
• Vec<serde_json::Value>: Associated asset data for the listed items.
• u32: Total number of active listings on Steam (for pagination).

pub async fn get_market_history( &self, start: u32, count: u32, ) -> Result<MarketHistoryResponse, SteamUserError>

Retrieves the market transaction history for the authenticated user.

Arguments

• start - The starting index (offset) for results.
• count - The number of results to fetch (max 100).

pub async fn sell_item( &self, appid: AppId, contextid: ContextId, assetid: AssetId, amount: Amount, price: PriceCents, ) -> Result<SellItemResult, SteamUserError>

Lists an item for sale on the Steam Community Market.

Arguments

• price - The price the SELLER receives, in cents (currency × 100). For VND: 10,000₫ seller-receive → price = 1_000_000.

pub async fn get_market_apps( &self, ) -> Result<HashMap<u32, String>, SteamUserError>

Retrieves a list of all applications that have items listed on the Steam Community Market.

Returns

Returns a HashMap<u32, String> where the key is the App ID and the value is the application name.

pub async fn remove_listing( &self, listing_id: &str, ) -> Result<bool, SteamUserError>

Cancels and removes an active listing from the Steam Community Market.

pub async fn get_market_restrictions( &self, ) -> Result<(MarketRestrictions, Option<WalletBalance>), SteamUserError>

Checks for any active Steam Market restrictions or warnings on the authenticated account.

pub async fn get_item_nameid( &self, app_id: AppId, market_hash_name: &str, ) -> Result<ItemNameId, SteamUserError>

Retrieves the internal item_nameid for a Steam Community Market item.

This ID is required for the orders histogram API and is extracted from the market listing page’s JavaScript code.

Arguments

• app_id - The App ID of the game (e.g., 730 for CS2).
• market_hash_name - The market hash name of the item.

Returns

Returns the numeric item_nameid used by Steam for order book queries.

Example

let client = SteamUser::new(&["cookies"])?;
let item_nameid = client
    .get_item_nameid(AppId::new(730), "AK-47 | Redline (Field-Tested)")
    .await?;
println!("Item nameid: {}", item_nameid);

pub async fn get_item_orders_histogram( &self, item_nameid: ItemNameId, country: &str, currency: u32, ) -> Result<ItemOrdersHistogramResponse, SteamUserError>

Retrieves the buy/sell order histogram for a Steam Community Market item.

This function fetches the order book data showing buy and sell orders at different price points for a specific market item.

Arguments

• item_nameid - The internal item ID (obtained from Self::get_item_nameid).
• country - Country code (e.g., “VN”, “US”, “DE”).
• currency - Steam currency code:
  • 1 = USD
  • 2 = GBP
  • 3 = EUR
  • 15 = VND
  • See Steam documentation for full list.

Returns

Returns an ItemOrdersHistogramResponse containing:

• Highest buy order and lowest sell order prices
• Buy and sell order graph data
• Price formatting information

Example

let client = SteamUser::new(&["cookies"])?;

// First get the item_nameid
let item_nameid = client
    .get_item_nameid(AppId::new(730), "AK-47 | Redline (Field-Tested)")
    .await?;

// Then fetch the order histogram
let histogram = client
    .get_item_orders_histogram(item_nameid, "US", 1)
    .await?;

if let Some(highest_buy) = &histogram.highest_buy_order {
    println!("Highest buy order: {}", highest_buy);
}
if let Some(lowest_sell) = &histogram.lowest_sell_order {
    println!("Lowest sell order: {}", lowest_sell);
}

impl SteamUser

pub async fn get_match_history( &self, match_type: MatchHistoryType, token: Option<&str>, ) -> Result<MatchHistoryResponse, SteamUserError>

Retrieves the CS:GO/CS2 match history for a specific mode and tab.

Arguments

• match_type - The match history type to fetch.
• token - Optional continuation token for pagination.

Returns

Returns a MatchHistoryResponse containing the parsed matches and the next continuation token.

impl SteamUser

pub async fn get_notifications(&self) -> Result<Notifications, SteamUserError>

Retrieves the current counts for various Steam notifications.

This includes unread messages, trade offers, new items, and more.

Returns

Returns a Notifications struct containing the counts for each type of notification.

impl SteamUser

pub async fn get_phone_number_status( &self, ) -> Result<Option<String>, SteamUserError>

Retrieves the current phone number status associated with the authenticated Steam account.

Scrapes the phone management page at https://store.steampowered.com/phone/manage.

Returns

Returns:

• Ok(Some("none")) if no phone number is linked.
• Ok(Some("Ends in XX")) describing the phone if one is bound.
• Ok(None) if the status cannot be determined.

pub async fn add_phone_number( &self, phone: &str, ) -> Result<AddPhoneNumberResponse, SteamUserError>

Initiates the process of adding a phone number to the user’s Steam account.

Arguments

• phone - The phone number to add (including country code, e.g., “+1 555-123-4567”).

pub async fn confirm_phone_code_for_add( &self, code: &str, ) -> Result<ConfirmPhoneCodeResponse, SteamUserError>

Confirms the SMS verification code received after calling Self::add_phone_number.

Arguments

• code - The numeric code received via SMS.

pub async fn resend_phone_verification_code( &self, ) -> Result<Value, SteamUserError>

Initiates a resend of the SMS verification code or retries email verification.

pub async fn get_remove_phone_number_type( &self, ) -> Result<Option<RemovePhoneResult>, SteamUserError>

Determines the available methods for removing the phone number from the account.

Scrapes the Steam Help wizard to find whether removal can be done via SMS, Email, or Mobile App.

pub async fn send_account_recovery_code( &self, wizard_param: Value, method: i32, ) -> Result<Value, SteamUserError>

Sends an account recovery code via the specified method. Methods: 2 = Email, 4 = SMS, 8 = Mobile App.

pub async fn confirm_remove_phone_number_code( &self, wizard_param: Value, code: &str, ) -> Result<Value, SteamUserError>

Confirm the code when removing a phone number.

pub async fn send_confirmation_2_steam_mobile_app( &self, wizard_param: Value, ) -> Result<Value, SteamUserError>

Sends a confirmation request to the Steam Mobile app.

pub async fn send_confirmation_2_steam_mobile_app_final( &self, wizard_param: Value, ) -> Result<Value, SteamUserError>

Sends the final confirmation request to the Steam Mobile app.

impl SteamUser

pub async fn get_privacy_settings( &self, ) -> Result<PrivacySettings, SteamUserError>

Retrieves the current privacy settings for the authenticated user profile.

pub async fn set_privacy_settings( &self, settings: PrivacySettings, ) -> Result<PrivacySettings, SteamUserError>

Updates the privacy settings for the authenticated user profile.

If partial settings are provided, the current settings are fetched and merged to avoid overwriting unspecified fields.

pub async fn set_all_privacy( &self, level: PrivacyState, ) -> Result<PrivacySettings, SteamUserError>

Sets all privacy-related settings to the specified level (Public, Friends Only, or Private).

impl SteamUser

pub async fn edit_profile( &self, settings: ProfileSettings, ) -> Result<(), SteamUserError>

Updates the authenticated user’s profile settings (name, real name, summary, etc.).

This method preserves existing settings for any fields not specified in the settings argument.

pub async fn set_persona_name(&self, name: &str) -> Result<(), SteamUserError>

Updates only the persona (display) name of the authenticated user.

pub async fn upload_avatar( &self, image: &[u8], format: &str, ) -> Result<AvatarUploadResponse, SteamUserError>

Uploads a new avatar image for the authenticated user.

Arguments

• image - The raw image bytes.
• format - The image format extension (e.g., “jpg”, “png”, “gif”).

Returns

Returns the URL of the uploaded avatar on success.

pub async fn post_profile_status( &self, text: &str, app_id: Option<u32>, ) -> Result<u64, SteamUserError>

Posts a status update to the authenticated user’s profile activity feed.

Arguments

• text - The status message to post.
• app_id - Optional App ID to associate with the status.

Returns

Returns the unique ID of the posted status update.

pub async fn upload_avatar_from_file( &self, path: impl AsRef<Path>, ) -> Result<AvatarUploadResponse, SteamUserError>

Upload a new avatar from a local file.

pub async fn upload_avatar_from_url( &self, url: &str, ) -> Result<AvatarUploadResponse, SteamUserError>

Upload a new avatar from a URL.

pub async fn clear_previous_aliases(&self) -> Result<(), SteamUserError>

Clear the user’s previous name aliases history.

This removes all previous display names shown in the “Also known as” section of the Steam profile.

pub async fn set_nickname( &self, user_id: SteamID, nickname: &str, ) -> Result<(), SteamUserError>

Set a nickname for another user.

pub async fn remove_nickname( &self, user_id: SteamID, ) -> Result<(), SteamUserError>

Remove a nickname for another user.

pub async fn get_alias_history( &self, user_id: SteamID, ) -> Result<Vec<AliasEntry>, SteamUserError>

Retrieves the alias history for a user, showing their previous display names.

pub async fn get_profile( &self, steam_id: Option<SteamID>, ) -> Result<SteamProfile, SteamUserError>

Retrieves full profile information for a specified user.

If steam_id is None or matches the authenticated user, it fetches the private-view profile.

pub async fn select_previous_avatar( &self, avatar_hash: &str, ) -> Result<(), SteamUserError>

Selects a previously used avatar by its SHA hash.

This allows users to revert to any avatar they have previously used.

Arguments

• avatar_hash - The SHA hash of the previous avatar (40 character hex string).

Returns

Returns Ok(()) on success.

pub async fn setup_profile(&self) -> Result<bool, SteamUserError>

Initializes a new Steam profile (first-time setup).

This is used for accounts that have not yet set up their Steam Community profile. It navigates to the profile setup page with the welcomed=1 parameter.

Returns

Returns true if profile setup page was loaded successfully.

pub async fn get_user_summary_from_xml( &self, steam_id: SteamID, ) -> Result<UserSummaryXml, SteamUserError>

Fetches user summary from XML profile endpoint.

This retrieves profile information in XML format from /profiles/{steamid}/?xml=1. No authentication is required for public profiles.

Arguments

• steam_id - The SteamID of the user to fetch.

Returns

Returns the parsed UserSummaryXml on success.

pub async fn get_user_summary_from_profile( &self, steam_id: Option<SteamID>, ) -> Result<UserSummaryProfile, SteamUserError>

Fetches user summary by parsing the HTML profile page.

Arguments

• steam_id - Optional SteamID. If None, fetches the logged-in user’s profile.

Returns

Returns the parsed UserSummaryProfile on success.

pub async fn fetch_full_profile( &self, identifier: &str, ) -> Result<SteamProfile, SteamUserError>

Resolves a single user identifier (SteamID or Vanity URL) to a SteamProfile.

This function first attempts to parse the identifier as a SteamID. If that fails, it treats it as a vanity URL and attempts to resolve it using the WebAPI. Note: Resolving a vanity URL requires fetching a Web API key, which might fail if the account is limited. Resolves a single user identifier (SteamID or Vanity URL) to a SteamProfile (Heavy, scraped).

pub async fn resolve_user( &self, steam_id: SteamID, ) -> Result<Option<SteamUserProfile>, SteamUserError>

Resolves a single Steam ID to a lightweight SteamUserProfile.

pub async fn get_avatar_history( &self, ) -> Result<Vec<AvatarHistoryEntry>, SteamUserError>

Fetches the avatar history for a user.

Uses the protobuf endpoint at https://api.steampowered.com/ICommunityService/GetAvatarHistory/v1.

impl SteamUser

pub async fn get_player_reports( &self, ) -> Result<Vec<PlayerReport>, SteamUserError>

Retrieves the history of players that the authenticated user has reported.

Scrapes the user’s report history page at https://steamcommunity.com/my/reports/.

Returns

Returns a Vec<PlayerReport> containing details such as report IDs, dates, and reasons.

impl SteamUser

pub async fn enumerate_tokens( &self, ) -> Result<CAuthenticationRefreshTokenEnumerateResponse, SteamUserError>

Lists all active authentication refresh tokens for the current account.

Requires a mobile access token. These tokens represent active sessions on various devices/browsers.

pub async fn check_token_exists( &self, token_id: &str, ) -> Result<bool, SteamUserError>

Checks if a refresh token with the specified token ID is currently active.

pub async fn revoke_tokens( &self, token_ids: &[&str], shared_secret: Option<&str>, ) -> Result<RevokeTokensResult, SteamUserError>

Revokes multiple authentication refresh tokens at once, effectively logging out those sessions.

Performs a single enumerate_tokens pre-check and post-check to minimise network round-trips. Tokens that are already absent are reported in already_gone; tokens that were sent for revocation but still appear afterwards are reported in failed.

Arguments

• token_ids - Slice of numeric token ID strings to revoke.
• shared_secret - The base64-encoded shared secret for generating the required HMAC signature.

impl SteamUser

pub async fn enable_two_factor( &self, ) -> Result<TwoFactorResponse, SteamUserError>

Initiates the process of enabling two-factor authentication (Steam Guard Mobile Authenticator).

This method starts the registration. You will receive an SMS code that must later be passed to Self::finalize_authenticator.

pub async fn add_authenticator( &self, ) -> Result<TwoFactorResponse, SteamUserError>

Alias for Self::enable_two_factor.

pub async fn finalize_two_factor( &self, shared_secret: &str, activation_code: &str, ) -> Result<(), SteamUserError>

Finalizes the process of adding a mobile authenticator by providing the shared secret.

This is a convenience wrapper that sets the shared_secret in the session before calling Self::finalize_authenticator.

pub async fn finalize_authenticator( &self, activation_code: &str, ) -> Result<(), SteamUserError>

Finalizes the mobile authenticator registration with the numeric code received via SMS.

Arguments

• activation_code - The numeric code received via SMS.

pub async fn disable_two_factor( &self, revocation_code: &str, ) -> Result<(), SteamUserError>

Disables two-factor authentication using a revocation code.

pub async fn remove_authenticator( &self, revocation_code: &str, ) -> Result<(), SteamUserError>

Remove the mobile authenticator using a revocation code.

This is an alias for disable_two_factor.

pub async fn deauthorize_devices(&self) -> Result<(), SteamUserError>

Deauthorizes all other devices currently logged into the Steam account.

pub async fn get_steam_guard_status( &self, ) -> Result<SteamGuardStatus, SteamUserError>

Retrieves the current Steam Guard protection status (Mobile, Email, or None).

pub async fn enable_steam_guard_email(&self) -> Result<bool, SteamUserError>

Enable Email Steam Guard.

pub async fn disable_steam_guard_email(&self) -> Result<bool, SteamUserError>

Disable Steam Guard (Set to None).

impl SteamUser

pub async fn get_web_api_key( &self, domain: &str, ) -> Result<String, SteamUserError>

Retrieves the current Steam Web API key, registering one if none exists.

Arguments

• domain - The domain name to register (e.g., “localhost”).

pub async fn revoke_web_api_key(&self) -> Result<(), SteamUserError>

Revokes the current Steam Web API key for the authenticated user.

pub async fn resolve_vanity_url( &self, api_key: &str, vanity_url_name: &str, ) -> Result<SteamID, SteamUserError>

Resolves a vanity URL (e.g. “gabelogannewell”) to a SteamID using the Web API.

Arguments

• api_key - A valid Steam Web API key.
• vanity_url_name - The vanity name to resolve.

pub async fn resolve_vanity_url_public( &self, vanity: &str, ) -> Result<PublicProfileSummary, SteamUserError>

Resolves a vanity URL (e.g. “gabelogannewell”) and returns a profile snapshot, by scraping the public profile XML feed at https://steamcommunity.com/id/{vanity}/?xml=1.

Anonymous; no API key required. Subject to per-IP community-page rate limits. For an authenticated / quota-managed alternative that returns only the SteamID, see Self::resolve_vanity_url.

Arguments

• vanity - The vanity name to resolve (alphanumerics, _, -).

pub async fn fetch_public_profile_by_id( &self, steam_id: SteamID, ) -> Result<PublicProfileSummary, SteamUserError>

Fetches a profile snapshot for a known SteamID via the public /profiles/{id}/?xml=1 feed. Anonymous; no API key required.

impl SteamUser

pub async fn get_owned_apps(&self) -> Result<Vec<OwnedApp>, SteamUserError>

Retrieves the list of apps owned by the currently authenticated user.

Fetches the list from https://steamcommunity.com/actions/GetOwnedApps/.

Returns

Returns a Vec<OwnedApp> containing details about each app owned by the user.

Example

let apps = user.get_owned_apps().await?;
println!("You own {} apps.", apps.len());

pub async fn get_app_detail( &self, app_ids: &[u32], ) -> Result<HashMap<u32, AppDetail>, SteamUserError>

Retrieves details for one or more Steam applications.

Fetches data from the Steam Store API at https://store.steampowered.com/api/appdetails.

Arguments

• app_ids - A slice of Steam App IDs to fetch details for.

Returns

Returns a HashMap<u32, AppDetail> where the key is the App ID and the value is the AppDetail.

Example

let details = user.get_app_detail(&[730, 440]).await?;
if let Some(csgo) = details.get(&730) {
    println!("App name: {}", csgo.name);
}

pub async fn fetch_csgo_account_stats( &self, ) -> Result<CsgoAccountStats, SteamUserError>

Fetches CS:GO account statistics from the Steam GDPR page.

Scrapes the GDPR activity page for CS:GO (App ID 730) at https://steamcommunity.com/my/gcpd/730/?tab=accountmain. This includes data like last logout, first played, and profile rank.

Returns

Returns a CsgoAccountStats struct containing various account statistics.

Example

let stats = user.fetch_csgo_account_stats().await?;
if let Some(rank) = stats.profile_rank {
    println!("CS:GO Profile Rank: {}", rank);
}

pub async fn fetch_batched_loyalty_reward_items( &self, app_ids: &[u32], ) -> Result<Vec<CLoyaltyRewardsBatchedQueryRewardItemsResponseResponse>, SteamUserError>

Fetches Steam batched loyalty reward items for given app ID(s).

Uses the ILoyaltyRewardsService/BatchedQueryRewardItems Protobuf API. Loyalty rewards include items like profile backgrounds, emojis, and animated avatars.

Arguments

• app_ids - A slice of Steam App IDs to query reward items for.

Returns

Returns a Vec of Protobuf responses containing reward item details for each app.

Example

let rewards = user.fetch_batched_loyalty_reward_items(&[730]).await?;
println!("Found rewards for {} apps.", rewards.len());

pub async fn get_owned_apps_detail( &self, ) -> Result<Vec<OwnedAppDetail>, SteamUserError>

Retrieves detailed information about all games the user owns.

Scrapes the games page at https://steamcommunity.com/my/games/?tab=all and parses the rgGames JavaScript variable.

Returns

Returns a Vec<OwnedAppDetail> containing detailed info about each owned game.

pub async fn get_dynamic_store_user_data( &self, ) -> Result<DynamicStoreUserData, SteamUserError>

Retrieves dynamic store user data including owned apps, wishlist, and ignored apps.

Fetches data from https://store.steampowered.com/dynamicstore/userdata/.

Returns

Returns a DynamicStoreUserData containing lists of owned apps, packages, wishlist, etc.

pub async fn get_owned_apps_id(&self) -> Result<Vec<u32>, SteamUserError>

Retrieves an array of Steam AppIDs that the current user owns.

This is a convenience wrapper around get_dynamic_store_user_data().

Returns

Returns a Vec<u32> containing owned Steam AppIDs.

pub async fn get_steam_app_version_info( app_id: u32, ) -> Result<SteamAppVersionInfo, SteamUserError>

Fetches up-to-date status and version information for a Steam app.

Uses the public API at https://api.steampowered.com/ISteamApps/UpToDateCheck/v1/. This is a static method that doesn’t require authentication.

Arguments

• app_id - The Steam App ID to check.

Returns

Returns a SteamAppVersionInfo containing update status information.

pub async fn suggest_app_list( term: &str, ) -> Result<Vec<AppListItem>, SteamUserError>

Fetches a list of suggested Steam apps based on a search term.

Uses the Steam store search suggestions at https://store.steampowered.com/search/suggest. This is a static method that doesn’t require authentication.

Arguments

• term - The search keyword to suggest apps for.

Returns

Returns a Vec<AppListItem> containing suggested apps.

pub async fn query_app_list( term: &str, ) -> Result<Vec<AppListItem>, SteamUserError>

Fetches a list of Steam apps from the store search results.

Uses the Steam store search at https://store.steampowered.com/search/results/. This is a static method that doesn’t require authentication.

Arguments

• term - The search keyword to query.

Returns

Returns a Vec<AppListItem> containing matched apps.

pub async fn get_app_list() -> Result<SimpleSteamAppList, SteamUserError>

Retrieves the full list of Steam applications.

Uses the public API at https://api.steampowered.com/ISteamApps/GetAppList/v0002/. This is a static method that doesn’t require authentication.

Returns

Returns a SimpleSteamAppList containing all Steam applications.

pub async fn fetch_matchmaking_stats( &self, ) -> Result<MatchmakingStats, SteamUserError>

Fetches CS2 matchmaking stats (cooldown, summary, per-map, last played).

Scrapes https://steamcommunity.com/my/gcpd/730/?tab=matchmaking.

Returns

Returns a [MatchmakingStats] with all four tables parsed from the page.

impl SteamUser

pub async fn get_eligible_event_apps() -> Result<Vec<EligibleEventApp>, SteamUserError>

Fetches eligible event apps from the Steam Points Shop.

Scrapes https://store.steampowered.com/points/shop/c/events and parses the loyalty store data to find event apps. This is a static method that doesn’t require authentication.

Returns

Returns a Vec<EligibleEventApp> containing eligible event apps.

pub async fn get_community_apps( &self, app_ids: &[u32], ) -> Result<CCommunityGetAppsResponse, SteamUserError>

Fetches Steam app information using the Community GetApps API.

Uses the protobuf endpoint at https://api.steampowered.com/ICommunityService/GetApps/v1.

Arguments

• app_ids - A slice of Steam App IDs to fetch.

Returns

Returns the protobuf response containing app information.

pub async fn get_steam_store_items( &self, app_ids: &[u32], ) -> Result<CStoreBrowseGetItemsResponse, SteamUserError>

Retrieves Steam Store items for given app IDs.

Uses the protobuf endpoint at https://api.steampowered.com/IStoreBrowseService/GetItems/v1.

Arguments

• app_ids - A slice of Steam App IDs to fetch store items for.

Returns

Returns the protobuf response containing store item information.

pub async fn get_friend_ownership_for_gifting( &self, access_token: &str, package_id: u32, ) -> Result<FriendOwnershipResponse, SteamUserError>

Checks which friends own a specific package (useful for gifting validation).

Uses the ICheckoutService/GetFriendOwnershipForGifting/v1 endpoint.

Arguments

• access_token - The OAuth access token to use.
• package_id - The Steam Package ID to check (e.g. 54029 for CS:GO Prime).

Returns

Returns a FriendOwnershipResponse containing ownership info for friends.

impl SteamUser

pub async fn get_confirmations( &self, identity_secret: &str, tag: Option<&str>, ) -> Result<Vec<Confirmation>, SteamUserError>

Retrieves a list of outstanding mobile confirmations.

Fetches the confirmation list from https://steamcommunity.com/mobileconf/getlist.

Arguments

• identity_secret - The identity secret for the account (base64 encoded).
• tag - Optional tag for the request (defaults to “conf”).

Returns

Returns a Vec<Confirmation> containing all pending confirmations.

Errors

• Returns SteamUserError::SessionExpired if the session is no longer valid.
• Returns SteamUserError::SteamError if the request fails on the Steam side.

Example

let identity_secret = "your_base64_identity_secret";
let confs = user.get_confirmations(identity_secret, None).await?;
for conf in confs {
    println!("Confirmation: {} (Title: {})", conf.id, conf.title);
}

pub async fn respond_to_confirmation( &self, confirmation: &Confirmation, identity_secret: &str, accept: bool, ) -> Result<(), SteamUserError>

Responds to a single confirmation by either accepting or canceling it.

Arguments

• confirmation - The Confirmation to respond to.
• identity_secret - The identity secret for the account (base64 encoded).
• accept - true to accept, false to cancel/deny.

Example

user.respond_to_confirmation(&conf, identity_secret, true)
    .await?;

pub async fn respond_to_confirmations( &self, confirmations: &[Confirmation], identity_secret: &str, accept: bool, ) -> Result<(), SteamUserError>

Responds to multiple confirmations at once.

Sends a POST request to https://steamcommunity.com/mobileconf/multiajaxop.

Arguments

• confirmations - A slice of Confirmation structs to respond to.
• identity_secret - The identity secret for the account (base64 encoded).
• accept - true to accept all, false to cancel/deny all.

Example

user.respond_to_confirmations(&confs, identity_secret, true)
    .await?;

pub async fn get_confirmation_offer_id( &self, confirmation: &Confirmation, identity_secret: &str, ) -> Result<Option<String>, SteamUserError>

Retrieves the trade offer ID or market listing ID associated with a confirmation.

Scrapes the confirmation details page at https://steamcommunity.com/mobileconf/detailspage/<id>.

Arguments

• confirmation - The Confirmation to get details for.
• identity_secret - The identity secret for the account (base64 encoded).

Returns

Returns Ok(Some(String)) containing the object ID if found.

pub async fn perform_confirmation_action( &self, identity_secret: &str, object_id: u64, accept: bool, ) -> Result<(), SteamUserError>

Performs an action (accept or deny) for a specific confirmation object ID.

This method first fetches the confirmation list to find the one matching the object_id.

Arguments

• identity_secret - The identity secret for the account (base64 encoded).
• object_id - The unique identifier for the confirmation object (trade offer ID or market listing ID).
• accept - true to accept, false to deny.

Errors

Returns SteamUserError::ConfirmationNotFound if no confirmation matches the ID.

pub async fn accept_confirmation_for_object( &self, identity_secret: &str, object_id: u64, ) -> Result<(), SteamUserError>

Accepts a confirmation for a specific object (trade offer ID or market listing ID).

Convenience wrapper around [perform_confirmation_action].

pub async fn deny_confirmation_for_object( &self, identity_secret: &str, object_id: u64, ) -> Result<(), SteamUserError>

Denies a confirmation for a specific object (trade offer ID or market listing ID).

Convenience wrapper around [perform_confirmation_action].

impl SteamUser

pub async fn get_account_email(&self) -> Result<String, SteamUserError>

Retrieves the email address associated with the current Steam account.

Scrapes the account settings page at https://store.steampowered.com/account/.

Returns

Returns the account email address as a String, or an empty string if not found.

Errors

Returns an error if the request fails.

Example

let email = user.get_account_email().await?;
println!("Account email: {}", email);

pub async fn get_current_steam_login(&self) -> Result<String, SteamUserError>

Retrieves the current Steam login username.

Scrapes the games page to extract the logged-in machine text.

Returns

Returns the current login username as a String, or an empty string if not found.

Errors

Returns an error if the request fails.

Example

let login = user.get_current_steam_login().await?;
println!("Current login: {}", login);

pub async fn change_email<F, Fut>( &self, new_email: &str, identity_secret: &str, get_email_otp: F, ) -> Result<ChangeEmailResult, SteamUserError>

where F: Fn() -> Fut, Fut: Future<Output = Option<Vec<String>>>,

Changes the email address associated with the Steam account.

This is a multi-step wizard flow that:

1. Initiates the help wizard for email change
2. Requests mobile app confirmation
3. Sends account recovery code
4. Accepts mobile confirmations
5. Polls for confirmation completion
6. Submits the new email address
7. Confirms with OTP code from the new email

Arguments

• new_email - The new email address to set.
• identity_secret - The identity secret for mobile confirmations.
• get_email_otp - An async function that returns OTP codes from the new email inbox. This will be called multiple times with increasing delays.

Returns

Returns ChangeEmailResult::Success if the email was changed successfully, or ChangeEmailResult::Error with an error message if it failed.

Example

let result = user
    .change_email(
        "new_email@example.com",
        "identity_secret_base64",
        || async {
            // Fetch OTP code from new email inbox
            // Return None if not available yet, or Some(codes) with list of codes
            Some(vec!["123456".to_string()])
        },
    )
    .await;

match result {
    Ok(r) if r.is_success() => println!("Email changed!"),
    Ok(r) => println!("Failed: {:?}", r.error_message()),
    Err(e) => println!("Error: {}", e),
}

impl SteamUser

pub async fn get_help_requests( &self, ) -> Result<Vec<HelpRequest>, SteamUserError>

Lists active and past Steam support tickets (Help Requests).

Scrapes the Steam Help Requests page at https://help.steampowered.com/en/wizard/HelpRequests.

Returns

Returns a Vec<HelpRequest> containing a summary of each support ticket.

pub async fn get_help_request_detail( &self, id: &str, ) -> Result<String, SteamUserError>

Retrieves the detailed conversation for a specific support ticket.

Arguments

• id - The Steam help request ID (e.g., “HT-XXXX-XXXX-XXXX”).

Returns

Returns the raw HTML content of the help request conversation details.

impl SteamUser

pub async fn add_free_license( &self, package_id: u32, ) -> Result<bool, SteamUserError>

Adds a free license for a given package ID to the user’s Steam account.

Arguments

• package_id - The package ID (not app ID) to add as a free license.

Returns

Returns Ok(true) if the license was successfully added.

pub async fn add_sub_free_license( &self, sub_id: u32, ) -> Result<bool, SteamUserError>

Adds a free subscription license for a given sub ID to the user’s Steam account.

Arguments

• sub_id - The subscription ID to add as a free license.

pub async fn redeem_points( &self, definition_id: u32, ) -> Result<CLoyaltyRewardsRedeemPointsResponse, SteamUserError>

Redeems Steam Points for a specified loyalty reward (backgrounds, emojis, etc.).

Arguments

• definition_id - The definition ID of the reward item in the Points Shop.

impl SteamUser

pub async fn get_trade_url(&self) -> Result<Option<String>, SteamUserError>

Retrieves the authenticated user’s unique trade offer URL.

This URL allows other users to send you trade offers without being on your friends list. The URL is scraped from the user’s trade privacy settings page.

pub async fn get_trade_offer( &self, ) -> Result<TradeOffersResponse, SteamUserError>

Retrieves a list of active trade offers (incoming and outgoing) from the trade offers page.

Scrapes https://steamcommunity.com/my/tradeoffers/ to extract offer IDs, status, and item summaries.

pub async fn send_trade_offer( &self, trade_url: &str, my_assets: Vec<TradeOfferAsset>, their_assets: Vec<TradeOfferAsset>, message: &str, ) -> Result<TradeOfferResult, SteamUserError>

Sends a new trade offer to a partner using their trade URL.

Arguments

• trade_url - The full trade offer URL of the partner.
• my_assets - A list of TradeOfferAsset from your inventory to give.
• their_assets - A list of TradeOfferAsset from their inventory to receive.
• message - An optional message to include with the trade offer.

pub async fn accept_trade_offer( &self, trade_offer_id: u64, partner_steam_id: Option<String>, ) -> Result<String, SteamUserError>

Accepts an incoming trade offer.

Arguments

• trade_offer_id - The unique ID of the trade offer to accept.
• partner_steam_id - Optional Steam ID of the partner. If not provided, it will be scraped from the offer page.

pub async fn decline_trade_offer( &self, trade_offer_id: u64, ) -> Result<(), SteamUserError>

Declines or cancels a Steam trade offer.

Arguments

• trade_offer_id - The unique ID of the trade offer to decline.

pub fn parse_trade_url(&self, trade_url: &str) -> Option<ParsedTradeURL>

Parses a Steam trade offer URL and extracts key partner information.

Trait Implementations

impl Clone for SteamUser

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SteamUser

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl SteamUserApi for SteamUser

type Error = SteamUserError

The error type returned by all methods.

fn get_account_details<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<AccountDetails, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_steam_wallet_balance<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<WalletBalance, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_amount_spent_on_steam<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_purchase_history<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<PurchaseHistoryItem>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn redeem_wallet_code<'life0, 'life1, 'async_trait>( &'life0 self, code: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<RedeemWalletCodeResponse, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn parental_unlock<'life0, 'life1, 'async_trait>( &'life0 self, pin: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_friend_activity<'life0, 'async_trait>( &'life0 self, start: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<FriendActivityResponse, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_friend_activity_full<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<FriendActivity>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn comment_user_received_new_game<'life0, 'life1, 'async_trait>( &'life0 self, steam_id: SteamID, thread_id: u64, comment: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<ActivityCommentResponse, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn rate_up_user_received_new_game<'life0, 'async_trait>( &'life0 self, steam_id: SteamID, thread_id: u64, ) -> Pin<Box<dyn Future<Output = Result<ActivityCommentResponse, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn delete_comment_user_received_new_game<'life0, 'life1, 'async_trait>( &'life0 self, steam_id: SteamID, thread_id: u64, comment_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<ActivityCommentResponse, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_owned_apps<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<OwnedApp>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_owned_apps_id<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<u32>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_owned_apps_detail<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<OwnedAppDetail>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_app_detail<'life0, 'life1, 'async_trait>( &'life0 self, app_ids: &'life1 [u32], ) -> Pin<Box<dyn Future<Output = Result<HashMap<u32, AppDetail>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn fetch_csgo_account_stats<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<CsgoAccountStats, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_app_list<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<SimpleSteamAppList, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn suggest_app_list<'life0, 'life1, 'async_trait>( &'life0 self, term: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<AppListItem>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn query_app_list<'life0, 'life1, 'async_trait>( &'life0 self, term: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<AppListItem>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_steam_app_version_info<'life0, 'async_trait>( &'life0 self, app_id: u32, ) -> Pin<Box<dyn Future<Output = Result<SteamAppVersionInfo, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_dynamic_store_user_data<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<DynamicStoreUserData, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn fetch_batched_loyalty_reward_items<'life0, 'life1, 'async_trait>( &'life0 self, app_ids: &'life1 [u32], ) -> Pin<Box<dyn Future<Output = Result<Vec<CLoyaltyRewardsBatchedQueryRewardItemsResponseResponse>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_my_comments<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<UserComment>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_user_comments<'life0, 'async_trait>( &'life0 self, steam_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<Vec<UserComment>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn post_comment<'life0, 'life1, 'async_trait>( &'life0 self, steam_id: SteamID, message: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<UserComment>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn delete_comment<'life0, 'life1, 'async_trait>( &'life0 self, steam_id: SteamID, gidcomment: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_confirmations<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, identity_secret: &'life1 str, tag: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Confirmation>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn accept_confirmation_for_object<'life0, 'life1, 'async_trait>( &'life0 self, identity_secret: &'life1 str, object_id: u64, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn deny_confirmation_for_object<'life0, 'life1, 'async_trait>( &'life0 self, identity_secret: &'life1 str, object_id: u64, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_account_email<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_current_steam_login<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn add_friend<'life0, 'async_trait>( &'life0 self, steam_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn remove_friend<'life0, 'async_trait>( &'life0 self, steam_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn accept_friend_request<'life0, 'async_trait>( &'life0 self, steam_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn ignore_friend_request<'life0, 'async_trait>( &'life0 self, steam_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn block_user<'life0, 'async_trait>( &'life0 self, steam_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn unblock_user<'life0, 'async_trait>( &'life0 self, steam_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_friends_list<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<HashMap<SteamID, i32>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_friends_details<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<FriendListPage, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_friends_details_of_user<'life0, 'async_trait>( &'life0 self, steam_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<FriendListPage, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn search_users<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 str, page: u32, ) -> Pin<Box<dyn Future<Output = Result<CommunitySearchResult, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn create_instant_invite<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn follow_user<'life0, 'async_trait>( &'life0 self, steam_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn unfollow_user<'life0, 'async_trait>( &'life0 self, steam_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_following_list<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<FriendListPage, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_following_list_of_user<'life0, 'async_trait>( &'life0 self, steam_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<FriendListPage, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_my_friends_id_list<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<SteamID>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_pending_friend_list<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<PendingFriendList, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn remove_friends<'life0, 'life1, 'async_trait>( &'life0 self, steam_ids: &'life1 [SteamID], ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn unfollow_users<'life0, 'life1, 'async_trait>( &'life0 self, steam_ids: &'life1 [SteamID], ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn cancel_friend_request<'life0, 'async_trait>( &'life0 self, steam_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_friends_in_common<'life0, 'async_trait>( &'life0 self, steam_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<Vec<FriendDetails>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn join_group<'life0, 'async_trait>( &'life0 self, group_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn leave_group<'life0, 'async_trait>( &'life0 self, group_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_group_members<'life0, 'async_trait>( &'life0 self, group_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<Vec<SteamID>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn post_group_announcement<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, group_id: SteamID, headline: &'life1 str, content: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn kick_group_member<'life0, 'async_trait>( &'life0 self, group_id: SteamID, member_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn invite_user_to_group<'life0, 'async_trait>( &'life0 self, user_id: SteamID, group_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn invite_users_to_group<'life0, 'life1, 'async_trait>( &'life0 self, user_ids: &'life1 [SteamID], group_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn accept_group_invite<'life0, 'async_trait>( &'life0 self, group_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn ignore_group_invite<'life0, 'async_trait>( &'life0 self, group_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_group_overview<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, gid: Option<SteamID>, group_url: Option<&'life1 str>, page: Option<i32>, search_key: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<GroupOverview, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn get_group_steam_id_from_vanity_url<'life0, 'life1, 'async_trait>( &'life0 self, vanity_url: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_group_info_xml<'life0, 'life1, 'async_trait>( &'life0 self, gid: Option<SteamID>, group_url: Option<&'life1 str>, page: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<GroupInfoXml, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_group_info_xml_full<'life0, 'life1, 'async_trait>( &'life0 self, gid: Option<SteamID>, group_url: Option<&'life1 str>, ) -> Pin<Box<dyn Future<Output = Result<GroupInfoXml, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_invitable_groups<'life0, 'async_trait>( &'life0 self, user_steam_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<Vec<InvitableGroup>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn invite_all_friends_to_group<'life0, 'async_trait>( &'life0 self, group_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_inventory<'life0, 'async_trait>( &'life0 self, appid: AppId, context_id: ContextId, ) -> Pin<Box<dyn Future<Output = Result<Vec<EconItem>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_user_inventory_contents<'life0, 'async_trait>( &'life0 self, steam_id: SteamID, appid: AppId, context_id: ContextId, ) -> Pin<Box<dyn Future<Output = Result<Vec<EconItem>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_inventory_history<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<InventoryHistoryResult, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_price_overview<'life0, 'life1, 'async_trait>( &'life0 self, appid: AppId, market_hash_name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<PriceOverview, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_active_inventories<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<ActiveInventory>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_inventory_trading<'life0, 'async_trait>( &'life0 self, appid: AppId, context_id: ContextId, ) -> Pin<Box<dyn Future<Output = Result<Value, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_inventory_trading_partner<'life0, 'async_trait>( &'life0 self, appid: AppId, partner: SteamID, context_id: ContextId, ) -> Pin<Box<dyn Future<Output = Result<Value, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_full_inventory_history<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<InventoryHistoryItem>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_my_listings<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<MyListingsResult, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_market_history<'life0, 'async_trait>( &'life0 self, start: u32, count: u32, ) -> Pin<Box<dyn Future<Output = Result<MarketHistoryResponse, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn sell_item<'life0, 'async_trait>( &'life0 self, appid: AppId, contextid: ContextId, assetid: AssetId, amount: Amount, price: PriceCents, ) -> Pin<Box<dyn Future<Output = Result<SellItemResult, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn remove_listing<'life0, 'life1, 'async_trait>( &'life0 self, listing_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_gem_value<'life0, 'async_trait>( &'life0 self, appid: AppId, assetid: AssetId, ) -> Pin<Box<dyn Future<Output = Result<GemValue, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn turn_item_into_gems<'life0, 'async_trait>( &'life0 self, appid: AppId, assetid: AssetId, expected_value: u32, ) -> Pin<Box<dyn Future<Output = Result<GemResult, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_booster_pack_catalog<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<BoosterPackEntry>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn create_booster_pack<'life0, 'async_trait>( &'life0 self, appid: AppId, use_untradable_gems: bool, ) -> Pin<Box<dyn Future<Output = Result<BoosterResult, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn open_booster_pack<'life0, 'async_trait>( &'life0 self, appid: AppId, assetid: AssetId, ) -> Pin<Box<dyn Future<Output = Result<Vec<EconItem>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_market_restrictions<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(MarketRestrictions, Option<WalletBalance>), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_market_apps<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<HashMap<u32, String>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_item_nameid<'life0, 'life1, 'async_trait>( &'life0 self, app_id: AppId, market_hash_name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<ItemNameId, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_item_orders_histogram<'life0, 'life1, 'async_trait>( &'life0 self, item_nameid: ItemNameId, country: &'life1 str, currency: u32, ) -> Pin<Box<dyn Future<Output = Result<ItemOrdersHistogramResponse, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_phone_number_status<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn add_phone_number<'life0, 'life1, 'async_trait>( &'life0 self, phone: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<AddPhoneNumberResponse, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn confirm_phone_code_for_add<'life0, 'life1, 'async_trait>( &'life0 self, code: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<ConfirmPhoneCodeResponse, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn resend_phone_verification_code<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Value, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_remove_phone_number_type<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<RemovePhoneResult>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn send_account_recovery_code<'life0, 'async_trait>( &'life0 self, wizard_param: Value, method: i32, ) -> Pin<Box<dyn Future<Output = Result<Value, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn confirm_remove_phone_number_code<'life0, 'life1, 'async_trait>( &'life0 self, wizard_param: Value, code: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Value, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn send_confirmation_2_steam_mobile_app<'life0, 'async_trait>( &'life0 self, wizard_param: Value, ) -> Pin<Box<dyn Future<Output = Result<Value, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn send_confirmation_2_steam_mobile_app_final<'life0, 'async_trait>( &'life0 self, wizard_param: Value, ) -> Pin<Box<dyn Future<Output = Result<Value, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_privacy_settings<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<PrivacySettings, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn set_privacy_settings<'life0, 'async_trait>( &'life0 self, settings: PrivacySettings, ) -> Pin<Box<dyn Future<Output = Result<PrivacySettings, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn set_all_privacy<'life0, 'life1, 'async_trait>( &'life0 self, level: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<PrivacySettings, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_profile<'life0, 'async_trait>( &'life0 self, steam_id: Option<SteamID>, ) -> Pin<Box<dyn Future<Output = Result<SteamProfile, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn edit_profile<'life0, 'async_trait>( &'life0 self, _settings: Value, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

👎Deprecated:

scraper is !Send; call SteamUser::edit_profile() directly instead of using this trait method

fn set_persona_name<'life0, 'life1, 'async_trait>( &'life0 self, name: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_alias_history<'life0, 'async_trait>( &'life0 self, steam_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<Vec<AliasEntry>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn clear_previous_aliases<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn set_nickname<'life0, 'life1, 'async_trait>( &'life0 self, steam_id: SteamID, nickname: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn remove_nickname<'life0, 'async_trait>( &'life0 self, steam_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn post_profile_status<'life0, 'life1, 'async_trait>( &'life0 self, text: &'life1 str, app_id: Option<u32>, ) -> Pin<Box<dyn Future<Output = Result<u64, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn select_previous_avatar<'life0, 'life1, 'async_trait>( &'life0 self, avatar_hash: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn setup_profile<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_user_summary_from_xml<'life0, 'async_trait>( &'life0 self, steam_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<UserSummaryXml, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_user_summary_from_profile<'life0, 'async_trait>( &'life0 self, steam_id: Option<SteamID>, ) -> Pin<Box<dyn Future<Output = Result<UserSummaryProfile, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn fetch_full_profile<'life0, 'async_trait>( &'life0 self, _steam_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<SteamProfile, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

👎Deprecated:

scraper is !Send; call SteamUser::fetch_full_profile() directly instead of using this trait method

fn resolve_user<'life0, 'async_trait>( &'life0 self, steam_id: SteamID, ) -> Pin<Box<dyn Future<Output = Result<Option<SteamUserProfile>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_avatar_history<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<AvatarHistoryEntry>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn upload_avatar_from_url<'life0, 'life1, 'async_trait>( &'life0 self, url: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<AvatarUploadResponse, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn enumerate_tokens<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<CAuthenticationRefreshTokenEnumerateResponse, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn check_token_exists<'life0, 'life1, 'async_trait>( &'life0 self, token_id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn revoke_tokens<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, token_ids: &'life1 [&'life2 str], shared_secret: Option<&'life3 str>, ) -> Pin<Box<dyn Future<Output = Result<RevokeTokensResult, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

fn get_trade_url<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Option<String>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_trade_offer<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<TradeOffersResponse, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn accept_trade_offer<'life0, 'async_trait>( &'life0 self, trade_offer_id: u64, partner_steam_id: Option<String>, ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn decline_trade_offer<'life0, 'async_trait>( &'life0 self, trade_offer_id: u64, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn send_trade_offer<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, trade_url: &'life1 str, my_assets: Vec<TradeOfferAsset>, their_assets: Vec<TradeOfferAsset>, message: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<TradeOfferResult, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn get_steam_guard_status<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<SteamGuardStatus, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn enable_two_factor<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<TwoFactorResponse, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn finalize_two_factor<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, shared_secret: &'life1 str, activation_code: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn disable_two_factor<'life0, 'life1, 'async_trait>( &'life0 self, revocation_code: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn deauthorize_devices<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn add_authenticator<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<TwoFactorResponse, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn finalize_authenticator<'life0, 'life1, 'async_trait>( &'life0 self, activation_code: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn remove_authenticator<'life0, 'life1, 'async_trait>( &'life0 self, revocation_code: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn enable_steam_guard_email<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn disable_steam_guard_email<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_player_reports<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<PlayerReport>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn add_free_license<'life0, 'async_trait>( &'life0 self, package_id: u32, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn add_sub_free_license<'life0, 'async_trait>( &'life0 self, sub_id: u32, ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn redeem_points<'life0, 'async_trait>( &'life0 self, definition_id: u32, ) -> Pin<Box<dyn Future<Output = Result<CLoyaltyRewardsRedeemPointsResponse, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_help_requests<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<HelpRequest>, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_help_request_detail<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn get_match_history<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, match_type: &'life1 str, token: Option<&'life2 str>, ) -> Pin<Box<dyn Future<Output = Result<MatchHistoryResponse, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn logged_in<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<LoggedInResult, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_notifications<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Notifications, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

fn get_web_api_key<'life0, 'life1, 'async_trait>( &'life0 self, _domain: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<String, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

👎Deprecated:

scraper is !Send; call SteamUser::get_web_api_key() directly instead of using this trait method

fn resolve_vanity_url<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, api_key: &'life1 str, vanity_name: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<SteamID, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn revoke_web_api_key<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<(), Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,