API reference #

property community_url: str | None#

The Steam ID’s community url if it is a Type.Individual or Type.Clan.

e.g https://steamcommunity.com/profiles/123456789 or https://steamcommunity.com/gid/123456789.

await equipped_profile_items(*, language=None)#

The user’s equipped profile items.

Parameters:: language (Language | None) – The language to fetch the profile items in. If None the current language is used
Return type:: EquippedProfileItems[Self]

await favourite_badge()#

The user’s favourite badge.

Return type:: FavouriteBadge[PartialApp | Literal[STEAM]] | None

await fetch_comment(id, /)#

Fetch a comment by its ID.

Parameters:: id (int) – The ID of the comment to fetch.
Return type:: Comment[Self]

await fetch_post(id, /)#

Fetch a post by its id.

Parameters:: id (int) – The id of the post to fetch.
Return type:: Post[Self]

await fetch_published_file(id, /, *, revision=PublishedFileRevision.Default, language=None)#

Fetch a published file by its id.

Parameters:

id (int) – The id of the published file to fetch.
revision (PublishedFileRevision) – The desired revision of the published file to fetch.
language (Language | None) – The language to fetch the published file in. If None, the current language is used.

Return type:

PublishedFile[Self] | None

await fetch_review(app)#

Fetch this user’s review for an app.

Parameters:: app (App) – The apps to fetch the reviews for.
Return type:: Review

await fetch_reviews(*apps)#

Fetch this user’s review for apps.

Parameters:: apps (App) – The apps to fetch the reviews for.
Return type:: list[Review]

await friends()#

Fetch the list of the users friends.

Return type:: Sequence[User]

staticmethod from_id2(value, /)#

Create an ID from a user’s id2.

Parameters:: value (str) – The ID2 e.g. STEAM_1:0:1234.

Note

The universe will be set to Universe.Public if it’s 0. See ID.id2_zero.

Return type:: IndividualID | None

staticmethod from_id3(value, /)#

Create an ID from an SteamID’s id3.

Parameters:: value (str) – The ID3 e.g. [U:1:1234].
Return type:: ID | None

staticmethod from_invite_code(value, /)#

Create an ID from a user’s invite_code.

Parameters:: value (str) – The invite code e.g. cv-dgb
Return type:: ID[Literal[Type.Individual]] | None

staticmethod await from_url(url, /, session=None)#

Fetches the ID associated with a Steam Community URL or None.

Note

Each call makes an HTTP request to https://steamcommunity.com.

Examples

The following are valid calls:

>>> await ID.from_url("https://steamcommunity.com/groups/Valve")
>>> await ID.from_url("https://steamcommunity.com/gid/103582791429521412")
>>> await ID.from_url("https://steamcommunity.com/gid/[g:1:4]")
ID(id=4, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

>>> await ID.from_url("https://steamcommunity.com/id/johnc")
>>> await ID.from_url("https://steamcommunity.com/profiles/76561197960265740")
>>> await ID.from_url("https://steamcommunity.com/profiles/[U:1:12]")
>>> await ID.from_url("https://steamcommunity.com/user/r")
ID(id=12, type=Type.Individual, universe=Universe.Public, instance=Instance.Desktop)

>>> await ID.from_url("https://steamcommunity.com/app/570")
ID(id=3703047, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

Parameters:

url (StrOrURL) – The Steam Community URL.
session (ClientSession | None) – The session to make the request with. If None, one is generated.

Return type:

ID[Literal[Type.Individual, Type.Clan]] | None

property id: ID32#: The Steam ID’s 32-bit ID.

property id2: str#

The Steam ID’s ID 2.

e.g STEAM_1:0:1234.

property id2_zero: str#: The Steam ID’s ID 2 accounted for bugged GoldSrc and Orange Box games.

Note

In these games the accounts universe, 1 for Type.Public, should be the X component of STEAM_X:0:1234 however, this was bugged and the value of X was 0.

e.g STEAM_0:0:1234.

property id3: str#

The Steam ID’s ID 3.

e.g [U:1:1234].

id64: Final#: The Steam ID’s 64-bit ID.

property instance: Instance#: The instance of the ID.

async for ... in inventories()#

Fetches all the inventories a user has.

Return type:: AsyncGenerator[Inventory[Item[Self], Self], None]

await inventory(app, /, *, context_id=None, language=None)#

Fetch a user’s Inventory for trading.

Parameters:

app (App) – The app to fetch the inventory for.
context_id (int | None) – The context ID for the inventory normally 2.
language (Language | None) – The language to fetch the inventory in. If None will default to the current language.

Raises:

Forbidden – The user’s inventory is private.

Return type:

Inventory[Item[Self], Self]

await inventory_info()#

Fetch the inventory info of the user.

Source for UserInventoryInfo:

@dataclass(slots=True)
class UserInventoryInfo(Generic[UserT]):
    user: UserT
    app: UserInventoryInfoApp
    total_count: int
    trade_permissions: str
    load_failed: bool
    store_vetted: bool
    owner_only: bool
    contexts: list[UserInventoryInfoContext]

    async def inventories(self) -> AsyncGenerator[Inventory[Item[UserT], UserT], None]:
        """An :term:`asynchronous iterator` for accessing a user's full inventory in an app."""
        for context in self.contexts:
            yield await self.user.inventory(App(id=self.app.id), context_id=context.id)

Return type:: list[UserInventoryInfo[Self]]

property invite_code: str | None#

The Steam ID’s invite code in the s.team invite code format.

e.g. cv-dgb.

await invite_to(app)#

Return type:: AppInvite

property invite_url: str | None#

The Steam ID’s full invite code URL.

e.g https://s.team/p/cv-dgb.

await is_banned()#

Specifies if the user is banned from any part of Steam.

Shorthand for:

bans = await user.bans()
bans.is_banned()

Return type:: bool

is_friend()#

Whether the user is in the ClientUser’s friends.

Return type:: bool

is_valid()#

Whether this Steam ID is valid.

A Steam ID is currently considered valid if:

Return type:: bool

await level()#

Fetches the user’s level.

Return type:: int

await profile(*, language=None)#

Fetch a user’s entire profile information.

Parameters:: language (Language | None) – The language to fetch the profile items in. If None the current language is used

Note

This calls all the profile related functions to return a Profile object which has all the info set.

Return type:: Profile[Self]

await profile_customisation_info()#

Fetch a user’s profile customisation information.

Return type:: ProfileCustomisation[Self]

async for ... in published_files(*, app=None, revision=PublishedFileRevision.Default, type=PublishedFileType.Community, language=None, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a user’s PublishedFiles.

Examples

Usage:

async for file in user.published_files(limit=10):
    print("Author:", file.author, "Published:", file.name)

All parameters are optional.

Parameters:

app (App | None) – The app to fetch published files in.
type (PublishedFileType) – The type of published file to fetch.
revision (PublishedFileRevision) – The desired revision of the published file to fetch.
language (Language | None) – The language to fetch the published file in. If None, the current language is used.
limit (int | None) – The maximum number of published files to search through. Setting this to None will fetch all of the user’s published files.
before (datetime | None) – A time to search for published files before.
after (datetime | None) – A time to search for published files after.

Yields:

await recently_played()#

Fetches the apps the user has recently played.

Return type:: list[UserRecentlyPlayedApp]

async for ... in reviews(*, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a user’s Reviews.

Examples

Usage:

async for review in user.reviews(limit=10):
    recommended = "recommended" if review.recommend else "doesn't recommend"
    print(f"Author: {review.author} {recommended} {review.app}")

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of reviews to search through. Setting this to None will fetch all the user’s reviews.
before (datetime | None) – A time to search for reviews before.
after (datetime | None) – A time to search for reviews after.

Yields:

property trade_url: URL#: The trade url of the user.

property type: TypeT#: The Steam type of the ID.

property universe: Universe#: The Steam universe of the ID.

await wishlist()#

Get the WishlistApps the user has on their wishlist.

Return type:: list[WishlistApp]

class steam.abc.Channel#

Channel(_state: ‘ConnectionState’, clan: ‘ClanT’ = None, group: ‘GroupT’ = None)

clan: ClanT#: The clan this channel belongs to.

group: GroupT#: The group this channel belongs to.

await fetch_message(id, /)#

Fetch a message by its Message.id.

Return type:: MessageT | None

abstractmethod async for ... in history(*, limit=100, before=None, after=None)#

An asynchronous iterator for accessing a channel’s steam.Messages.

Examples

Usage:

async for message in channel.history(limit=10):
    print("Author:", message.author, "Said:", message.content)

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of messages to search through. Setting this to None will fetch all of the channel’s messages, but this will be a very slow operation.
before (datetime | None) – A time to search for messages before.
after (datetime | None) – A time to search for messages after.

Yields:

await send(content=..., /, *, media=None)#

Send a message to a certain destination.

Parameters:

content (Any) – The content of the message to send.
media (Media | None) – The media to send to the user.

Note

Anything as passed to content is implicitly cast to a str.

Raises:

HTTPException – Sending the message failed.
Forbidden – You do not have permission to send the message.

Returns:

The sent message, only applicable if content is passed.

Return type:

MessageT | None

class steam.abc.Commentable#

A mixin that implements commenting functionality.

await fetch_comment(id, /)#

Fetch a comment by its ID.

Parameters:: id (int) – The ID of the comment to fetch.
Return type:: Comment[Self]

await comment(content, /, *, subscribe=True)#

Post a comment to a comments section.

Parameters:

content (str) – The message to add to the comment section.
subscribe (bool) – Whether to subscribe to notifications on any future activity in this comment’s thread.

Returns:

The created comment.

Return type:

Comment[Self, ClientUser]

async for ... in comments(*, oldest_first=False, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a comment section’s Comment objects.

Examples

Usage:

async for comment in commentable.comments(limit=10):
    print("Author:", comment.author, "Said:", comment.content)

All parameters are optional.

Parameters:

oldest_first (bool) – Whether or not to request comments with the oldest comments first or last. Defaults to False.
limit (int | None) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (datetime | None) – A time to search for comments before.
after (datetime | None) – A time to search for comments after.

Yields:

class steam.abc.Messageable#

An ABC that details the common operations on a Steam message. The following classes implement this ABC:

await send(content=..., /, *, media=None)#

Send a message to a certain destination.

Parameters:

content (Any) – The content of the message to send.
media (Media | None) – The media to send to the user.

Note

Anything as passed to content is implicitly cast to a str.

Raises:

HTTPException – Sending the message failed.
Forbidden – You do not have permission to send the message.

Returns:

The sent message, only applicable if content is passed.

Return type:

MessageT | None

abstractmethod async for ... in history(*, limit=100, before=None, after=None)#

An asynchronous iterator for accessing a channel’s steam.Messages.

Examples

Usage:

async for message in channel.history(limit=10):
    print("Author:", message.author, "Said:", message.content)

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of messages to search through. Setting this to None will fetch all of the channel’s messages, but this will be a very slow operation.
before (datetime | None) – A time to search for messages before.
after (datetime | None) – A time to search for messages after.

Yields:

await fetch_message(id, /)#

Fetch a message by its Message.id.

Return type:: MessageT | None

Steam Models#

steam.py provides wrappers around common Steam API objects. These are not meant to be constructed by the user instead you receive them from methods/events.

Achievements#

class steam.AppStat#

Represents a stat for an app.

default_value: int#: The value of the stat.

app: PartialApp#: The app this stat is for.

display_name: str#: The display name of the stat.

name: str#: The name of the stat.

class steam.UserAppStat#

Represents a stat for a user in an app.

increment_only: bool#: Whether the stat can only be incremented.

value: int#: The value of the stat.

app: PartialApp#: The app this stat is for.

display_name: str#: The display name of the stat.

name: str#: The name of the stat.

class steam.AppAchievement#

Represents an achievement for an app.

display_name: str#: The display name of the achievement.

description: str#: The description of the achievement.

icon: CDNAsset#: The icon of the achievement.

icon_gray: CDNAsset#: The gray icon of the achievement.

hidden: bool#: Whether the achievement is hidden from the app’s achievement list.

global_percent_unlocked: float#: The percentage of the players that have this achievement.

app: PartialApp#: The app this achievement is for.

name: str#: The name of the achievement.

class steam.AppStatAchievement#

Represents an achievement for an app.

display_name: str#: The localised name of the achievement.

description: str#: The description of the achievement.

default_value: int#: The default value of the stat.

icon: CDNAsset#: The icon of the achievement.

icon_gray: CDNAsset#: The gray icon of the achievement.

hidden: bool#: Whether the achievement is hidden from the app’s achievement list.

app: PartialApp#: The app this achievement is for.

name: str#: The name of the achievement.

class steam.UserAppAchievement#

Represents an achievement for a user in an app.

app: PartialApp#: The app this achievement is for.

name: str#: The name of the achievement.

display_name: str#: The localised name of the achievement.

min: int | None#: The minimum value of the stat.

max: int | None#: The maximum value of the achievement.

icon: CDNAsset#: The icon of the achievement.

icon_gray: CDNAsset#: The gray icon of the achievement.

hidden: bool#: Whether the achievement is hidden from the app’s achievement list.

description: str#: The description of the achievement.

unlocked_at: datetime | None#: The time the achievement was unlocked at.

class steam.AppStats#

Represents a collection of stats and achievements for an app.

app#: The app these stats and achievement are for.

version#: The version of the schema used to generate the stats and achievements.

achievements#: The achievements for the app.

stats#: The stats for the app.

class steam.UserAppStats#

Represents a collection of stats and achievements for a user in an app.

app#: The app these stats and achievement are for.

version#: The version of the schema used to generate the stats and achievements.

stats: list[UserAppStat]#: The stats for the app.

achievements: list[UserAppAchievement]#: The achievements for the app.

Announcements#

class steam.Announcement(state, clan, data)#

Represents an announcement in a clan.

app#: The app that the event is going to be played in.

author: User | PartialUser#: The event’s author.

becomes_visible#: The time at which the event becomes publicly visible.

clan#: The event’s clan.

await comment(content, /, *, subscribe=True)#

Post a comment to a comments section.

Parameters:

content (str) – The message to add to the comment section.
subscribe (bool) – Whether to subscribe to notifications on any future activity in this comment’s thread.

Returns:

The created comment.

Return type:

Comment[Self, ClientUser]

comment_count: int#: The number of comments on the event.

async for ... in comments(*, oldest_first=False, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a comment section’s Comment objects.

Examples

Usage:

async for comment in commentable.comments(limit=10):
    print("Author:", comment.author, "Said:", comment.content)

All parameters are optional.

Parameters:

oldest_first (bool) – Whether or not to request comments with the oldest comments first or last. Defaults to False.
limit (int | None) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (datetime | None) – A time to search for comments before.
after (datetime | None) – A time to search for comments after.

Yields:

downvotes: int#: The number of down votes on the event.

ends_at#: The time at which the event ends.

await fetch_comment(id, /)#

Fetch a comment by its ID.

Parameters:: id (int) – The ID of the comment to fetch.
Return type:: Comment[Self]

hidden#: Whether the event is currently hidden.

last_edited_at#: The time the event was last edited at.

last_edited_by: User | PartialUser | None#: The user last edited the event.

name: str#: The event’s name.

published#: Whether the event is currently published.

starts_at#: The event’s start time.

stops_being_visible#: The time at which the event stops being publicly visible.

type#: The event’s type.

upvotes: int#: The number of up votes on the event.

id: int#: The event’s ID.

topic_id#: The ID of the forum post comments are sent to.

created_at#: The time at which the announcement was created at.

updated_at#: The time at which the announcement was last updated_at.

approved_at#: The time at which the announcement was approved by a moderator.

content: str#: The event’s description.

tags: Sequence[str]#: The announcement’s tags.

await edit(name=None, content=None)#

Edit the announcement’s details.

Note

If parameters are omitted they use what they are currently set to.

Parameters:

name (str | None) – The announcement’s name.
content (str | None) – The announcement’s content.

await delete()#

Delete this announcement.

await upvote()#

Upvote this announcement.

await downvote()#

Downvote this announcement.

Badge#

class steam.AppBadge#

Represents a badge for an app.

await name()#

Fetches the name of this badge.

Return type:: str

await icon()#

Fetches the URL of this badge.

Return type:: CDNAsset

class steam.UserBadge#

Represents a Steam badge on a user’s profile.

xp#: The badge’s XP.

completed_at#: The time the badge was completed at.

scarcity#: The scarcity of the badge. The lower this value, the rarer the badge.

class steam.UserBadges#

Represents a Steam User’s badges/level.

len(x): Returns the number of badges.

iter(x): Returns an iterator over the badges.

y in x: Returns whether the badge is in the badges.

x[y]: Returns the badge at the given index.

level#: The user’s level.

xp#: The users’s XP.

xp_needed_to_level_up#: The amount of XP the user needs to level up.

xp_needed_for_current_level#: The amount of XP the user’s current level requires to achieve.

badges: Sequence[UserBadge[UserT]]#: A list of the user’s badges.

class steam.FavouriteBadge#

Represents a User’s favourite badge.

type#: The badge’s type.

border_colour#: The badge’s border colour.

Ban#

class steam.Ban#

Represents a Steam ban.

since_last_ban#: The amount of time that has passed since user was last banned

number_of_game_bans: int#: The number of game bans the user has.

is_banned()#

Species if the user is banned from any part of Steam.

Return type:: bool

is_vac_banned()#

Whether or not the user is VAC banned.

Return type:: bool

is_community_banned()#

Whether or not the user is community banned.

Return type:: bool

is_market_banned()#

Whether or not the user is market banned.

Return type:: bool

Bundle#

class steam.Bundle#

Represents a bundle of apps and packages. Read more on steamworks

id#: The bundle’s ID.

name#: The bundle’s name.

property url: str#: The bundle’s store page URL.

class steam.PartialBundle#

await fetch(*, language=None)#

Fetch this bundle.

Shorthand for:

bundle = await client.fetch_bundle(bundle_id)

Return type:: FetchedBundle

await store_item(*, language=None)#

Fetch the store item for this bundle.

Shorthand for:

(item,) = await client.fetch_store_item(bundles=[bundle], language=language)

Return type:: BundleStoreItem

await apps()#

Fetch the bundle’s apps.

Return type:: list[PartialApp[None]]

await packages()#

Fetch the bundle’s packages.

Return type:: list[PartialPackage[None]]

await redeem()#

Redeem this bundle if it’s a free-on-demand bundle.

id#: The bundle’s ID.

name#: The bundle’s name.

class steam.FetchedBundle#

Represents a bundle of games and packages.

creator_clans#: The clans of the creators that created this bundle.

supported_languages#: The languages that this bundle is supported in.

is_on_windows()#

Whether the app is playable on Windows.

Return type:: bool

id#: The bundle’s ID.

name#: The bundle’s name.

is_on_mac_os()#

Whether the app is playable on macOS.

Return type:: bool

is_on_linux()#

Whether the app is playable on Linux.

Return type:: bool

await apps()#

Fetch the bundle’s apps.

Return type:: list[PartialApp[None]]

await packages()#

Fetch the bundle’s packages.

Return type:: list[PartialPackage[None]]

Channel#

class steam.UserChannel#

Represents the channel a DM is sent in.

clan: None#: The clan this channel belongs to.

group: None#: The group this channel belongs to.

participant#: The recipient of any messages sent.

typing()#

Send a typing indicator continuously to the channel while in the context manager.

Note

This only works in DMs.

Usage:

async with channel.typing():
    ...  # do your expensive operations

Return type:: AbstractAsyncContextManager[None]

await trigger_typing()#

Send a typing indicator to the channel once.

Note

This only works in DMs.

history(*, limit=100, before=None, after=None)#

An asynchronous iterator for accessing a channel’s steam.Messages.

Examples

Usage:

async for message in channel.history(limit=10):
    print("Author:", message.author, "Said:", message.content)

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of messages to search through. Setting this to None will fetch all of the channel’s messages, but this will be a very slow operation.
before (datetime | None) – A time to search for messages before.
after (datetime | None) – A time to search for messages after.

Yields:

await fetch_message(id, /)#

Fetch a message by its Message.id.

Return type:: MessageT | None

await send(content=..., /, *, media=None)#

Send a message to a certain destination.

Parameters:

content (Any) – The content of the message to send.
media (Media | None) – The media to send to the user.

Note

Anything as passed to content is implicitly cast to a str.

Raises:

HTTPException – Sending the message failed.
Forbidden – You do not have permission to send the message.

Returns:

The sent message, only applicable if content is passed.

Return type:

MessageT | None

class steam.GroupChannel#

Represents a group channel.

group: GroupT#: The group this channel belongs to.

await bulk_delete(messages, /)#

Bulk delete messages.

Parameters:: messages (Iterable[ChatMessage]) – The messages to delete.

clan: ClanT#: The clan this channel belongs to.

await delete()#

Delete the chat.

await edit(*, name=None, move_below)#

Edit the chat.

Parameters:

name (str | None) – The new name of the chat.
move_below (Self | None) – The chat to move this chat below.

await fetch_message(id, /)#

Fetch a message by its Message.id.

Return type:: ChatMessageT | None

async for ... in history(*, limit=100, before=None, after=None)#

An asynchronous iterator for accessing a channel’s steam.Messages.

Examples

Usage:

async for message in channel.history(limit=10):
    print("Author:", message.author, "Said:", message.content)

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of messages to search through. Setting this to None will fetch all of the channel’s messages, but this will be a very slow operation.
before (datetime | None) – A time to search for messages before.
after (datetime | None) – A time to search for messages after.

Yields:

id#: The ID of the channel.

joined_at: datetime | None#: The time the client joined the chat.

last_message: ChatMessageT | None#: The last message sent in the channel.

name: str | None#: The name of the channel, this could be the same as the name/name, if it’s the main channel.

position: int | None#: The position of the channel in the channel list.

await send(content=..., /, *, media=None)#

Send a message to a certain destination.

Parameters:

content (Any) – The content of the message to send.
media (Media | None) – The media to send to the user.

Note

Anything as passed to content is implicitly cast to a str.

Raises:

HTTPException – Sending the message failed.
Forbidden – You do not have permission to send the message.

Returns:

The sent message, only applicable if content is passed.

Return type:

MessageT | None

class steam.ClanChannel#

Represents a clan channel.

await bulk_delete(messages, /)#

Bulk delete messages.

Parameters:: messages (Iterable[ChatMessage]) – The messages to delete.

clan: ClanT#: The clan this channel belongs to.

await delete()#

Delete the chat.

await edit(*, name=None, move_below)#

Edit the chat.

Parameters:

name (str | None) – The new name of the chat.
move_below (Self | None) – The chat to move this chat below.

await fetch_message(id, /)#

Fetch a message by its Message.id.

Return type:: ChatMessageT | None

group: GroupT#: The group this channel belongs to.

async for ... in history(*, limit=100, before=None, after=None)#

An asynchronous iterator for accessing a channel’s steam.Messages.

Examples

Usage:

async for message in channel.history(limit=10):
    print("Author:", message.author, "Said:", message.content)

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of messages to search through. Setting this to None will fetch all of the channel’s messages, but this will be a very slow operation.
before (datetime | None) – A time to search for messages before.
after (datetime | None) – A time to search for messages after.

Yields:

id#: The ID of the channel.

joined_at: datetime | None#: The time the client joined the chat.

last_message: ChatMessageT | None#: The last message sent in the channel.

name: str | None#: The name of the channel, this could be the same as the name/name, if it’s the main channel.

position: int | None#: The position of the channel in the channel list.

await send(content=..., /, *, media=None)#

Send a message to a certain destination.

Parameters:

content (Any) – The content of the message to send.
media (Media | None) – The media to send to the user.

Note

Anything as passed to content is implicitly cast to a str.

Raises:

HTTPException – Sending the message failed.
Forbidden – You do not have permission to send the message.

Returns:

The sent message, only applicable if content is passed.

Return type:

MessageT | None

Clan#

class steam.Clan#

Represents a Steam clan.

x == y: Checks if two clans are equal.

str(x): Returns the clan’s name.

summary: BBCodeStr | None#: The summary of the clan.

headline: str | None#: The headline of the clan.

created_at: datetime | None#: The time the clan was created at.

member_count: int#: The amount of users in the clan.

online_count: int#: The amount of users currently online.

in_game_count: int#: The amount of user’s currently in game.

language: Language#: The language set for the clan.

location: str#: The location set for the clan.

active_member_count: int#: The number of users in the clan.

app: PartialApp | None#: The steam.PartialApp that the chat group is associated with.

property avatar: Avatar#: The chat group’s avatar.

await ban(member)#

Bans a member of the chat group.

property channels: Sequence[ChatT]#: A list of the chat group’s channels.

chunked: bool#: Whether the chat group has been chunked.

await comment(content, /, *, subscribe=True)#

Post a comment to a comments section.

Parameters:

content (str) – The message to add to the comment section.
subscribe (bool) – Whether to subscribe to notifications on any future activity in this comment’s thread.

Returns:

The created comment.

Return type:

Comment[Self, ClientUser]

async for ... in comments(*, oldest_first=False, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a comment section’s Comment objects.

Examples

Usage:

async for comment in commentable.comments(limit=10):
    print("Author:", comment.author, "Said:", comment.content)

All parameters are optional.

Parameters:

oldest_first (bool) – Whether or not to request comments with the oldest comments first or last. Defaults to False.
limit (int | None) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (datetime | None) – A time to search for comments before.
after (datetime | None) – A time to search for comments after.

Yields:

property community_url: str | None#

The Steam ID’s community url if it is a Type.Individual or Type.Clan.

e.g https://steamcommunity.com/profiles/123456789 or https://steamcommunity.com/gid/123456789.

await create_announcement(name, content, *, hidden=False)#

Create an announcement.

Parameters:

name (str) – The name of the announcement.
content (str) – The content of the announcement.
hidden (bool) – Whether the announcement should initially be hidden.

Returns:

The created announcement.

Return type:

Announcement[Self]

await create_channel(name)#

Creates a channel in the chat group.

Parameters:: name (str) – The name of the channel to create.
Return type:: ChatT

await create_event(name, content, *, type=EventType.Other, app=None, starts_at=None, server_address=None, server_password=None)#

Create an event.

Parameters:

name (str) – The name of the event
content (str) – The content for the event.
type (CreateableEvents) – The type of the event, defaults to EventType.Other.
app (App | None) – The app that will be played in the event. Required if type is EventType.Game.
starts_at (datetime | None) – The time the event will start at.
server_address (IPAdress | str | None) – The address of the server that the event will be played on. This is only allowed if type is EventType.App.
server_password (str | None) – The password for the server that the event will be played on. This is only allowed if type is EventType.App.

Note

It is recommended to use a timezone aware datetime for start.

Returns:: The created event.
Return type:: Event[CreateableEvents, Self]

await create_role(name)#

Creates a role in the chat group.

Parameters:: name (str) – The name of the role to create.
Return type:: Role

property default_channel: ChatT#: The group’s default channel.

property default_role: Role#: The group’s default role.

await fetch_announcement(id)#

Fetch an announcement from its ID.

Parameters:: id (int) – The ID of the announcement.
Return type:: Announcement[Self]

await fetch_comment(id, /)#

Fetch a comment by its ID.

Parameters:: id (int) – The ID of the comment to fetch.
Return type:: Comment[Self]

await fetch_event(id)#

Fetch an event from its ID.

Parameters:: id (int) – The ID of the event.
Return type:: Event[EventType, Self]

staticmethod from_id2(value, /)#

Create an ID from a user’s id2.

Parameters:: value (str) – The ID2 e.g. STEAM_1:0:1234.

Note

The universe will be set to Universe.Public if it’s 0. See ID.id2_zero.

Return type:: IndividualID | None

staticmethod from_id3(value, /)#

Create an ID from an SteamID’s id3.

Parameters:: value (str) – The ID3 e.g. [U:1:1234].
Return type:: ID | None

staticmethod from_invite_code(value, /)#

Create an ID from a user’s invite_code.

Parameters:: value (str) – The invite code e.g. cv-dgb
Return type:: ID[Literal[Type.Individual]] | None

staticmethod await from_url(url, /, session=None)#

Fetches the ID associated with a Steam Community URL or None.

Note

Each call makes an HTTP request to https://steamcommunity.com.

Examples

The following are valid calls:

>>> await ID.from_url("https://steamcommunity.com/groups/Valve")
>>> await ID.from_url("https://steamcommunity.com/gid/103582791429521412")
>>> await ID.from_url("https://steamcommunity.com/gid/[g:1:4]")
ID(id=4, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

>>> await ID.from_url("https://steamcommunity.com/id/johnc")
>>> await ID.from_url("https://steamcommunity.com/profiles/76561197960265740")
>>> await ID.from_url("https://steamcommunity.com/profiles/[U:1:12]")
>>> await ID.from_url("https://steamcommunity.com/user/r")
ID(id=12, type=Type.Individual, universe=Universe.Public, instance=Instance.Desktop)

>>> await ID.from_url("https://steamcommunity.com/app/570")
ID(id=3703047, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

Parameters:

url (StrOrURL) – The Steam Community URL.
session (ClientSession | None) – The session to make the request with. If None, one is generated.

Return type:

ID[Literal[Type.Individual, Type.Clan]] | None

get_channel(id, /)#

Get a channel from cache.

Parameters:: id (int) – The ID of the channel.
Return type:: ChatT | None

get_member(id64, /)#

Get a member of the chat group by id.

Parameters:: id64 (int) – The 64 bit ID of the member to get.
Return type:: MemberT | None

get_role(id, /)#

Get a role from cache.

Parameters:: id (int) – The ID of the role.
Return type:: Role | None

property id: ID32#: The Steam ID’s 32-bit ID.

property id2: str#

The Steam ID’s ID 2.

e.g STEAM_1:0:1234.

property id2_zero: str#: The Steam ID’s ID 2 accounted for bugged GoldSrc and Orange Box games.

Note

In these games the accounts universe, 1 for Type.Public, should be the X component of STEAM_X:0:1234 however, this was bugged and the value of X was 0.

e.g STEAM_0:0:1234.

property id3: str#

The Steam ID’s ID 3.

e.g [U:1:1234].

id64: Final#: The Steam ID’s 64-bit ID.

property instance: Instance#: The instance of the ID.

await invite(user, /)#

Invites a User to the chat group.

Parameters:: user (User) – The user to invite to the chat group.

property invite_code: str | None#

The Steam ID’s invite code in the s.team invite code format.

e.g. cv-dgb.

property invite_url: str | None#

The Steam ID’s full invite code URL.

e.g https://s.team/p/cv-dgb.

is_valid()#

Whether this Steam ID is valid.

A Steam ID is currently considered valid if:

Return type:: bool

await kick(member, expires_at)#

Kicks a member of the chat group.

Parameters:

member (IndividualID) – The member to kick.
expires_at (datetime) – When the kick expires.

property me: MemberT#: The client user’s account in this chat group.

property members: Sequence[MemberT]#: A list of the chat group’s members.

property mods: list[MemberT | PartialMember]#: A list of the chat group’s moderators.

await mute(member, expires_at)#

Mutes a member of the chat group.

Parameters:

member (IndividualID) – The member to mute.
expires_at (datetime) – When the mute expires.

name: str#: The name of the chat group.

property officers: list[MemberT | PartialMember]#: A list of the chat groups’s administrators.

property owner: MemberT | PartialMember#: The chat group’s owner.

property roles: Sequence[Role]#: A list of the group’s roles.

await search(name)#

Search for members in the chat group.

Parameters:: name (str) – The name of the member to search for.
Return type:: Sequence[MemberT]

tagline: str#: The tagline of the chat group.

property top_members: Sequence[MemberT | PartialMember]#: A list of the chat group’s top members.

property type: TypeT#: The Steam type of the ID.

await unban(user)#

Unbans a member of the chat group.

property universe: Universe#: The Steam universe of the ID.

flags: ClanAccountFlags | None#: The flags

await chunk()#

Get a list of all members in the group.

Return type:: Sequence[ClanMember]

is_ogg()#

Whether this clan is an official game group.

Return type:: bool

await edit(*, abbreviation=None, headline=None, summary=None, community_url=None, language=None, country=None, state=None, city=None, apps=None, name=None, tagline=None, avatar=None)#

Edits the clan.

Parameters:

name (str | None) – The new name for the clan’s chat group. Does not change the clan’s name.
tagline (str | None) – The new tagline for the clan.
avatar (Media | None) – The new avatar for the clan.

See also

PartialClan.edit()

async for ... in fetch_members()#

An async iterator over a clan’s member list.

Note

This can be a very slow operation due to the rate limits on this endpoint.

Return type:: AsyncGenerator[ClanMember | PartialMember, None]

await join(*, invite_code=None)#

Joins the chat group.

Parameters:: invite_code (str | None) – The invite code to use to join the chat group.

await leave()#

Leaves the chat group.

async for ... in events(*, limit=100, before=None, after=None)#

An asynchronous iterator over a clan’s steam.Events.

Examples

Usage:

async for event in clan.events(limit=10):
    print(event.author, "made an event", event.name, "starting at", event.starts_at)

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of events to search through. Default is 100. Setting this to None will fetch all the clan’s events, but this will be a very slow operation.
before (datetime | None) – A time to search for events before.
after (datetime | None) –
A time to search for events after.

Warning

If this is None and created_at is None, this has to fetch events all the way back until 2007

Yields:

Event

async for ... in announcements(*, limit=100, before=None, after=None)#

An asynchronous iterator over a clan’s steam.Announcements.

Examples

Usage:

async for announcement in clan.announcements(limit=10):
    print(announcement.author, "made an announcement", announcement.name, "at", announcement.created_at)

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of announcements to search through. Default is 100. Setting this to None will fetch all of the clan’s announcements, but this will be a very slow operation.
before (datetime | None) – A time to search for announcements before.
after (datetime | None) – A time to search for announcements after.

Yields:

Announcement

Comment#

class steam.Comment#

Represents a comment on a Steam profile.

x == y: Checks if two comments are equal.

hash(x): Returns the comment’s hash.

id: ReadOnly[CommentID]#: The comment’s ID.

content: str#: The comment’s content.

created_at: datetime#: The time the comment was posted at.

reactions: list[AwardReaction]#: The comment’s reactions.

author: AuthorT#: The author of the comment.

owner: OwnerT#: The comment sections owner.

await report()#

Reports the comment.

await delete()#

Deletes the comment.

Events#

class steam.Event#

Represents an event in a clan.

server_address: IPv4Address | None#: The event’s server address.

server_password: str | None#: The event’s server password.

app#: The app that the event is going to be played in.

author: User | PartialUser#: The event’s author.

becomes_visible#: The time at which the event becomes publicly visible.

clan#: The event’s clan.

await comment(content, /, *, subscribe=True)#

Post a comment to a comments section.

Parameters:

content (str) – The message to add to the comment section.
subscribe (bool) – Whether to subscribe to notifications on any future activity in this comment’s thread.

Returns:

The created comment.

Return type:

Comment[Self, ClientUser]

comment_count: int#: The number of comments on the event.

async for ... in comments(*, oldest_first=False, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a comment section’s Comment objects.

Examples

Usage:

async for comment in commentable.comments(limit=10):
    print("Author:", comment.author, "Said:", comment.content)

All parameters are optional.

Parameters:

oldest_first (bool) – Whether or not to request comments with the oldest comments first or last. Defaults to False.
limit (int | None) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (datetime | None) – A time to search for comments before.
after (datetime | None) – A time to search for comments after.

Yields:

content: str#: The event’s description.

downvotes: int#: The number of down votes on the event.

ends_at#: The time at which the event ends.

await fetch_comment(id, /)#

Fetch a comment by its ID.

Parameters:: id (int) – The ID of the comment to fetch.
Return type:: Comment[Self]

hidden#: Whether the event is currently hidden.

id: int#: The event’s ID.

last_edited_at#: The time the event was last edited at.

last_edited_by: User | PartialUser | None#: The user last edited the event.

name: str#: The event’s name.

published#: Whether the event is currently published.

starts_at#: The event’s start time.

stops_being_visible#: The time at which the event stops being publicly visible.

type#: The event’s type.

upvotes: int#: The number of up votes on the event.

await server()#

The server that the event will be ran on.

Note

This is shorthand for

await client.fetch_server(ip=event.server_address)

Return type:: GameServer

await edit(name: str, content: str, *, app: App | None = None, starts_at: datetime | None = None, server_address: str | None = None, server_password: str | None = None) → None#

await edit(name: str, content: str, *, type: BoringEvents | None = None, starts_at: datetime | None = None) → None

await edit(name: str, content: str, *, type: Literal[EventType.Game] = None, starts_at: datetime | None = None, app: App, server_address: IPAdress | str | None = None, server_password: str | None = None) → None

Edit the event’s details.

Note

If parameters are omitted they use what they are currently set to.

Parameters:

name – The event’s name.
content – The event’s description.
type – The event’s type.
app – The event’s app.
starts_at – The event’s start time.
server_address – The event’s server’s address.
server_password – The event’s server’s password.

await delete()#

Delete this event.

Game Servers#

class steam.GameServer#

Represents a game server.

name#: The name of the server.

app#: The app of the server.

ip#: The ip of the server.

port#: The port of the server.

tags#: The tags of the server.

map#: The map the server is running.

bot_count#: The number of bots in the server.

player_count#: The number of players the server.

max_player_count#: The maximum player count of the server.

region#: The region the server is in.

property community_url: str | None#

The Steam ID’s community url if it is a Type.Individual or Type.Clan.

e.g https://steamcommunity.com/profiles/123456789 or https://steamcommunity.com/gid/123456789.

staticmethod from_id2(value, /)#

Create an ID from a user’s id2.

Parameters:: value (str) – The ID2 e.g. STEAM_1:0:1234.

Note

The universe will be set to Universe.Public if it’s 0. See ID.id2_zero.

Return type:: IndividualID | None

staticmethod from_id3(value, /)#

Create an ID from an SteamID’s id3.

Parameters:: value (str) – The ID3 e.g. [U:1:1234].
Return type:: ID | None

staticmethod from_invite_code(value, /)#

Create an ID from a user’s invite_code.

Parameters:: value (str) – The invite code e.g. cv-dgb
Return type:: ID[Literal[Type.Individual]] | None

staticmethod await from_url(url, /, session=None)#

Fetches the ID associated with a Steam Community URL or None.

Note

Each call makes an HTTP request to https://steamcommunity.com.

Examples

The following are valid calls:

>>> await ID.from_url("https://steamcommunity.com/groups/Valve")
>>> await ID.from_url("https://steamcommunity.com/gid/103582791429521412")
>>> await ID.from_url("https://steamcommunity.com/gid/[g:1:4]")
ID(id=4, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

>>> await ID.from_url("https://steamcommunity.com/id/johnc")
>>> await ID.from_url("https://steamcommunity.com/profiles/76561197960265740")
>>> await ID.from_url("https://steamcommunity.com/profiles/[U:1:12]")
>>> await ID.from_url("https://steamcommunity.com/user/r")
ID(id=12, type=Type.Individual, universe=Universe.Public, instance=Instance.Desktop)

>>> await ID.from_url("https://steamcommunity.com/app/570")
ID(id=3703047, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

Parameters:

url (StrOrURL) – The Steam Community URL.
session (ClientSession | None) – The session to make the request with. If None, one is generated.

Return type:

ID[Literal[Type.Individual, Type.Clan]] | None

property id: ID32#: The Steam ID’s 32-bit ID.

property id2: str#

The Steam ID’s ID 2.

e.g STEAM_1:0:1234.

property id2_zero: str#: The Steam ID’s ID 2 accounted for bugged GoldSrc and Orange Box games.

Note

In these games the accounts universe, 1 for Type.Public, should be the X component of STEAM_X:0:1234 however, this was bugged and the value of X was 0.

e.g STEAM_0:0:1234.

property id3: str#

The Steam ID’s ID 3.

e.g [U:1:1234].

id64: Final#: The Steam ID’s 64-bit ID.

property instance: Instance#: The instance of the ID.

property invite_code: str | None#

The Steam ID’s invite code in the s.team invite code format.

e.g. cv-dgb.

property invite_url: str | None#

The Steam ID’s full invite code URL.

e.g https://s.team/p/cv-dgb.

is_valid()#

Whether this Steam ID is valid.

A Steam ID is currently considered valid if:

Return type:: bool

property type: TypeT#: The Steam type of the ID.

property universe: Universe#: The Steam universe of the ID.

version#: The version of the server.

game_directory#: The server’s game directory e.g. "cstrike"

is_secure()#

Whether the sever is secured, likely with VAC.

Return type:: bool

is_dedicated()#

Whether the sever is dedicated.

Return type:: bool

await update()#

Update this game server instance in place.

await players()#

Fetch a server’s players.

Returns:

Source for ServerPlayer:

class ServerPlayer(NamedTuple):
    name: str
    """The player's name."""
    score: int
    """The player's score."""
    play_time: timedelta
    """The amount of time the player has spent on the server."""

Return type:

list[ServerPlayer]

await rules()#

Fetch a console variables. e.g. sv_gravity or sv_voiceenable.

Return type:: dict[str, str]

class steam.Query#

A class to construct Global Master Server queries.

classmethod where(**kwargs)#

Construct a query meeting all the given criteria.

Parameters:

empty – Fetches servers that are empty.
is_proxy – Fetches servers that are spectator proxies.
whitelisted – Fetches servers that are whitelisted.
dedicated – Fetches servers that are running dedicated.
secure – Fetches servers that are using anti-cheat technology (VAC, but potentially others as well).
linux – Fetches servers running on a Linux platform.
has_password – Fetches servers that are password protected.
full – Fetches servers that are full.
only_one_per_ip – Fetches only one server for each unique IP address matched.
version_match – Fetches servers running version “x” ("*" is wildcard equivalent to .* in regex).
name_match – Fetches servers with their name matching “x” ("*" is wildcard equivalent to .* in regex).
game_directory – Fetches servers running the specified modification (e.g. cstrike).
map – Fetches servers running the specified map (e.g. cs_italy)
ip – Fetches servers on the specified IP address, port is optional.
app – Fetches servers running a App.
not_app – Fetches servers not running a App.
tags – Fetches servers with all the given tag(s) in GameServer.tags.
region – Fetches servers in a given region.

Returns:

The query that should be passed to Client.fetch_servers(). Examples ——– Match servers running TF2, that are not empty and are using VAC .. code-block:: pycon >>> Query.where( … app=TF2, … empty=False, … secure=True, … ) Match servers where the server name is not “A cool Server” and the server supports “alltalk” and increased max players .. code-block:: pycon >>> Query.where(name_match=”A not cool server*”, match_tags=[“alltalk”, “increased_maxplayers”])

Return type:

str

Group#

class steam.Group#

Represents a Steam group.

await chunk()#

Get a list of all members in the group.

Return type:: Sequence[GroupMember]

active_member_count: int#: The number of users in the clan.

app: PartialApp | None#: The steam.PartialApp that the chat group is associated with.

property avatar: Avatar#: The chat group’s avatar.

await ban(member)#

Bans a member of the chat group.

property channels: Sequence[ChatT]#: A list of the chat group’s channels.

chunked: bool#: Whether the chat group has been chunked.

property community_url: str | None#

The Steam ID’s community url if it is a Type.Individual or Type.Clan.

e.g https://steamcommunity.com/profiles/123456789 or https://steamcommunity.com/gid/123456789.

await create_channel(name)#

Creates a channel in the chat group.

Parameters:: name (str) – The name of the channel to create.
Return type:: ChatT

await create_role(name)#

Creates a role in the chat group.

Parameters:: name (str) – The name of the role to create.
Return type:: Role

property default_channel: ChatT#: The group’s default channel.

property default_role: Role#: The group’s default role.

await edit(*, name=None, tagline=None, avatar=None)#

Edits the chat group.

Parameters:

name (str | None) – The new name of the chat group. If None, the name will not be changed.
tagline (str | None) – The new tagline of the chat group. If None, the tagline will not be changed.
avatar (Media | None) – The new avatar of the chat group. If None, the avatar will not be changed.

staticmethod from_id2(value, /)#

Create an ID from a user’s id2.

Parameters:: value (str) – The ID2 e.g. STEAM_1:0:1234.

Note

The universe will be set to Universe.Public if it’s 0. See ID.id2_zero.

Return type:: IndividualID | None

staticmethod from_id3(value, /)#

Create an ID from an SteamID’s id3.

Parameters:: value (str) – The ID3 e.g. [U:1:1234].
Return type:: ID | None

staticmethod from_invite_code(value, /)#

Create an ID from a user’s invite_code.

Parameters:: value (str) – The invite code e.g. cv-dgb
Return type:: ID[Literal[Type.Individual]] | None

staticmethod await from_url(url, /, session=None)#

Fetches the ID associated with a Steam Community URL or None.

Note

Each call makes an HTTP request to https://steamcommunity.com.

Examples

The following are valid calls:

>>> await ID.from_url("https://steamcommunity.com/groups/Valve")
>>> await ID.from_url("https://steamcommunity.com/gid/103582791429521412")
>>> await ID.from_url("https://steamcommunity.com/gid/[g:1:4]")
ID(id=4, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

>>> await ID.from_url("https://steamcommunity.com/id/johnc")
>>> await ID.from_url("https://steamcommunity.com/profiles/76561197960265740")
>>> await ID.from_url("https://steamcommunity.com/profiles/[U:1:12]")
>>> await ID.from_url("https://steamcommunity.com/user/r")
ID(id=12, type=Type.Individual, universe=Universe.Public, instance=Instance.Desktop)

>>> await ID.from_url("https://steamcommunity.com/app/570")
ID(id=3703047, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

Parameters:

url (StrOrURL) – The Steam Community URL.
session (ClientSession | None) – The session to make the request with. If None, one is generated.

Return type:

ID[Literal[Type.Individual, Type.Clan]] | None

get_channel(id, /)#

Get a channel from cache.

Parameters:: id (int) – The ID of the channel.
Return type:: ChatT | None

get_member(id64, /)#

Get a member of the chat group by id.

Parameters:: id64 (int) – The 64 bit ID of the member to get.
Return type:: MemberT | None

get_role(id, /)#

Get a role from cache.

Parameters:: id (int) – The ID of the role.
Return type:: Role | None

property id: ID32#: The Steam ID’s 32-bit ID.

property id2: str#

The Steam ID’s ID 2.

e.g STEAM_1:0:1234.

property id2_zero: str#: The Steam ID’s ID 2 accounted for bugged GoldSrc and Orange Box games.

Note

In these games the accounts universe, 1 for Type.Public, should be the X component of STEAM_X:0:1234 however, this was bugged and the value of X was 0.

e.g STEAM_0:0:1234.

property id3: str#

The Steam ID’s ID 3.

e.g [U:1:1234].

id64: Final#: The Steam ID’s 64-bit ID.

property instance: Instance#: The instance of the ID.

await invite(user, /)#

Invites a User to the chat group.

Parameters:: user (User) – The user to invite to the chat group.

property invite_code: str | None#

The Steam ID’s invite code in the s.team invite code format.

e.g. cv-dgb.

property invite_url: str | None#

The Steam ID’s full invite code URL.

e.g https://s.team/p/cv-dgb.

is_valid()#

Whether this Steam ID is valid.

A Steam ID is currently considered valid if:

Return type:: bool

await join(*, invite_code=None)#

Joins the chat group.

Parameters:: invite_code (str | None) – The invite code to use to join the chat group.

await kick(member, expires_at)#

Kicks a member of the chat group.

Parameters:

member (IndividualID) – The member to kick.
expires_at (datetime) – When the kick expires.

await leave()#

Leaves the chat group.

property me: MemberT#: The client user’s account in this chat group.

property members: Sequence[MemberT]#: A list of the chat group’s members.

property mods: list[MemberT | PartialMember]#: A list of the chat group’s moderators.

await mute(member, expires_at)#

Mutes a member of the chat group.

Parameters:

member (IndividualID) – The member to mute.
expires_at (datetime) – When the mute expires.

name: str#: The name of the chat group.

property officers: list[MemberT | PartialMember]#: A list of the chat groups’s administrators.

property owner: MemberT | PartialMember#: The chat group’s owner.

property roles: Sequence[Role]#: A list of the group’s roles.

await search(name)#

Search for members in the chat group.

Parameters:: name (str) – The name of the member to search for.
Return type:: Sequence[MemberT]

tagline: str#: The tagline of the chat group.

property top_members: Sequence[MemberT | PartialMember]#: A list of the chat group’s top members.

property type: TypeT#: The Steam type of the ID.

await unban(user)#

Unbans a member of the chat group.

property universe: Universe#: The Steam universe of the ID.

Invite#

class steam.UserInvite#

Represents a invite from a user to become their friend.

await accept()#

Accept the invite request.

await decline()#

Decline the invite request.

author: User | ClientUser | PartialUser#: The user who sent the invite.

relationship: FriendRelationship | None#: The relationship you have with the invitee.

user: User | ClientUser | PartialUser#: The user that was invited.

class steam.ClanInvite#

Represents an invitation to join a Clan from a user.

clan: Clan#: The clan to join.

await accept()#

Accept the invite request.

await decline()#

Decline the invite request.

author: User | ClientUser | PartialUser#: The user who sent the invite.

relationship: FriendRelationship | None#: The relationship you have with the invitee.

await revoke()#

Revoke the invite request.

user: User | ClientUser | PartialUser#: The user that was invited.

Leaderboard#

class steam.Leaderboard#

Represents a leaderboard for an app.

id: LeaderboardID#: The leaderboard’s id.

name: str#: The name of the leaderboard.

app: AppT#: The app this leaderboard is for.

sort_method: LeaderboardSortMethod#: The sort method of the leaderboard.

display_type: LeaderboardDisplayType#: The display type of the leaderboard.

entry_count: int#: The number of entries in the leaderboard.

display_name: DisplayNameT#: The display name of the leaderboard. This is only set if the leaderboard is fetched using PartialApp.leaderboards().

property url: str#: The URL of the leaderboard.

async for ... in entries(*, limit: int | None = None, type: Literal[LeaderboardDataRequest.Users], users: Sequence[IndividualID]) → AsyncGenerator[LeaderboardUser, None]#

async for ... in entries(*, limit: int | None = None, type: LeaderboardDataRequest = LeaderboardDataRequest.Global) → AsyncGenerator[LeaderboardUser, None]

Fetch the entries of the leaderboard.

Parameters:

limit – The maximum number of entries to fetch. If None is passed, all entries will be fetched.
type – The type of entries to fetch.
users – The users to fetch. Only used if type is LeaderboardDataRequest.Users.

Return type:

AsyncGenerator[LeaderboardUser, None]

await set_score(score, *, details, method=LeaderboardUploadScoreMethod.NONE)#

Set the score of the current user on the leaderboard.

Parameters:

score (int) – The score to set.
details (bytes) – The details to set.
method (LeaderboardUploadScoreMethod) – The method to use to upload the score.

Return type:

LeaderboardScoreUpdate

await set_ugc_id(ugc_id)#

Set the UGC ID of the current user on the leaderboard.

class steam.LeaderboardUser#

Represents a user on an app’s leaderboard.

global_rank#: The global rank of the user.

score#: The score of the user.

details#: The details of the user.

ugc_id#: The UGC ID of the user.

await achievements(app, /, *, language=None)#

Fetch the achievements for the user in the app.

Parameters:: language (Language | None) – The language to fetch the stats in. If None will default to the current language.
Return type:: list[UserAppAchievement]

await add()#

Sends a friend invite to the user to your friends list.

app: PartialApp[str] | None#: The app the user is currently in. Is None if the user isn’t in an app.

await app_stats(app, /, *, language=None)#

Fetch the stats for the user in the app.

Parameters:: language (Language | None) – The language to fetch the stats in. If None will default to the current language.
Return type:: UserAppStats

await apps(*, include_free=True)#

Fetches the Apps the user owns.

Parameters:: include_free (bool) – Whether to include free apps in the list. Defaults to True.
Return type:: list[UserApp]

property avatar: Avatar#: The user’s avatar.

await badges()#

Fetches the user’s UserBadgess.

Return type:: UserBadges[Self]

await bans()#

Fetches the user’s Bans.

Return type:: Ban

await block()#

Blocks the user.

await cancel_invite()#

Cancels an invitation sent to the user. This effectively does the same thing as remove().

await clans(*, auto_chunk=False)#

Fetches a list of Clans the user is in.

Parameters:: auto_chunk (bool) – Whether to automatically chunk the clans that are fetched. Defaults to False.
Return type:: list[Clan]

await comment(content, /, *, subscribe=True)#

Post a comment to a comments section.

Parameters:

content (str) – The message to add to the comment section.
subscribe (bool) – Whether to subscribe to notifications on any future activity in this comment’s thread.

Returns:

The created comment.

Return type:

Comment[Self, ClientUser]

async for ... in comments(*, oldest_first=False, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a comment section’s Comment objects.

Examples

Usage:

async for comment in commentable.comments(limit=10):
    print("Author:", comment.author, "Said:", comment.content)

All parameters are optional.

Parameters:

oldest_first (bool) – Whether or not to request comments with the oldest comments first or last. Defaults to False.
limit (int | None) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (datetime | None) – A time to search for comments before.
after (datetime | None) – A time to search for comments after.

Yields:

property community_url: str | None#

The Steam ID’s community url if it is a Type.Individual or Type.Clan.

e.g https://steamcommunity.com/profiles/123456789 or https://steamcommunity.com/gid/123456789.

await equipped_profile_items(*, language=None)#

The user’s equipped profile items.

Parameters:: language (Language | None) – The language to fetch the profile items in. If None the current language is used
Return type:: EquippedProfileItems[Self]

await escrow(token=None)#

Check how long any received items would take to arrive. None if the user has no escrow or has a private inventory.

Parameters:: token (str | None) – The user’s trade offer token, not required if you are friends with the user.
Return type:: timedelta | None

await favourite_badge()#

The user’s favourite badge.

Return type:: FavouriteBadge[PartialApp | Literal[STEAM]] | None

await fetch_comment(id, /)#

Fetch a comment by its ID.

Parameters:: id (int) – The ID of the comment to fetch.
Return type:: Comment[Self]

await fetch_message(id, /)#

Fetch a message by its Message.id.

Return type:: MessageT | None

await fetch_post(id, /)#

Fetch a post by its id.

Parameters:: id (int) – The id of the post to fetch.
Return type:: Post[Self]

await fetch_published_file(id, /, *, revision=PublishedFileRevision.Default, language=None)#

Fetch a published file by its id.

Parameters:

id (int) – The id of the published file to fetch.
revision (PublishedFileRevision) – The desired revision of the published file to fetch.
language (Language | None) – The language to fetch the published file in. If None, the current language is used.

Return type:

PublishedFile[Self] | None

await fetch_review(app)#

Fetch this user’s review for an app.

Parameters:: app (App) – The apps to fetch the reviews for.
Return type:: Review

await fetch_reviews(*apps)#

Fetch this user’s review for apps.

Parameters:: apps (App) – The apps to fetch the reviews for.
Return type:: list[Review]

flags: PersonaStateFlag#: The persona state flags of the account.

await friends()#

Fetch the list of the users friends.

Return type:: Sequence[User]

staticmethod from_id2(value, /)#

Create an ID from a user’s id2.

Parameters:: value (str) – The ID2 e.g. STEAM_1:0:1234.

Note

The universe will be set to Universe.Public if it’s 0. See ID.id2_zero.

Return type:: IndividualID | None

staticmethod from_id3(value, /)#

Create an ID from an SteamID’s id3.

Parameters:: value (str) – The ID3 e.g. [U:1:1234].
Return type:: ID | None

staticmethod from_invite_code(value, /)#

Create an ID from a user’s invite_code.

Parameters:: value (str) – The invite code e.g. cv-dgb
Return type:: ID[Literal[Type.Individual]] | None

staticmethod await from_url(url, /, session=None)#

Fetches the ID associated with a Steam Community URL or None.

Note

Each call makes an HTTP request to https://steamcommunity.com.

Examples

The following are valid calls:

>>> await ID.from_url("https://steamcommunity.com/groups/Valve")
>>> await ID.from_url("https://steamcommunity.com/gid/103582791429521412")
>>> await ID.from_url("https://steamcommunity.com/gid/[g:1:4]")
ID(id=4, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

>>> await ID.from_url("https://steamcommunity.com/id/johnc")
>>> await ID.from_url("https://steamcommunity.com/profiles/76561197960265740")
>>> await ID.from_url("https://steamcommunity.com/profiles/[U:1:12]")
>>> await ID.from_url("https://steamcommunity.com/user/r")
ID(id=12, type=Type.Individual, universe=Universe.Public, instance=Instance.Desktop)

>>> await ID.from_url("https://steamcommunity.com/app/570")
ID(id=3703047, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

Parameters:

url (StrOrURL) – The Steam Community URL.
session (ClientSession | None) – The session to make the request with. If None, one is generated.

Return type:

ID[Literal[Type.Individual, Type.Clan]] | None

game_server_ip: IPv4Address | None#: The IP address of the game server the user is currently playing on.

game_server_port: int | None#: The port of the game server the user is currently playing on.

async for ... in history(*, limit=100, before=None, after=None)#

An asynchronous iterator for accessing a channel’s steam.Messages.

Examples

Usage:

async for message in channel.history(limit=10):
    print("Author:", message.author, "Said:", message.content)

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of messages to search through. Setting this to None will fetch all of the channel’s messages, but this will be a very slow operation.
before (datetime | None) – A time to search for messages before.
after (datetime | None) – A time to search for messages after.

Yields:

property id: ID32#: The Steam ID’s 32-bit ID.

property id2: str#

The Steam ID’s ID 2.

e.g STEAM_1:0:1234.

property id2_zero: str#: The Steam ID’s ID 2 accounted for bugged GoldSrc and Orange Box games.

Note

In these games the accounts universe, 1 for Type.Public, should be the X component of STEAM_X:0:1234 however, this was bugged and the value of X was 0.

e.g STEAM_0:0:1234.

property id3: str#

The Steam ID’s ID 3.

e.g [U:1:1234].

id64: Final#: The Steam ID’s 64-bit ID.

property instance: Instance#: The instance of the ID.

async for ... in inventories()#

Fetches all the inventories a user has.

Return type:: AsyncGenerator[Inventory[Item[Self], Self], None]

await inventory(app, /, *, context_id=None, language=None)#

Fetch a user’s Inventory for trading.

Parameters:

app (App) – The app to fetch the inventory for.
context_id (int | None) – The context ID for the inventory normally 2.
language (Language | None) – The language to fetch the inventory in. If None will default to the current language.

Raises:

Forbidden – The user’s inventory is private.

Return type:

Inventory[Item[Self], Self]

await inventory_info()#

Fetch the inventory info of the user.

Source for UserInventoryInfo:

@dataclass(slots=True)
class UserInventoryInfo(Generic[UserT]):
    user: UserT
    app: UserInventoryInfoApp
    total_count: int
    trade_permissions: str
    load_failed: bool
    store_vetted: bool
    owner_only: bool
    contexts: list[UserInventoryInfoContext]

    async def inventories(self) -> AsyncGenerator[Inventory[Item[UserT], UserT], None]:
        """An :term:`asynchronous iterator` for accessing a user's full inventory in an app."""
        for context in self.contexts:
            yield await self.user.inventory(App(id=self.app.id), context_id=context.id)

Return type:: list[UserInventoryInfo[Self]]

property invite_code: str | None#

The Steam ID’s invite code in the s.team invite code format.

e.g. cv-dgb.

await invite_to(app)#

Return type:: AppInvite

property invite_url: str | None#

The Steam ID’s full invite code URL.

e.g https://s.team/p/cv-dgb.

await is_banned()#

Specifies if the user is banned from any part of Steam.

Shorthand for:

bans = await user.bans()
bans.is_banned()

Return type:: bool

is_friend()#

Whether the user is in the ClientUser’s friends.

Return type:: bool

is_valid()#

Whether this Steam ID is valid.

A Steam ID is currently considered valid if:

Return type:: bool

last_logoff: datetime | None#: The last time the user logged off steam. Could be None (e.g. if they are currently online).

last_logon: datetime | None#: The last time the user logged into steam.

last_seen_online: datetime | None#: The last time the user was seen online.

await level()#

Fetches the user’s level.

Return type:: int

property mention: str#: The string used to mention the user in chat.

name: str#: The user’s username.

await profile(*, language=None)#

Fetch a user’s entire profile information.

Parameters:: language (Language | None) – The language to fetch the profile items in. If None the current language is used

Note

This calls all the profile related functions to return a Profile object which has all the info set.

Return type:: Profile[Self]

await profile_customisation_info()#

Fetch a user’s profile customisation information.

Return type:: ProfileCustomisation[Self]

async for ... in published_files(*, app=None, revision=PublishedFileRevision.Default, type=PublishedFileType.Community, language=None, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a user’s PublishedFiles.

Examples

Usage:

async for file in user.published_files(limit=10):
    print("Author:", file.author, "Published:", file.name)

All parameters are optional.

Parameters:

app (App | None) – The app to fetch published files in.
type (PublishedFileType) – The type of published file to fetch.
revision (PublishedFileRevision) – The desired revision of the published file to fetch.
language (Language | None) – The language to fetch the published file in. If None, the current language is used.
limit (int | None) – The maximum number of published files to search through. Setting this to None will fetch all of the user’s published files.
before (datetime | None) – A time to search for published files before.
after (datetime | None) – A time to search for published files after.

Yields:

await recently_played()#

Fetches the apps the user has recently played.

Return type:: list[UserRecentlyPlayedApp]

await remove()#

Remove the user from your friends list.

async for ... in reviews(*, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a user’s Reviews.

Examples

Usage:

async for review in user.reviews(limit=10):
    recommended = "recommended" if review.recommend else "doesn't recommend"
    print(f"Author: {review.author} {recommended} {review.app}")

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of reviews to search through. Setting this to None will fetch all the user’s reviews.
before (datetime | None) – A time to search for reviews before.
after (datetime | None) – A time to search for reviews after.

Yields:

rich_presence: dict[str, str] | None#: The user’s rich presence.

await send(content=..., /, *, trade=None, media=None)#

Send a message, trade or image to an User.

Parameters:

content (Any) – The message to send to the user.
trade (TradeOffer[Asset[User], Asset[ClientUser], Any] | None) –
The trade offer to send to the user.

Note

This will have its id attribute updated after being sent.
media (Media | None) – The media to send to the user.

Raises:

HTTPException – Sending the message failed.
Forbidden – You do not have permission to send the message.

Returns:

The sent message only applicable if content is passed.

Return type:

await server()#

Fetch the game server this user is currently playing on.

Return type:: GameServer

state: PersonaState#: The current persona state of the account (e.g. LookingToTrade).

property trade_url: URL#: The trade url of the user.

await trigger_typing()#

Send a typing indicator to the channel once.

Note

This only works in DMs.

property type: TypeT#: The Steam type of the ID.

async with typing()#

Send a typing indicator continuously to the channel while in the context manager.

Note

This only works in DMs.

Usage:

async with channel.typing():
    ...  # do your expensive operations

Return type:: AsyncGenerator[None, None]

await unblock()#

Unblocks the user.

property universe: Universe#: The Steam universe of the ID.

await wishlist()#

Get the WishlistApps the user has on their wishlist.

Return type:: list[WishlistApp]

class steam.LeaderboardScoreUpdate#

Represents a score update on a leaderboard.

global_rank_before: int#: The global rank of the user before the score update.

global_rank_after: int#: The global rank of the user after the score update.

score_changed: bool#: Whether the score changed.

Manifests#

class steam.Manifest#

Represents a manifest which is a collection of files included with a depot build on Steam’s CDN.

x == y: Checks if two manifests are equal.

len(x): Returns the number of files this manifest holds.

bytes(x): Returns the manifest’s binary data.

Note#

This will be the uncompressed data.

name: str | None#: The name of the manifest.

app#: The app that this manifest was fetched from.

server#: The content server that this manifest was fetched from.

property paths: Sequence[ManifestPath]#: The depot’s files.

property root: ManifestPath#: The depot’s root directory.

property id: ManifestID#: The ID of this manifest. This is randomly generated by Steam.

property depot_id: DepotID#: The ID of this manifest’s depot.

created_at#: The time at which the depot was created at.

property size_original: int#: The size of the original depot file.

property size_compressed: int#: The size of the compressed depot file.

property compressed: bool#: Whether the depot is compressed.

class steam.ManifestPath#

A pathlib.PurePath subclass representing a binary file in a Manifest. This class is broadly compatible with pathlib.Path.

x == y: Checks if two paths are equal.

hash(x): Hashes this path.

x < y: Checks if one path’s parts is less than the other.

property parents: tuple[Self, ...]#: A tuple of this path’s logical parents.

property size: int#: This path’s size in bytes.

property chunks: Sequence[PayloadFileMappingChunkData]#: A read-only version of this path’s chunks instances.

flags#: This path’s flags.

property sha_content: bytes#: This path’s SHA1 content hash.

property sha_filename: bytes#: This path’s SHA1 filename hash.

is_dir()#

Whether the path is a directory.

Return type:: bool

is_symlink()#

Whether this path is a symlink.

Return type:: bool

is_file()#

Whether this path is a file or symlink.

Return type:: bool

is_executable()#

Whether this file is executable.

Return type:: bool

is_hidden()#

Whether this file is hidden.

Return type:: bool

readlink()#

If this path is a symlink where it points to. Similar to pathlib.Path.readlink()

Raises:: OSError – This path isn’t a symlink.
Return type:: Self

resolve(*, strict: bool = False) → Self#

Return the canonical path of the symbolic link, eliminating any symbolic links encountered in the path. Similar to pathlib.Path.resolve()

Parameters:

strict – Whether to raise an error if a path doesn’t exist.

Raises:

FileNotFoundError – If strict is True and the path doesn’t exist.
RuntimeError – If a recursive path is detected.

Return type:

Self

exists(*, follow_symlinks=True)#

Return whether this path exists. Similar to pathlib.Path.exists().

Return type:: bool

for ... in iterdir()#

Iterate over this path. Similar to pathlib.Path.iterdir().

Return type:: Generator[Self, None, None]

for ... in walk(*, top_down=True, follow_symlinks=False)#

Walk this path. Similar to pathlib.Path.walk().

Parameters:

top_down (bool) – Whether to walk top down or bottom up.
follow_symlinks (bool) – Whether to follow symlinks.

Note

Unlike pathlib.Path.walk(), this method does not have a on_error parameter as it should never error.

Yields:: The path currently being traversed, directories and files ((dirpath, dirnames, filenames)).

for ... in glob(pattern, /)#

Perform a glob operation on this path. Similar to pathlib.Path.glob().

Return type:: Generator[Self, None, None]

for ... in rglob(pattern, /)#

Perform a recursive glob operation on this path. Similar to pathlib.Path.rglob().

Return type:: Generator[Self, None, None]

async with open()#

Reads the contents of the file.

Raises:

IsADirectoryError – This path is a directory and cannot be opened.
RuntimeError – The depot cannot be decrypted as no key for its manifest was found.

Return type:

AsyncGenerator[ManifestPathIO, None]

await read_bytes(**kwargs)#

Read the contents of the file. Similar to pathlib.Path.read_bytes()

Return type:: bytes

await media(*, spoiler=False, **kwargs)#

Return this file as Media for uploading.

Return type:: Media

await save(filename, **kwargs)#

Save the file to a path.

Parameters:: filename (StrOrBytesPath) – The filename of the file to be created and have this saved to.
Returns:: The number of bytes written.
Return type:: int

await read_text(encoding=..., errors=...)#

Read the contents of the file. Similar to pathlib.Path.read_text()

Return type:: str

await read_vdf(encoding=..., errors=...)#

Read the contents of the file into a VDFDict.

Return type:: VDFDict

property anchor#: The concatenation of the drive and root, or ‘’.

as_posix()#: Return the string representation of the path with forward (/) slashes.

as_uri()#: Return the path as a ‘file’ URI.

property drive#: The drive prefix (letter or UNC path), if any.

is_absolute()#: True if the path is absolute (has both a root and, if applicable, a drive).

is_relative_to(*other)#: Return True if the path is relative to another path or False.

is_reserved()#: Return True if the path contains one of the special names reserved by the system, if any.

joinpath(*args)#: Combine this path with one or several arguments, and return a new path representing either a subpath (if all arguments are relative paths) or a totally different path (if one of the arguments is anchored).

match(path_pattern)#: Return True if this path matches the given pattern.

property name#: The final path component, if any.

property parent#: The logical parent of the path.

property parts#: An object providing sequence-like access to the components in the filesystem path.

relative_to(*other)#: Return the relative path to another path identified by the passed arguments. If the operation is not possible (because this is not a subpath of the other path), raise ValueError.

property root#: The root of the path, if any.

property stem#: The final path component, minus its last suffix.

property suffix#

The final component’s last suffix, if any.

This includes the leading period. For example: ‘.txt’

property suffixes#

A list of the final component’s suffixes, if any.

These include the leading periods. For example: [‘.tar’, ‘.gz’]

with_name(name)#: Return a new path with the file name changed.

with_stem(stem)#: Return a new path with the stem changed.

with_suffix(suffix)#: Return a new path with the file suffix changed. If the path has no suffix, add given suffix. If the given suffix is an empty string, remove the suffix from the path.

class steam.Branch#

Represents a branch on for a Steam app. Branches are specific builds of an application that have made available publicly or privately through Steam.

See also

Return type:: AppStats

await store_item(*, language=None)#

Fetch the store item for this app.

Shorthand for:

(item,) = await client.fetch_store_item(apps=[app], language=language)

Return type:: AppStoreItem

property url: str#

//steamcommunity.com.

Type:: The app’s URL on https

supported_languages#: This app’s supported languages.

language_support#: This app’s language support.

categories#: This app’s supported categories.

tags#: This app’s supported tags.

genres#: This app’s supported genres.

created_at#: The time this app was created.

review_score#: This app’s review score.

review_percentage#: This app’s review percentage.

metacritic_name#: This app’s metacritic name.

metacritic_score#: This app’s metacritic score.

metacritic_url#: This app’s metacritic URL.

partial_dlc#: This app’s downloadable content.

icon#: This app’s icon.

logo#: This app’s logo.

website_url#: This app’s website URL.

parent#: This app’s parent.

headless_depots: Sequence[HeadlessDepot]#: This app’s headless depots.

get_branch(name)#

Get a branch by its name.

Return type:: Branch | None

property branches: Sequence[Branch]#: The branches for this app.

property public_branch: Branch#

The public branch. Shorthand for:

app.get_branch("public")

await depots()#

Fetch the depots for this app.

Return type:: Sequence[Depot | HeadlessDepot]

is_on_windows()#

Whether the app is playable on Windows.

Return type:: bool

is_on_mac_os()#

Whether the app is playable on macOS.

Return type:: bool

is_on_linux()#

Whether the app is playable on Linux.

Return type:: bool

has_visible_stats()#

Whether the app has publicly visible stats.

Return type:: bool

is_free()#

Whether the app is free to download.

Return type:: bool

class steam.PackageInfo#

Represents a collection of information on a package.

sha: str#: The product info’s SHA.

size: int#: The product info’s size.

change_number: int#: The product info’s change number.

await apps_info()#

Fetch the product info for all apps in this package.

Shorthand for:

infos = await client.fetch_product_info(apps=await package.apps())

Return type:: list[AppInfo]

await depots()#

Fetches this package’s depots.

Return type:: list[Depot | HeadlessDepot]

await fetch(*, language=None)#

Fetches this package’s information.

Shorthand for:

package = await client.fetch_package(package, language=language)

Return type:: FetchedPackage

await fetch_manifest(*, id, depot_id, branch='public', password_hash='')#

Fetch a manifest from one of the apps() manifests.

Parameters:

id (int) – The ID of the manifest to fetch.
depot_id (int) – The ID of the depot the manifest is from.
branch (str) – The name of the branch the manifest is from.
password_hash (str) – The hashed password for the manifest.

Return type:

id#: The package’s ID.

await info()#

Fetches this package’s product info.

Shorthand for:

(info,) = await client.fetch_product_info(packages=[package])

Return type:: PackageInfo

async for ... in manifests(limit=100, before=None, after=None, branch='public', passwords={}, password_hashes={})#

An asynchronous iterator for accessing this package’s steam.Manifests.

Examples

Usage:

async for manifest in package.manifests(limit=10):
    print("Manifest:", manifest.name)
    print(f"Contains {len(manifest.paths)} manifests")

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of Manifests to return.
before (datetime | None) – The time to get manifests before.
after (datetime | None) – The time to get manifests after.
branch (str) – The name of the branch to fetch manifests from.
passwords (Mapping[AppT, str | None]) – A mapping of the password for a branch by its app, if any.
password_hashes (Mapping[AppT, str]) – A mapping of the hashed password for a branch by its app, if any.

Yields:

name#: The package’s name.

await redeem()#

Redeem this package if it’s a free-on-demand package.

Return type:: License

await store_item(*, language=None)#

Fetches this package’s store item.

Shorthand for:

(item,) = await client.fetch_store_item(packages=[package], language=language)

Return type:: PackageStoreItem

property url: str#: The package’s store page URL.

billing_type#: The billing type for the package.

license_type#: The license type for the package.

status#: The status for the package.

depot_ids#: The depot IDs in of the depots in the package.

app_items#: The app items in the package.

await apps(*, language: Language) → list[PartialApp[str]]#

await apps(*, language: None = None) → list[PartialApp[None]]

Fetches this package’s apps.

Return type:: list[PartialApp[None]] | list[PartialApp[str]]

Message#

class steam.Message#

Represents a message from a User. This is a base class from which all messages inherit.

The following classes implement this:

x == y: Checks if two messages are equal

hash(x): Returns the hash of a message.

author: UserT#: The message’s author.

created_at: datetime#: The time this message was sent at.

channel#: The channel the message was sent in.

group#: The group the message was sent in. None if the message wasn’t sent in a Group.

clan#: The clan the message was sent in. None if the message wasn’t sent in a Clan.

content#: The message’s content.

Note

This is not what you will see in the steam client see clean_content for that.

ordinal: int#: A per-channel incremented integer up to 1000 for every message sent in a second window.

clean_content: str#: The message’s clean content without BBCode.

reactions: list[MessageReaction]#: The message’s reactions.

partial_reactions: list[PartialMessageReaction]#: The message’s partial reactions.

property id: int#: A unique identifier for every message sent in a channel.

Note

This is not something Steam provides, this is meant to be a simple way to compare messages.

await add_emoticon(emoticon, /)#

Adds an emoticon to this message.

Parameters:: emoticon (Emoticon) – The emoticon to add to this message.

await remove_emoticon(emoticon, /)#

Removes an emoticon from this message.

Parameters:: emoticon (Emoticon) – The emoticon to remove from this message.

await add_sticker(sticker, /)#

Adds a sticker to this message.

Parameters:: sticker (Sticker) – The sticker to add to this message.

await remove_sticker(sticker, /)#

Adds a sticker to this message.

Parameters:: sticker (Sticker) – The sticker to remove from this message.

abstractmethod await ack()#

Acknowledge this message.

Note

This will acknowledge any messages sent before this message

class steam.UserMessage#

Represents a message from a user.

created_at: datetime#: The time this message was sent at.

author: UserT#: The message’s author.

await ack()#

Acknowledge this message.

Note

This will acknowledge any messages sent before this message

await add_emoticon(emoticon, /)#

Adds an emoticon to this message.

Parameters:: emoticon (Emoticon) – The emoticon to add to this message.

await add_sticker(sticker, /)#

Adds a sticker to this message.

Parameters:: sticker (Sticker) – The sticker to add to this message.

channel#: The channel the message was sent in.

clan#: The clan the message was sent in. None if the message wasn’t sent in a Clan.

clean_content: str#: The message’s clean content without BBCode.

content#: The message’s content.

Note

This is not what you will see in the steam client see clean_content for that.

group#: The group the message was sent in. None if the message wasn’t sent in a Group.

property id: int#: A unique identifier for every message sent in a channel.

Note

This is not something Steam provides, this is meant to be a simple way to compare messages.

ordinal: int#: A per-channel incremented integer up to 1000 for every message sent in a second window.

partial_reactions: list[PartialMessageReaction]#: The message’s partial reactions.

reactions: list[MessageReaction]#: The message’s reactions.

await remove_emoticon(emoticon, /)#

Removes an emoticon from this message.

Parameters:: emoticon (Emoticon) – The emoticon to remove from this message.

await remove_sticker(sticker, /)#

Adds a sticker to this message.

Parameters:: sticker (Sticker) – The sticker to remove from this message.

class steam.GroupMessage#

Represents a message in a group.

group: Group#: The group the message was sent in. None if the message wasn’t sent in a Group.

clan: None#: The clan the message was sent in. None if the message wasn’t sent in a Clan.

await ack()#

Acknowledge this message.

Note

This will acknowledge any messages sent before this message

await add_emoticon(emoticon, /)#

Adds an emoticon to this message.

Parameters:: emoticon (Emoticon) – The emoticon to add to this message.

await add_sticker(sticker, /)#

Adds a sticker to this message.

Parameters:: sticker (Sticker) – The sticker to add to this message.

author: AuthorT#: The message’s author.

channel: ChatT#: The channel the message was sent in.

clean_content: str#: The message’s clean content without BBCode.

content#: The message’s content.

Note

This is not what you will see in the steam client see clean_content for that.

created_at: datetime#: The time this message was sent at.

await delete()#

Deletes the message.

await fetch_reaction(emoticon, /)#

Fetches the reactions to this message with a given emoticon.

Return type:: list[MessageReaction]

await fetch_reactions()#

Fetches all this message’s reactions.

Warning

This does nothing for messages that aren’t fetched by GroupChannel.history()/ClanChannel.history().

Return type:: list[MessageReaction]

property id: int#: A unique identifier for every message sent in a channel.

Note

This is not something Steam provides, this is meant to be a simple way to compare messages.

property mentions: list[MemberT | PartialMember]#: The members mentioned in the message.

ordinal: int#: A per-channel incremented integer up to 1000 for every message sent in a second window.

partial_reactions: list[PartialMessageReaction]#: The message’s partial reactions.

reactions: list[MessageReaction]#: The message’s reactions.

await remove_emoticon(emoticon, /)#

Removes an emoticon from this message.

Parameters:: emoticon (Emoticon) – The emoticon to remove from this message.

await remove_sticker(sticker, /)#

Adds a sticker to this message.

Parameters:: sticker (Sticker) – The sticker to remove from this message.

class steam.ClanMessage#

Represents a message in a clan.

clan: Clan#: The clan the message was sent in. None if the message wasn’t sent in a Clan.

group: None#: The group the message was sent in. None if the message wasn’t sent in a Group.

await ack()#

Acknowledge this message.

Note

This will acknowledge any messages sent before this message

await add_emoticon(emoticon, /)#

Adds an emoticon to this message.

Parameters:: emoticon (Emoticon) – The emoticon to add to this message.

await add_sticker(sticker, /)#

Adds a sticker to this message.

Parameters:: sticker (Sticker) – The sticker to add to this message.

author: AuthorT#: The message’s author.

channel: ChatT#: The channel the message was sent in.

clean_content: str#: The message’s clean content without BBCode.

content#: The message’s content.

Note

This is not what you will see in the steam client see clean_content for that.

created_at: datetime#: The time this message was sent at.

await delete()#

Deletes the message.

await fetch_reaction(emoticon, /)#

Fetches the reactions to this message with a given emoticon.

Return type:: list[MessageReaction]

await fetch_reactions()#

Fetches all this message’s reactions.

Warning

This does nothing for messages that aren’t fetched by GroupChannel.history()/ClanChannel.history().

Return type:: list[MessageReaction]

property id: int#: A unique identifier for every message sent in a channel.

Note

This is not something Steam provides, this is meant to be a simple way to compare messages.

property mentions: list[MemberT | PartialMember]#: The members mentioned in the message.

ordinal: int#: A per-channel incremented integer up to 1000 for every message sent in a second window.

partial_reactions: list[PartialMessageReaction]#: The message’s partial reactions.

reactions: list[MessageReaction]#: The message’s reactions.

await remove_emoticon(emoticon, /)#

Removes an emoticon from this message.

Parameters:: emoticon (Emoticon) – The emoticon to remove from this message.

await remove_sticker(sticker, /)#

Adds a sticker to this message.

Parameters:: sticker (Sticker) – The sticker to remove from this message.

Package#

class steam.Package#

Represents a package, a collection of one or more apps and depots.

Post#

class steam.Post#

Represents a post on Steam Community.

id: ReadOnly[PostID]#: The ID of this post.

content: str#: The content of this post.

author: UserT#: The author of this post.

app: PartialApp | None#: The app this post is for, if any.

await delete()#

Delete this post.

await upvote()#

Upvote this post.

await award(award, /)#

Add an Award to this piece of user generated content.

Parameters:: award (Award) – The award to add.

await comment(content, /, *, subscribe=True)#

Post a comment to a comments section.

Parameters:

content (str) – The message to add to the comment section.
subscribe (bool) – Whether to subscribe to notifications on any future activity in this comment’s thread.

Returns:

The created comment.

Return type:

Comment[Self, ClientUser]

async for ... in comments(*, oldest_first=False, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a comment section’s Comment objects.

Examples

Usage:

async for comment in commentable.comments(limit=10):
    print("Author:", comment.author, "Said:", comment.content)

All parameters are optional.

Parameters:

oldest_first (bool) – Whether or not to request comments with the oldest comments first or last. Defaults to False.
limit (int | None) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (datetime | None) – A time to search for comments before.
after (datetime | None) – A time to search for comments after.

Yields:

await downvote()#

Un-upvote this post (this is different from other downvoting systems).

await fetch_comment(id, /)#

Fetch a comment by its ID.

Parameters:: id (int) – The ID of the comment to fetch.
Return type:: Comment[Self]

property created_at: datetime#: The time this post was created.

property url: str#: The URL of this post.

PriceOverview#

class steam.PriceOverview#

Represents the data received from the Steam Community Market.

lowest_price: float | str#: The lowest price observed by the market.

median_price: float | str#: The median price observed by the market.

volume: int#: The number of items sold in the last 24 hours.

Profile#

class steam.ProfileInfo#

Represents the user’s profile info.

created_at: datetime#: The time at which the user was created at.

real_name: str | None#: The real name of the user.

city_name: str | None#: The city the user is located in.

state_name: str | None#: The name of the state the user is located in.

country_name: str | None#: The name of the country the user is located in.

headline: str | None#: The profile’s headline.

summary: utils.BBCodeStr#: The user’s summary.

class steam.ProfileItem#

Represents an item on/in a user’s profile.

id#: The item’s id.

url#: The item’s url.

name#: The item’s name.

title#: The item’s title.

description#: The item’s description.

app#: The app the item is from.

type#: The item’s type.

class_#: The item’s class.

movie#: The movie associated with the item.

equipped_flags#: The item’s equipped flags.

await equip()#

Equip the profile item.

await item(*, language=None)#

Resolve this to an actual item in the owner’s inventory.

Return type:: Item[UserT]

class steam.OwnedProfileItems#

Represents the ClientUser's owned items.

backgrounds: list[ProfileItem[UserT]]#: The backgrounds the client user owns.

mini_profile_backgrounds: list[ProfileItem[UserT]]#: The mini profile backgrounds the client user owns.

avatar_frames: list[ProfileItem[UserT]]#: The avatar frames the client user owns.

animated_avatars: list[ProfileItem[UserT]]#: The animated avatars the client user owns.

modifiers: list[ProfileItem[UserT]]#: The modifiers the client user owns.

class steam.EquippedProfileItems#

Represents the items the user has equipped.

background: ProfileItem[UserT] | None#: The equipped background.

mini_profile_background: ProfileItem[UserT] | None#: The equipped mini profile background for the user.

avatar_frame: ProfileItem[UserT] | None#: The equipped avatar frame for the user.

animated_avatar: ProfileItem[UserT] | None#: The equipped animated avatar for the user.

modifier: ProfileItem[UserT] | None#: The equipped modifier for the user.

class steam.ProfileShowcase#

Represents a user’s profile showcase.

owner: UserT#: The showcase’s owner.

type: ProfileItemType#: The showcase type.

large: bool#: Whether the showcase is large.

active: bool#: Whether the showcase is active.

purchase_id: int#: The purchase id.

level: int#: The level of the the showcase.

style: ProfileCustomisationStyle#: The style of the showcase.

slots: list[ProfileShowcaseSlot[UserT]]#: The slots in this showcase.

await items(*, language=None)#

Fetches the associated Items for the entire showcase.

Parameters:: language (Language | None) – The language to fetch the items in. If None, the current language is used.
Return type:: list[Item[UserT]]

await published_files(*, revision=PublishedFileRevision.Default, language=None)#

Fetches the associated PublishedFile for the entire showcase.

Parameters:

revision (PublishedFileRevision) – The revision of the file to fetch.
language (Language | None) – The language to fetch the file in. If None, the current language is used.

Return type:

list[PublishedFile[UserT]]

await badges()#

Fetches the associated Badges for the entire showcase.

Return type:: list[UserBadge[UserT]]

class steam.Profile#

Represents a user’s complete profile.

background: ProfileItem[UserT] | None#: The equipped background.

mini_profile_background: ProfileItem[UserT] | None#: The equipped mini profile background for the user.

avatar_frame: ProfileItem[UserT] | None#: The equipped avatar frame for the user.

animated_avatar: ProfileItem[UserT] | None#: The equipped animated avatar for the user.

modifier: ProfileItem[UserT] | None#: The equipped modifier for the user.

PublishedFile#

class steam.PublishedFile#

Represents a published file on SteamPipe.

id: ReadOnly[IDT]#: The file’s id.

name#: The file’s name.

author#: The file’s author.

app#: The file’s app.

created_with#: The file’s created_with.

created_at#: The time the file was created at.

updated_at#: The time the file was last updated at.

manifest_id#: The file’s manifest id.

revision#: The file’s revision.

available_revisions#: The file’s available_revisions.

change_number#: This revision’s change number.

type#: The file’s type.

views#: The file’s views.

youtube_id#: The file’s youtube_id.

description#: The file’s description.

visibility#: The file’s visibility.

flags#: The file’s flags.

accepted#: Whether the file has been accepted.

show_subscribe_all#: The file’s show_subscribe_all.

number_of_developer_comments#: The file’s number of comments from the developer.

number_of_public_comments#: The file’s number of public comments.

spoiler#: Whether the file is marked as a spoiler.

children#: The file’s children.

file#: The file’s main file.

preview#: The file’s preview.

previews#: All the file’s previews.

image#: The file’s image.

banned#: Whether the file is banned.

ban_reason#: The file’s ban_reason.

banner#: The file’s banner.

ban_text_check_result#: The file’s ban_text_check_result.

can_be_deleted#: The file’s can_be_deleted.

incompatible#: The file’s incompatible.

can_subscribe#: The file’s can_subscribe.

subscriptions#: The file’s subscriptions.

time_subscribed#: The file’s time_subscribed.

await award(award, /)#

Add an Award to this piece of user generated content.

Parameters:: award (Award) – The award to add.

await comment(content, /, *, subscribe=True)#

Post a comment to a comments section.

Parameters:

content (str) – The message to add to the comment section.
subscribe (bool) – Whether to subscribe to notifications on any future activity in this comment’s thread.

Returns:

The created comment.

Return type:

Comment[Self, ClientUser]

async for ... in comments(*, oldest_first=False, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a comment section’s Comment objects.

Examples

Usage:

async for comment in commentable.comments(limit=10):
    print("Author:", comment.author, "Said:", comment.content)

All parameters are optional.

Parameters:

oldest_first (bool) – Whether or not to request comments with the oldest comments first or last. Defaults to False.
limit (int | None) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (datetime | None) – A time to search for comments before.
after (datetime | None) – A time to search for comments after.

Yields:

await fetch_comment(id, /)#

Fetch a comment by its ID.

Parameters:: id (int) – The ID of the comment to fetch.
Return type:: Comment[Self]

favourited#: The current number of people that have favourited the file.

followers#: The current number of followers the file has.

lifetime_subscriptions#: The file’s lifetime subscriptions.

lifetime_favourited#: The total number of people that have favourited the file.

lifetime_followers#: The total number of followers the file has.

lifetime_playtime#: The file’s lifetime playtime.

lifetime_playtime_sessions#: The file’s lifetime playtime sessions.

shortcut_id#: The file’s shortcut ID.

shortcut_name#: The file’s shortcut name.

consumer_shortcut_id#: The file’s consumer’s shortcut ID.

tags#: The file’s tags.

kv_tags#: The file’s key-value tags

reports#: The number of reports the file has.

upvotes#: The number of upvotes the file has.

downvotes#: The number of downvotes the file has.

score#: The file’s score.

playtime_stats#: The file’s playtime stats.

for_sale_data#: The file’s sale data.

metadata#: Any metadata attached to the file.

language#: The language the file is in.

maybe_inappropriate_sex#: Whether the file may contain sexually inappropriate content.

maybe_inappropriate_violence#: Whether the file may contain violent content which may be inappropriate for some.

reactions#: The file’s reactions.

property url: str#: The file’s url.

await manifest()#

The manifest associated with this published file.

Return type:: Manifest

await fetch_children(*, revision=PublishedFileRevision.Default, language=None)#

Fetches this published file’s children.

Parameters:

revision (PublishedFileRevision) – The revision to fetch.
language (Language | None) – The language to fetch children in. If None, the current language is used.

Return type:

list[PublishedFile]

async for ... in parents(*, revision=PublishedFileRevision.Default, language=None)#

Fetches this published file’s parents.

Parameters:

revision (PublishedFileRevision) – The revision to fetch.
language (Language | None) – The language to fetch parents in. If None, the current language is used.

Return type:

AsyncGenerator[PublishedFile[Author], None]

await upvote()#

Upvotes this published file.

await downvote()#

Downvotes this published file.

await subscribe()#

Subscribes to this published file’s changes.

await unsubscribe()#

Unsubscribes from this published file’s changes.

await is_subscribed()#

Whether the client user is subscribed to this published file.

Return type:: bool

await add_child(child, /)#

Adds a child to this published file.

Parameters:: child (PublishedFile) – The child to add.

await remove_child(child, /)#

Removes a child from this published file.

Parameters:: child (PublishedFile) – The child to remove.

await history(*, language=None)#

Fetches this published file’s history.

Parameters:: language (Language | None) – The language to fetch history in. If None, the current language is used.
Return type:: list[PublishedFileChange]

await fetch_history_entry(at, *, language=None)#

Fetches the history entry at a given time.

Parameters:

at (datetime) – The time to fetch the history entry at.
language (Language | None) – The language to fetch history entries in. If None, the current language is used.

Return type:

PublishedFileChange

await friends_who_favourited()#

Fetches a list of the ClientUser’s friends who favourited this published file.

Note

Due to a Steam limitation, this will only return your friends with non-default avatars.

Return type:: list[Friend]

await edit(*, name=None, description=None, visibility=None, tags=None, filename=None, preview_filename=None)#

Edits this published file.

Parameters:

name (str | None) – The new name of the file.
description (str | None) – The new description of the file.
visibility (PublishedFileVisibility | None) – The new visibility of the file.
tags (Sequence[str] | None) – The new tags of the file.
filename (str | None) – The new filename of the file.
preview_filename (str | None) – The new preview filename of the file.

Store#

class steam.StoreItem#

is_free()#

Whether the store item is free to play.

Return type:: bool

is_early_access()#

Whether the store item is in early access.

Return type:: bool

is_on_windows()#

Whether the store item is playable on Windows.

Return type:: bool

is_on_mac_os()#

Whether the store item is playable on macOS.

Return type:: bool

is_on_linux()#

Whether the store item is playable on Linux.

Return type:: bool

class steam.AppStoreItem#

Represents an app fetched from the store.

await achievements(*, language=None)#

The achievements for this app.

Parameters:: language (Language | None) – The language to fetch the achievements in. If None, the current language will be used.
Return type:: list[AppAchievement]

await add_free_licenses()#

Request the free licenses for this app.

Raises:: ValueError – No licenses were granted.
Return type:: list[License]

await badges(*, language=None)#

Fetch this app’s badges.

Parameters:: language (Language | None) – The language to fetch the badges in. If None, the current language will be used.
Return type:: Sequence[AppBadge[Self]]

await clan()#

Fetch this app’s clan.

This can be useful to get an App’s updates.

clan = await app.clan()
async for update in clan.announcements():
    if update.type in (steam.EventType.MajorUpdate, steam.EventType.SmallUpdate):
        ...  # do something with the update

Raises:: ValueError – This app has no associated clan.
Return type:: Clan

await community_items(*, type=CommunityDefinitionItemType.NONE, language=None)#

Fetch the app’s community item definitions.

Parameters:

type (CommunityDefinitionItemType) – The type of community item definitions to fetch.
language (Language | None) – The language to fetch the community item definitions in. If None, the current language will be used.

Return type:

list[CommunityItem[Self]]

async with create_authentication_ticket()#

Create an authentication ticket for this app.

Examples

async with app.create_authentication_ticket() as ticket:
    ...  # send the ticket to a user or server
    # ticket will only be valid inside this block

Return type:: AsyncGenerator[AuthenticationTicket, None]

await create_leaderboard(name)#

Create a leaderboard with a given name.

Parameters:: name (str) – The name of the leaderboard to create.
Return type:: Leaderboard[Self, None]

await depots()#

Fetch the depots for this app.

Return type:: Sequence[Depot | HeadlessDepot]

await dlc(*, language=None)#

Fetch the app’s DLC.

Parameters:: language (Language | None) – The language to fetch the DLC in. If None, the current language will be used.
Return type:: list[DLC]

await encrypted_ticket(key, *, user_data=b'')#

Fetch an encrypted ticket for this app.

Parameters:

key (bytes) – The key to encrypt the ticket with.
user_data (bytes) – The user data to include in the ticket.

Return type:

await fetch(*, language=None)#

Fetch this app.

Shorthand for:

app = await client.fetch_app(app_id, language=language)

Return type:: FetchedApp

await fetch_leaderboard(name)#

Fetch a leaderboard by name.

Parameters:

name (str) –

The name of the leaderboard to fetch.

Note

This is not the name of the leaderboard shown in the app’s stat page, you can find the name of the leaderboard from leaderboards().

Return type:

Leaderboard[Self, None]

await fetch_manifest(*, id, depot_id, branch='public', password_hash='')#

Fetch a CDN manifest for an app.

Parameters:

id (int) – The ID of the manifest to fetch.
depot_id (int) – The ID of the manifest’s associated depot.
branch (str) – The name of the branch the manifest is from.
password_hash (str) – The hashed password for the manifest.

Return type:

await friend_thoughts()#

Fetch the client user’s friends who recommended and didn’t recommend this app in a review.

Source for FriendThoughts:

class FriendThoughts(NamedTuple):
    recommended: list[Friend]
    not_recommended: list[Friend]

Return type:: FriendThoughts

await friends_who_own()#

Fetch the users in your friend list who own this app.

Return type:: list[Friend]

id: AppID#: The app’s app ID.

await info()#

Fetches this app’s product info.

Shorthand for:

(info,) = await client.fetch_product_info(apps=[app])

Return type:: AppInfo

is_early_access()#

Whether the store item is in early access.

Return type:: bool

is_free()#

Whether the store item is free to play.

Return type:: bool

is_on_linux()#

Whether the store item is playable on Linux.

Return type:: bool

is_on_mac_os()#

Whether the store item is playable on macOS.

Return type:: bool

is_on_windows()#

Whether the store item is playable on Windows.

Return type:: bool

is_valid()#

Whether the app could be a Steam app.

Return type:: bool

await leaderboards(*, language=None)#

The leaderboards for this app.

Parameters:: language (Language | None) – The language to fetch the leaderboards in. If None, the current language will be used.
Return type:: list[Leaderboard[Self, str]]

await legacy_cd_key()#

Fetch the legacy CD key for this app.

Return type:: str

async for ... in manifests(*, limit=100, before=None, after=None, branch='public', password=None, password_hash='')#

An asynchronous iterator for accessing a this app’s steam.Manifests.

Examples

Usage:

async for manifest in app.manifests(limit=10):
    print("Manifest:", manifest.name)
    print(f"Contains {len(manifest.paths)} manifests")

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of Manifests to return.
before (datetime | None) – The time to get manifests before.
after (datetime | None) – The time to get manifests after.
branch (str) – The name of the branch to fetch manifests from.
password (str | None) – The password for the branch, if any.
password_hash (str) – The hashed password for a manifest.

Yields:

await market_filters()#

Fetch the market filters for this app.

Return type:: list[AppMarketFilter]

name#: The app’s name.

await ownership_ticket()#

Fetch an ownership ticket for this app.

Return type:: OwnershipTicket

await packages(*, language=None)#

Fetch the app’s packages.

Parameters:: language (Language | None) – The language to fetch the packages in. If None, the current language will be used.
Return type:: list[FetchedAppPackage]

await player_count()#

The apps current player count.

Return type:: int

async for ... in published_files(*, type=PublishedFileQueryFileType.Items, revision=PublishedFileRevision.Default, language=None, limit=100, before=None, after=None)#

An asynchronous iterator for accessing an app’s steam.PublishedFiles.

Examples

Usage:

async for published_file in app.published_files(limit=10):
    print("Published file:", published_file.name)
    print("Published at:", published_file.created_at)
    print("Published by:", published_file.author)

All parameters are optional.

Parameters:

type (PublishedFileQueryFileType) – The type of published files to fetch.
revision (PublishedFileRevision) – The desired revision of the published files to fetch.
language (Language | None) – The language to fetch the published files in. If None the current language is used.
limit (int | None) – The maximum number of published files to search through. Default is 100. Setting this to None will fetch all the app’s published files, but this will be a very slow operation.
before (datetime | None) – A time to search for published files before.
after (datetime | None) – A time to search for published files after.

Yields:

await review(content, *, recommend, public=True, commentable=True, received_compensation=False, language=None)#

Review an app.

Parameters:

content (str) – The content of the review.
recommend (bool) – Whether you recommended the app.
public (bool) – Whether the review should be public.
commentable (bool) – Whether the review should allow comments.
received_compensation (bool) – Whether you received compensation for this review.
language (Language | None) – The language the review is in.

Return type:

async for ... in reviews(*, limit=100, before=None, after=None)#

An asynchronous iterator for accessing a steam.App’s steam.Reviews.

Examples

Usage:

async for review in app.reviews(limit=10):
    print("Reviewer:", review.author)
    print("Said:", review.content)

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of reviews to search through. Default is 100. Setting this to None will fetch all the app’s reviews, but this will be a very slow operation.
before (datetime | None) – A time to search for reviews before.
after (datetime | None) – A time to search for reviews after.

Yields:

await reward_items(*, language=None)#

Fetch the app’s reward item definitions.

Parameters:: language (Language | None) – The language to fetch the reward item definitions in. If None, the current language will be used.
Return type:: list[RewardItem[Self]]

async for ... in search_market(query='', *, limit=100, search_description=True, sort_by='popular', reverse=True, filters=())#

Fetch the Steam Community Market listings for this app.

Parameters:

query (str) – The query to search for.
limit (int | None) – The maximum number of listings to search through. Default is 100. Setting this to None will fetch all the app’s listings, but this will be a very slow operation.
search_description (bool) – Whether to search in the description of the listing.
sort_by (market.SortBy) – The column to sort the listings by.
reverse (bool) – Whether to sort the listings in descending order. Default is True. If False the listings will be sorted in ascending order.
filters (Sequence[AppMarketFilter]) – The filters to apply to the search.

Return type:

AsyncGenerator[MarketSearchListing, None]

await shop_items(*, currency=None, language=None)#

Fetch the items that are purchasable inside of the app’s shop.

Parameters:

currency (Currency | None) – If passed only return the prices in this currency otherwise return the prices in all supported currencies.
language (Language | None) – The language to resolve the descriptions of the items to. If None uses the current language.

Return type:

await stats(*, language=None)#

The stats for this app.

Parameters:: language (Language | None) – The language to fetch the stats in. If None, the current language will be used.

See also

Return type:: AppStats

await store_item(*, language=None)#

Fetch the store item for this app.

Shorthand for:

(item,) = await client.fetch_store_item(apps=[app], language=language)

Return type:: AppStoreItem

property url: str#

//steamcommunity.com.

Type:: The app’s URL on https

class steam.PackageStoreItem#

Represents a package fetched from the store.

await apps(*, language=None)#

Fetches this package’s apps.

Return type:: list[PartialApp[str]]

await apps_info()#

Fetch the product info for all apps in this package.

Shorthand for:

infos = await client.fetch_product_info(apps=await package.apps())

Return type:: list[AppInfo]

await depots()#

Fetches this package’s depots.

Return type:: list[Depot | HeadlessDepot]

await fetch(*, language=None)#

Fetches this package’s information.

Shorthand for:

package = await client.fetch_package(package, language=language)

Return type:: FetchedPackage

await fetch_manifest(*, id, depot_id, branch='public', password_hash='')#

Fetch a manifest from one of the apps() manifests.

Parameters:

id (int) – The ID of the manifest to fetch.
depot_id (int) – The ID of the depot the manifest is from.
branch (str) – The name of the branch the manifest is from.
password_hash (str) – The hashed password for the manifest.

Return type:

id#: The package’s ID.

await info()#

Fetches this package’s product info.

Shorthand for:

(info,) = await client.fetch_product_info(packages=[package])

Return type:: PackageInfo

is_early_access()#

Whether the store item is in early access.

Return type:: bool

is_free()#

Whether the store item is free to play.

Return type:: bool

is_on_linux()#

Whether the store item is playable on Linux.

Return type:: bool

is_on_mac_os()#

Whether the store item is playable on macOS.

Return type:: bool

is_on_windows()#

Whether the store item is playable on Windows.

Return type:: bool

async for ... in manifests(limit=100, before=None, after=None, branch='public', passwords={}, password_hashes={})#

An asynchronous iterator for accessing this package’s steam.Manifests.

Examples

Usage:

async for manifest in package.manifests(limit=10):
    print("Manifest:", manifest.name)
    print(f"Contains {len(manifest.paths)} manifests")

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of Manifests to return.
before (datetime | None) – The time to get manifests before.
after (datetime | None) – The time to get manifests after.
branch (str) – The name of the branch to fetch manifests from.
passwords (Mapping[AppT, str | None]) – A mapping of the password for a branch by its app, if any.
password_hashes (Mapping[AppT, str]) – A mapping of the hashed password for a branch by its app, if any.

Yields:

name#: The package’s name.

await redeem()#

Redeem this package if it’s a free-on-demand package.

Return type:: License

await store_item(*, language=None)#

Fetches this package’s store item.

Shorthand for:

(item,) = await client.fetch_store_item(packages=[package], language=language)

Return type:: PackageStoreItem

property url: str#: The package’s store page URL.

class steam.BundleStoreItem#

Represents a bundle fetched from the store.

await apps()#

Fetch the bundle’s apps.

Return type:: list[PartialApp[None]]

await fetch(*, language=None)#

Fetch this bundle.

Shorthand for:

bundle = await client.fetch_bundle(bundle_id)

Return type:: FetchedBundle

id#: The bundle’s ID.

is_early_access()#

Whether the store item is in early access.

Return type:: bool

is_free()#

Whether the store item is free to play.

Return type:: bool

is_on_linux()#

Whether the store item is playable on Linux.

Return type:: bool

is_on_mac_os()#

Whether the store item is playable on macOS.

Return type:: bool

is_on_windows()#

Whether the store item is playable on Windows.

Return type:: bool

name#: The bundle’s name.

await packages()#

Fetch the bundle’s packages.

Return type:: list[PartialPackage[None]]

await redeem()#

Redeem this bundle if it’s a free-on-demand bundle.

await store_item(*, language=None)#

Fetch the store item for this bundle.

Shorthand for:

(item,) = await client.fetch_store_item(bundles=[bundle], language=language)

Return type:: BundleStoreItem

property url: str#: The bundle’s store page URL.

class steam.TransactionReceipt#

Represents a transaction receipt.

id#: The ID of the transaction.

items#: The items in the transaction.

package#: The package in the transaction.

purchase_status#: The status of the transaction.

created_at#: The time the transaction was created.

payment_method#: The payment method used for the transaction.

base_price#: The base price of the transaction.

total_discount#: The total discount of the transaction.

tax#: The tax of the transaction.

shipping#: The shipping cost of the transaction.

currency#: The currency code of the transaction.

language#: The country code of the transaction.

App Tickets#

class steam.EncryptedTicket#

Represents an encrypted ticket.

user_data#: The user’s given data for the ticket.

version#: The version of the ticket.

user#: The user who owns the ticket.

app#: The app the ticket is for.

external_ip#: The external IP address of the user.

internal_ip#: The internal IP address of the user.

flags#: The flags of the ticket.

created_at#: The time the ticket was created.

licenses#: The licenses the user owns.

dlc#: The DLC the user owns.

signature#: The signature of the ticket.

class steam.OwnershipTicket#

Represents an ownership ticket. This is used to verify ownership of an app.

is_signature_valid()#

Return type:: bool

property expires: datetime#: The time at which the ticket expires.

is_expired()#

Whether the ticket has expired.

Return type:: bool

is_valid()#

Return type:: bool

app#: The app the ticket is for.

created_at#: The time the ticket was created.

dlc#: The DLC the user owns.

external_ip#: The external IP address of the user.

flags#: The flags of the ticket.

internal_ip#: The internal IP address of the user.

licenses#: The licenses the user owns.

signature#: The signature of the ticket.

user#: The user who owns the ticket.

version#: The version of the ticket.

class steam.AuthenticationTicket#

Represents an authentication ticket. This is used to verify ownership of an app and to connect to the game server.

auth_ticket#: The authentication ticket for the app. The first 52 bytes of the ticket.

gc_token#: The Game Connect token for the app.

gc_token_created_at#: When the Game Connect token was created.

client_ip#: The IP address of the client.

client_connected_at#: The time the client has been connected to Steam

client_connection_count#: How many servers the client has connected to

await verify(*, publisher_api_key=None)#

Verify the ticket with the web API.

Parameters:: publisher_api_key (str | None) – The publisher API key to use for verification. If not provided, will use the standard (rate limited) API.
Return type:: AuthenticationTicketVerificationResult

await activate()#

Activate the ticket.

await deactivate()#

Deactivate the ticket. Ends our sessions with other users meaning we can’t get events from them anymore.

app#: The app the ticket is for.

created_at#: The time the ticket was created.

dlc#: The DLC the user owns.

property expires: datetime#: The time at which the ticket expires.

external_ip#: The external IP address of the user.

flags#: The flags of the ticket.

internal_ip#: The internal IP address of the user.

is_expired()#

Whether the ticket has expired.

Return type:: bool

is_signature_valid()#

Return type:: bool

is_valid()#

Return type:: bool

licenses#: The licenses the user owns.

signature#: The signature of the ticket.

user#: The user who owns the ticket.

version#: The version of the ticket.

class steam.AuthenticationTicketVerificationResult#

Represents the result of an authentication ticket verification.

bool(x): Checks if the result is Result.OK.

result: Result#: The result of the verification.

user: PartialUser#: The user who sent the ticket.

owner: PartialUser#: The user who owns the ticket.

vac_banned: bool#: Whether the user is VAC banned.

publisher_banned: bool#: Whether the user is publisher banned.

Trading#

class steam.Inventory#

Represents a User’s inventory.

len(x): Returns how many items are in the inventory.

iter(x): Iterates over the inventory’s items.

x[i]: Returns the item at the given index.

y in x: Determines if an item is in the inventory based off of its Asset.id.

owner#: The owner of the inventory.

app#: The app the inventory belongs to.

await update()#

Re-fetches the inventory and updates it inplace.

count(value) → integer -- return number of occurrences of value#

index(value[, start[, stop]]) → integer -- return first index of value.#

Raises ValueError if the value is not present.

Supporting start and stop arguments is optional, but recommended.

class steam.Item#

Represents an item in a User’s inventory.

name#: The market_name of the item.

type#: The type of the item.

tags#: The tags of the item.

colour#: The colour of the item.

icon#: The icon url of the item. Uses the large image url where possible.

display_name#: The displayed name of the item. This could be different to Item.name if the item is user re-nameable.

market_hash_name#: The market_hash_name of the item.

descriptions#: The descriptions of the item.

owner_descriptions#: The descriptions of the item which are visible only to the owner of the item.

fraud_warnings#: The fraud warnings for the item.

actions#: The actions for the item.

owner_actions#: The owner actions for the item.

market_actions#: The market actions for the item.

market_fee#: The market fee percentage for the item.

amount#: The amount of the same asset there are in the inventory.

property app: PartialApp[None]#: The app the item is from.

class_id: ClassID#: The classid of the item.

context_id#: The contextid of the item.

await gift_to(recipient, /, *, name=None, message, closing_note, signature)#

Gifts the asset to the recipient.

Parameters:

recipient (Friend) – The recipient to gift the asset to.
name (str | None) – The name to give the asset. If not provided, the recipient’s name will be used.
message (str) – The message to send with the gift.
closing_note (str) – The closing note to send with the gift.
signature (str) – The signature to send with the gift.

id#: The assetid of the item.

instance_id: InstanceID#: The instanceid of the item.

is_marketable()#

Whether the item is marketable.

Return type:: bool

is_tradable()#

Whether the item is tradable.

Return type:: bool

listings()#

Fetch the listings of this item on the Steam Community Market place.

Return type:: AsyncGenerator[Listing, None]

property market_fee_app: PartialApp[None]#: The app for which the Steam Community Market fee percentage is applied.

await name_id()#

Fetch the item_nameid of this item on the Steam Community Market place.

Return type:: int

owner#: The owner of the asset.

await price(*, currency=None)#

Fetch the price of this item on the Steam Community Market place.

Shorthand for:

await client.fetch_price(item.market_hash_name, item.app, currency)

Return type:: PriceOverview

await price_history(*, currency=None)#

Fetch the price history of this item on the Steam Community Market place.

Shorthand for:

await client.fetch_price_history(item.market_hash_name, item.app, currency)

Return type:: list[PriceHistory]

await sell()#

List this item for sale on the Steam Community Market.

e.g. https://steamcommunity.com/profiles/76561198248053954/inventory/#440_2_8526584188

Return type:: MyListing

property url: str#

The URL for the asset in the owner’s inventory.

class steam.Asset#

Base most version of an item. This class should only be received when Steam fails to find a matching item for its class and instance IDs.

x == y: Checks if two assets are equal.

hash(x): Returns the hash of an asset.

id#: The assetid of the item.

amount#: The amount of the same asset there are in the inventory.

context_id#: The contextid of the item.

owner#: The owner of the asset.

property url: str#

The URL for the asset in the owner’s inventory.

e.g. https://steamcommunity.com/profiles/76561198248053954/inventory/#440_2_8526584188

await gift_to(recipient, /, *, name=None, message, closing_note, signature)#

Gifts the asset to the recipient.

Parameters:

recipient (Friend) – The recipient to gift the asset to.
name (str | None) – The name to give the asset. If not provided, the recipient’s name will be used.
message (str) – The message to send with the gift.
closing_note (str) – The closing note to send with the gift.
signature (str) – The signature to send with the gift.

await sell(user_pays: int) → MyListing#

await sell(you_receive: int) → MyListing

List this item for sale on the Steam Community Market.

Return type:: MyListing

class steam.MovedItem#

Represents an item that has moved from one inventory to another.

new_id#: The new_assetid field, this is the asset ID of the item in the partners inventory.

new_context_id#: The new_contextid field.

Reactions#

class steam.Award#

Represents an award.

id#: The ID of the award.

name#: The english localised name of the award.

property url: str#: The reaction’s icon URL.

property animated_url: str#: The reaction’s icon animated URL.

await media(*, spoiler=False, **kwargs)#

Return this file as Media for uploading.

Return type:: Media

await read(**kwargs)#

Read the whole contents of this file.

Return type:: bytes

await save(filename, **kwargs)#

Save the file to a path.

Parameters:: filename (StrOrBytesPath) – The filename of the file to be created and have this saved to.
Returns:: The number of bytes written.
Return type:: int

class steam.AwardReaction#

Represents an award on user generated content.

award#: The award given to the user generated content.

count#: The reactions count on the post.

class steam.PartialMessageReaction#

Represents a partial reaction to a message.

message: Message#: The message the reaction applies to.

emoticon: Emoticon | None#: The emoticon that was reacted with.

sticker: Sticker | None#: The sticker that was reacted with.

class steam.MessageReaction#

Represents a reaction to a message.

user: Author#: The user that reacted to the message.

created_at: datetime | None#: The time the reaction was added to the message.

ordinal: int | None#: The ordinal of the the message.

emoticon: Emoticon | None#: The emoticon that was reacted with.

message: Message#: The message the reaction applies to.

sticker: Sticker | None#: The sticker that was reacted with.

class steam.Emoticon#

Represents an emoticon in chat.

x == y: Checks if two emoticons are equal.

str(x): The string to send this emoticon in chat.

hash(x): Returns the emoticon’s hash.

property url: str#: The URL for this emoticon.

await app()#

Fetches this emoticon’s associated app.

Return type:: PartialApp[str]

await media(*, spoiler=False, **kwargs)#

Return this file as Media for uploading.

Return type:: Media

name#: The name of this emoticon.

await read(**kwargs)#

Read the whole contents of this file.

Return type:: bytes

await save(filename, **kwargs)#

Save the file to a path.

Parameters:: filename (StrOrBytesPath) – The filename of the file to be created and have this saved to.
Returns:: The number of bytes written.
Return type:: int

class steam.Sticker#

Represents a sticker in chat.

x == y: Checks if two stickers are equal.

str(x): The way to send this sticker in chat.

hash(x): Returns the stickers’s hash.

Note

Unlike Emoticon this can only be sent in a message by itself.

property url: str#: The URL for this sticker.

await app()#

Fetches this sticker’s associated app.

Return type:: PartialApp[None]

await media(*, spoiler=False, **kwargs)#

Return this file as Media for uploading.

Return type:: Media

name#: The name of this emoticon.

await read(**kwargs)#

Read the whole contents of this file.

Return type:: bytes

await save(filename, **kwargs)#

Save the file to a path.

Parameters:: filename (StrOrBytesPath) – The filename of the file to be created and have this saved to.
Returns:: The number of bytes written.
Return type:: int

class steam.ClientEmoticon#

Represents an Emoticon the ClientUser owns.

await app()#

Fetches this emoticon’s associated app.

Return type:: PartialApp[str]

count#: The number of times this emoticon can be used.

last_used#: The last time this emoticon was used.

await media(*, spoiler=False, **kwargs)#

Return this file as Media for uploading.

Return type:: Media

name#: The name of this emoticon.

await read(**kwargs)#

Read the whole contents of this file.

Return type:: bytes

received_at#: The time this emoticon was received.

await save(filename, **kwargs)#

Save the file to a path.

Parameters:: filename (StrOrBytesPath) – The filename of the file to be created and have this saved to.
Returns:: The number of bytes written.
Return type:: int

property url: str#: The URL for this emoticon.

use_count#: The number of times this emoticon has been used.

class steam.ClientSticker#

Represents a Sticker the ClientUser owns.

count#: The number of times this emoticon can be used.

last_used#: The last time this emoticon was used.

await media(*, spoiler=False, **kwargs)#

Return this file as Media for uploading.

Return type:: Media

name#: The name of this emoticon.

await read(**kwargs)#

Read the whole contents of this file.

Return type:: bytes

received_at#: The time this emoticon was received.

await save(filename, **kwargs)#

Save the file to a path.

Parameters:: filename (StrOrBytesPath) – The filename of the file to be created and have this saved to.
Returns:: The number of bytes written.
Return type:: int

property url: str#: The URL for this sticker.

use_count#: The number of times this emoticon has been used.

await app()#

Fetches this sticker’s associated app.

Return type:: PartialApp[None]

class steam.ClientEffect#

await media(*, spoiler=False, **kwargs)#

Return this file as Media for uploading.

Return type:: Media

name#: The name of this emoticon.

await read(**kwargs)#

Read the whole contents of this file.

Return type:: bytes

await save(filename, **kwargs)#

Save the file to a path.

Parameters:: filename (StrOrBytesPath) – The filename of the file to be created and have this saved to.
Returns:: The number of bytes written.
Return type:: int

count#: The number of times this emoticon can be used.

received_at#: The time this emoticon was received.

await app()#

Fetches this effect’s associated app.

Return type:: PartialApp[None]

class steam.ClientEffect#

await media(*, spoiler=False, **kwargs)#

Return this file as Media for uploading.

Return type:: Media

name#: The name of this emoticon.

await read(**kwargs)#

Read the whole contents of this file.

Return type:: bytes

await save(filename, **kwargs)#

Save the file to a path.

Parameters:: filename (StrOrBytesPath) – The filename of the file to be created and have this saved to.
Returns:: The number of bytes written.
Return type:: int

count#: The number of times this emoticon can be used.

received_at#: The time this emoticon was received.

await app()#

Fetches this effect’s associated app.

Return type:: PartialApp[None]

Reviews#

class steam.Review#

Represents a review for an app.

id: ReadOnly[int]#: The ID of the review.

author: ReviewUser#: The author of the review.

app: ReviewApp#: The app being reviewed.

recommended: bool#: Whether the reviewer recommends the app.

language: Language#: The language the review is written in.

content: str#: The contents of the review.

created_at: datetime#: The time the review was created at.

updated_at: datetime#: The time the review was last updated at.

votes_helpful: int#: The amount of people that marked the review as helpful.

votes_funny: int#: The amount of people that marked this review as funny.

weighted_vote_score: float#: The weighted score from Steam.

commentable: bool | None#: Whether the author has allowed comments on the review.

comment_count: int#: The amount of comments this review has.

steam_purchase: bool | None#: Whether the app was purchased through Steam.

await award(award, /)#

Add an Award to this piece of user generated content.

Parameters:: award (Award) – The award to add.

await comment(content, /, *, subscribe=True)#

Post a comment to a comments section.

Parameters:

content (str) – The message to add to the comment section.
subscribe (bool) – Whether to subscribe to notifications on any future activity in this comment’s thread.

Returns:

The created comment.

Return type:

Comment[Self, ClientUser]

async for ... in comments(*, oldest_first=False, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a comment section’s Comment objects.

Examples

Usage:

async for comment in commentable.comments(limit=10):
    print("Author:", comment.author, "Said:", comment.content)

All parameters are optional.

Parameters:

oldest_first (bool) – Whether or not to request comments with the oldest comments first or last. Defaults to False.
limit (int | None) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (datetime | None) – A time to search for comments before.
after (datetime | None) – A time to search for comments after.

Yields:

await fetch_comment(id, /)#

Fetch a comment by its ID.

Parameters:: id (int) – The ID of the comment to fetch.
Return type:: Comment[Self]

received_compensation: bool#: Whether the reviewer received compensation for this review.

written_during_early_access: bool#: Whether the reviewer played the app the app during early access.

developer_response: str | None#: The developer’s response to the review.

developer_responded_at: datetime | None#: The time the developer responded to the review.

reactions: list[AwardReaction] | None#: The review’s reactions.

await mark_helpful()#

Mark this review as helpful.

await mark_not_helpful()#

Mark this review as not helpful.

await mark_funny()#

Mark this review as funny.

await edit(content, /, *, public=True, commentable=None, language=None, written_during_early_access=None, received_compensation=None)#

Edit this review.

Parameters:

content (str) – The content of the review.
public (bool) – Whether the review should be shown publicly on your profile.
commentable (bool | None) – Whether the review should be commentable.
language (Language | None) – The language of the review. Defaults to the current value.
written_during_early_access (bool | None) – Whether the review was written during early access. Defaults to the current value.
received_compensation (bool | None) – Whether the user received compensation for this review. Defaults to the current value.

await delete()#

Delete this review.

class steam.ReviewUser#

number_of_apps_owned: int | None#

number_of_reviews: int | None#

playtime_forever: timedelta#

playtime_last_two_weeks: timedelta#

playtime_at_review: timedelta#

last_played: datetime#

await achievements(app, /, *, language=None)#

Fetch the achievements for the user in the app.

Parameters:: language (Language | None) – The language to fetch the stats in. If None will default to the current language.
Return type:: list[UserAppAchievement]

await add()#

Sends a friend invite to the user to your friends list.

app: PartialApp[str] | None#: The app the user is currently in. Is None if the user isn’t in an app.

await app_stats(app, /, *, language=None)#

Fetch the stats for the user in the app.

Parameters:: language (Language | None) – The language to fetch the stats in. If None will default to the current language.
Return type:: UserAppStats

await apps(*, include_free=True)#

Fetches the Apps the user owns.

Parameters:: include_free (bool) – Whether to include free apps in the list. Defaults to True.
Return type:: list[UserApp]

property avatar: Avatar#: The user’s avatar.

await badges()#

Fetches the user’s UserBadgess.

Return type:: UserBadges[Self]

await bans()#

Fetches the user’s Bans.

Return type:: Ban

await block()#

Blocks the user.

await cancel_invite()#

Cancels an invitation sent to the user. This effectively does the same thing as remove().

await clans(*, auto_chunk=False)#

Fetches a list of Clans the user is in.

Parameters:: auto_chunk (bool) – Whether to automatically chunk the clans that are fetched. Defaults to False.
Return type:: list[Clan]

await comment(content, /, *, subscribe=True)#

Post a comment to a comments section.

Parameters:

content (str) – The message to add to the comment section.
subscribe (bool) – Whether to subscribe to notifications on any future activity in this comment’s thread.

Returns:

The created comment.

Return type:

Comment[Self, ClientUser]

async for ... in comments(*, oldest_first=False, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a comment section’s Comment objects.

Examples

Usage:

async for comment in commentable.comments(limit=10):
    print("Author:", comment.author, "Said:", comment.content)

All parameters are optional.

Parameters:

oldest_first (bool) – Whether or not to request comments with the oldest comments first or last. Defaults to False.
limit (int | None) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (datetime | None) – A time to search for comments before.
after (datetime | None) – A time to search for comments after.

Yields:

property community_url: str | None#

The Steam ID’s community url if it is a Type.Individual or Type.Clan.

e.g https://steamcommunity.com/profiles/123456789 or https://steamcommunity.com/gid/123456789.

await equipped_profile_items(*, language=None)#

The user’s equipped profile items.

Parameters:: language (Language | None) – The language to fetch the profile items in. If None the current language is used
Return type:: EquippedProfileItems[Self]

await escrow(token=None)#

Check how long any received items would take to arrive. None if the user has no escrow or has a private inventory.

Parameters:: token (str | None) – The user’s trade offer token, not required if you are friends with the user.
Return type:: timedelta | None

await favourite_badge()#

The user’s favourite badge.

Return type:: FavouriteBadge[PartialApp | Literal[STEAM]] | None

await fetch_comment(id, /)#

Fetch a comment by its ID.

Parameters:: id (int) – The ID of the comment to fetch.
Return type:: Comment[Self]

await fetch_message(id, /)#

Fetch a message by its Message.id.

Return type:: MessageT | None

await fetch_post(id, /)#

Fetch a post by its id.

Parameters:: id (int) – The id of the post to fetch.
Return type:: Post[Self]

await fetch_published_file(id, /, *, revision=PublishedFileRevision.Default, language=None)#

Fetch a published file by its id.

Parameters:

id (int) – The id of the published file to fetch.
revision (PublishedFileRevision) – The desired revision of the published file to fetch.
language (Language | None) – The language to fetch the published file in. If None, the current language is used.

Return type:

PublishedFile[Self] | None

await fetch_review(app)#

Fetch this user’s review for an app.

Parameters:: app (App) – The apps to fetch the reviews for.
Return type:: Review

await fetch_reviews(*apps)#

Fetch this user’s review for apps.

Parameters:: apps (App) – The apps to fetch the reviews for.
Return type:: list[Review]

flags: PersonaStateFlag#: The persona state flags of the account.

await friends()#

Fetch the list of the users friends.

Return type:: Sequence[User]

staticmethod from_id2(value, /)#

Create an ID from a user’s id2.

Parameters:: value (str) – The ID2 e.g. STEAM_1:0:1234.

Note

The universe will be set to Universe.Public if it’s 0. See ID.id2_zero.

Return type:: IndividualID | None

staticmethod from_id3(value, /)#

Create an ID from an SteamID’s id3.

Parameters:: value (str) – The ID3 e.g. [U:1:1234].
Return type:: ID | None

staticmethod from_invite_code(value, /)#

Create an ID from a user’s invite_code.

Parameters:: value (str) – The invite code e.g. cv-dgb
Return type:: ID[Literal[Type.Individual]] | None

staticmethod await from_url(url, /, session=None)#

Fetches the ID associated with a Steam Community URL or None.

Note

Each call makes an HTTP request to https://steamcommunity.com.

Examples

The following are valid calls:

>>> await ID.from_url("https://steamcommunity.com/groups/Valve")
>>> await ID.from_url("https://steamcommunity.com/gid/103582791429521412")
>>> await ID.from_url("https://steamcommunity.com/gid/[g:1:4]")
ID(id=4, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

>>> await ID.from_url("https://steamcommunity.com/id/johnc")
>>> await ID.from_url("https://steamcommunity.com/profiles/76561197960265740")
>>> await ID.from_url("https://steamcommunity.com/profiles/[U:1:12]")
>>> await ID.from_url("https://steamcommunity.com/user/r")
ID(id=12, type=Type.Individual, universe=Universe.Public, instance=Instance.Desktop)

>>> await ID.from_url("https://steamcommunity.com/app/570")
ID(id=3703047, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

Parameters:

url (StrOrURL) – The Steam Community URL.
session (ClientSession | None) – The session to make the request with. If None, one is generated.

Return type:

ID[Literal[Type.Individual, Type.Clan]] | None

game_server_ip: IPv4Address | None#: The IP address of the game server the user is currently playing on.

game_server_port: int | None#: The port of the game server the user is currently playing on.

async for ... in history(*, limit=100, before=None, after=None)#

An asynchronous iterator for accessing a channel’s steam.Messages.

Examples

Usage:

async for message in channel.history(limit=10):
    print("Author:", message.author, "Said:", message.content)

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of messages to search through. Setting this to None will fetch all of the channel’s messages, but this will be a very slow operation.
before (datetime | None) – A time to search for messages before.
after (datetime | None) – A time to search for messages after.

Yields:

property id: ID32#: The Steam ID’s 32-bit ID.

property id2: str#

The Steam ID’s ID 2.

e.g STEAM_1:0:1234.

property id2_zero: str#: The Steam ID’s ID 2 accounted for bugged GoldSrc and Orange Box games.

Note

In these games the accounts universe, 1 for Type.Public, should be the X component of STEAM_X:0:1234 however, this was bugged and the value of X was 0.

e.g STEAM_0:0:1234.

property id3: str#

The Steam ID’s ID 3.

e.g [U:1:1234].

id64: Final#: The Steam ID’s 64-bit ID.

property instance: Instance#: The instance of the ID.

async for ... in inventories()#

Fetches all the inventories a user has.

Return type:: AsyncGenerator[Inventory[Item[Self], Self], None]

await inventory(app, /, *, context_id=None, language=None)#

Fetch a user’s Inventory for trading.

Parameters:

app (App) – The app to fetch the inventory for.
context_id (int | None) – The context ID for the inventory normally 2.
language (Language | None) – The language to fetch the inventory in. If None will default to the current language.

Raises:

Forbidden – The user’s inventory is private.

Return type:

Inventory[Item[Self], Self]

await inventory_info()#

Fetch the inventory info of the user.

Source for UserInventoryInfo:

@dataclass(slots=True)
class UserInventoryInfo(Generic[UserT]):
    user: UserT
    app: UserInventoryInfoApp
    total_count: int
    trade_permissions: str
    load_failed: bool
    store_vetted: bool
    owner_only: bool
    contexts: list[UserInventoryInfoContext]

    async def inventories(self) -> AsyncGenerator[Inventory[Item[UserT], UserT], None]:
        """An :term:`asynchronous iterator` for accessing a user's full inventory in an app."""
        for context in self.contexts:
            yield await self.user.inventory(App(id=self.app.id), context_id=context.id)

Return type:: list[UserInventoryInfo[Self]]

property invite_code: str | None#

The Steam ID’s invite code in the s.team invite code format.

e.g. cv-dgb.

await invite_to(app)#

Return type:: AppInvite

property invite_url: str | None#

The Steam ID’s full invite code URL.

e.g https://s.team/p/cv-dgb.

await is_banned()#

Specifies if the user is banned from any part of Steam.

Shorthand for:

bans = await user.bans()
bans.is_banned()

Return type:: bool

is_friend()#

Whether the user is in the ClientUser’s friends.

Return type:: bool

is_valid()#

Whether this Steam ID is valid.

A Steam ID is currently considered valid if:

Return type:: bool

last_logoff: datetime | None#: The last time the user logged off steam. Could be None (e.g. if they are currently online).

last_logon: datetime | None#: The last time the user logged into steam.

last_seen_online: datetime | None#: The last time the user was seen online.

await level()#

Fetches the user’s level.

Return type:: int

property mention: str#: The string used to mention the user in chat.

name: str#: The user’s username.

await profile(*, language=None)#

Fetch a user’s entire profile information.

Parameters:: language (Language | None) – The language to fetch the profile items in. If None the current language is used

Note

This calls all the profile related functions to return a Profile object which has all the info set.

Return type:: Profile[Self]

await profile_customisation_info()#

Fetch a user’s profile customisation information.

Return type:: ProfileCustomisation[Self]

async for ... in published_files(*, app=None, revision=PublishedFileRevision.Default, type=PublishedFileType.Community, language=None, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a user’s PublishedFiles.

Examples

Usage:

async for file in user.published_files(limit=10):
    print("Author:", file.author, "Published:", file.name)

All parameters are optional.

Parameters:

app (App | None) – The app to fetch published files in.
type (PublishedFileType) – The type of published file to fetch.
revision (PublishedFileRevision) – The desired revision of the published file to fetch.
language (Language | None) – The language to fetch the published file in. If None, the current language is used.
limit (int | None) – The maximum number of published files to search through. Setting this to None will fetch all of the user’s published files.
before (datetime | None) – A time to search for published files before.
after (datetime | None) – A time to search for published files after.

Yields:

await recently_played()#

Fetches the apps the user has recently played.

Return type:: list[UserRecentlyPlayedApp]

await remove()#

Remove the user from your friends list.

async for ... in reviews(*, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a user’s Reviews.

Examples

Usage:

async for review in user.reviews(limit=10):
    recommended = "recommended" if review.recommend else "doesn't recommend"
    print(f"Author: {review.author} {recommended} {review.app}")

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of reviews to search through. Setting this to None will fetch all the user’s reviews.
before (datetime | None) – A time to search for reviews before.
after (datetime | None) – A time to search for reviews after.

Yields:

rich_presence: dict[str, str] | None#: The user’s rich presence.

await send(content=..., /, *, trade=None, media=None)#

Send a message, trade or image to an User.

Parameters:

content (Any) – The message to send to the user.
trade (TradeOffer[Asset[User], Asset[ClientUser], Any] | None) –
The trade offer to send to the user.

Note

This will have its id attribute updated after being sent.
media (Media | None) – The media to send to the user.

Raises:

HTTPException – Sending the message failed.
Forbidden – You do not have permission to send the message.

Returns:

The sent message only applicable if content is passed.

Return type:

await server()#

Fetch the game server this user is currently playing on.

Return type:: GameServer

state: PersonaState#: The current persona state of the account (e.g. LookingToTrade).

property trade_url: URL#: The trade url of the user.

await trigger_typing()#

Send a typing indicator to the channel once.

Note

This only works in DMs.

property type: TypeT#: The Steam type of the ID.

async with typing()#

Send a typing indicator continuously to the channel while in the context manager.

Note

This only works in DMs.

Usage:

async with channel.typing():
    ...  # do your expensive operations

Return type:: AsyncGenerator[None, None]

await unblock()#

Unblocks the user.

property universe: Universe#: The Steam universe of the ID.

await wishlist()#

Get the WishlistApps the user has on their wishlist.

Return type:: list[WishlistApp]

Roles#

class steam.Role#

Represents a role in a chat group.

id#: The ID of the role.

name#: The name of the role.

ordinal#: The ordinal of the role.

group: Group | None#: The group the role belongs to, if any.

clan: Clan | None#: The clan the role belongs to, if any.

permissions#: The permissions of the role.

property members: list[Member]#: The members that have this role.

await edit(*, name=None, permissions=None, ordinal=None)#

Edit this role.

Parameters:

name (str | None) – The new name of the role.
permissions (RolePermissions | None) – The new permissions of the role.
ordinal (int | None) – The new ordinal (position) of the role.

await delete()#

Delete this role.

class steam.RolePermissions#

Represents the permissions of a role in a chat group.

kick#: Whether the role can kick members.

ban_members#: Whether the role can ban members.

invite#: Whether the role can invite members.

manage_group#: Whether the role can manage the group.

send_messages#: Whether the role can send messages.

read_message_history#: Whether the role can read message history.

change_group_roles#: Whether the role can change group roles.

change_user_roles#: Whether the role can change user roles.

mention_all#: Whether the role can mention all.

set_watching_broadcast#: Whether the role can set watching broadcast.

replace(*, kick: bool = ..., ban_members: bool = ..., invite: bool = ..., manage_group: bool = ..., send_messages: bool = ..., read_message_history: bool = ..., change_group_roles: bool = ..., change_user_roles: bool = ..., mention_all: bool = ..., set_watching_broadcast: bool = ...) → Self#

Return a new RolePermissions with the specified changes.

Return type:: Self

User News#

class steam.UserNews(state, news, achievements)#

Represents a news entry on the activity feed.

type: Final#: The type of news entry.

created_at#: When the news entry was created.

actor#: The actor of the news entry.

app#: The app this news entry is for.

package#: The package this news entry is for.

apps#: If type is UserNewsType.ReceivedNewGame, the apps unlocked by package. If type is UserNewsType.AddedGameToWishlist, the apps wishlisted by actor.

achievements#: The achievements unlocked. Only used for UserNewsType.AchievementUnlocked.

shortcut_id#: The shortcut ID this news entry is for.

event_id#: The event ID this news entry is for. Only used for UserNewsType.ScheduledEvent.

announcement_id#: The announcement ID this news entry is for. Only used for UserNewsType.PostedAnnouncement.

published_file_id#: The published file ID this news entry is for.

post_id#: The post ID this news entry is for. Only used for UserNewsType.Post.

target#: The target of the news entry.

await event()#

Fetch the event this news entry is for.

Return type:: Event[EventType, PartialClan]

await announcement()#

Fetch the announcement this news entry is for.

Return type:: Announcement[PartialClan]

await published_file()#

Fetch the published file this news entry is for.

Return type:: PublishedFile

await review()#

Fetch the review this news entry is for.

Return type:: Review

await post()#

Fetch the post this news entry is for.

Return type:: Post

Users#

class steam.PartialUser#

property trade_url: URL#: The trade url of the user.

await inventory_info()#

Fetch the inventory info of the user.

Source for UserInventoryInfo:

@dataclass(slots=True)
class UserInventoryInfo(Generic[UserT]):
    user: UserT
    app: UserInventoryInfoApp
    total_count: int
    trade_permissions: str
    load_failed: bool
    store_vetted: bool
    owner_only: bool
    contexts: list[UserInventoryInfoContext]

    async def inventories(self) -> AsyncGenerator[Inventory[Item[UserT], UserT], None]:
        """An :term:`asynchronous iterator` for accessing a user's full inventory in an app."""
        for context in self.contexts:
            yield await self.user.inventory(App(id=self.app.id), context_id=context.id)

Return type:: list[UserInventoryInfo[Self]]

await inventory(app, /, *, context_id=None, language=None)#

Fetch a user’s Inventory for trading.

Parameters:

app (App) – The app to fetch the inventory for.
context_id (int | None) – The context ID for the inventory normally 2.
language (Language | None) – The language to fetch the inventory in. If None will default to the current language.

Raises:

Forbidden – The user’s inventory is private.

Return type:

Inventory[Item[Self], Self]

async for ... in inventories()#

Fetches all the inventories a user has.

Return type:: AsyncGenerator[Inventory[Item[Self], Self], None]

await friends()#

Fetch the list of the users friends.

Return type:: Sequence[User]

await apps(*, include_free=True)#

Fetches the Apps the user owns.

Parameters:: include_free (bool) – Whether to include free apps in the list. Defaults to True.
Return type:: list[UserApp]

await recently_played()#

Fetches the apps the user has recently played.

Return type:: list[UserRecentlyPlayedApp]

await app_stats(app, /, *, language=None)#

Fetch the stats for the user in the app.

Parameters:: language (Language | None) – The language to fetch the stats in. If None will default to the current language.
Return type:: UserAppStats

await achievements(app, /, *, language=None)#

Fetch the achievements for the user in the app.

Parameters:: language (Language | None) – The language to fetch the stats in. If None will default to the current language.
Return type:: list[UserAppAchievement]

await wishlist()#

Get the WishlistApps the user has on their wishlist.

Return type:: list[WishlistApp]

await clans(*, auto_chunk=False)#

Fetches a list of Clans the user is in.

Parameters:: auto_chunk (bool) – Whether to automatically chunk the clans that are fetched. Defaults to False.
Return type:: list[Clan]

await bans()#

Fetches the user’s Bans.

Return type:: Ban

await is_banned()#

Specifies if the user is banned from any part of Steam.

Shorthand for:

bans = await user.bans()
bans.is_banned()

Return type:: bool

await level()#

Fetches the user’s level.

Return type:: int

await badges()#

Fetches the user’s UserBadgess.

Return type:: UserBadges[Self]

await favourite_badge()#

The user’s favourite badge.

Return type:: FavouriteBadge[PartialApp | Literal[STEAM]] | None

await equipped_profile_items(*, language=None)#

The user’s equipped profile items.

Parameters:: language (Language | None) – The language to fetch the profile items in. If None the current language is used
Return type:: EquippedProfileItems[Self]

await profile_customisation_info()#

Fetch a user’s profile customisation information.

Return type:: ProfileCustomisation[Self]

await profile(*, language=None)#

Fetch a user’s entire profile information.

Parameters:: language (Language | None) – The language to fetch the profile items in. If None the current language is used

Note

This calls all the profile related functions to return a Profile object which has all the info set.

Return type:: Profile[Self]

async for ... in reviews(*, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a user’s Reviews.

Examples

Usage:

async for review in user.reviews(limit=10):
    recommended = "recommended" if review.recommend else "doesn't recommend"
    print(f"Author: {review.author} {recommended} {review.app}")

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of reviews to search through. Setting this to None will fetch all the user’s reviews.
before (datetime | None) – A time to search for reviews before.
after (datetime | None) – A time to search for reviews after.

Yields:

await fetch_review(app)#

Fetch this user’s review for an app.

Parameters:: app (App) – The apps to fetch the reviews for.
Return type:: Review

await fetch_reviews(*apps)#

Fetch this user’s review for apps.

Parameters:: apps (App) – The apps to fetch the reviews for.
Return type:: list[Review]

await fetch_published_file(id, /, *, revision=PublishedFileRevision.Default, language=None)#

Fetch a published file by its id.

Parameters:

id (int) – The id of the published file to fetch.
revision (PublishedFileRevision) – The desired revision of the published file to fetch.
language (Language | None) – The language to fetch the published file in. If None, the current language is used.

Return type:

PublishedFile[Self] | None

async for ... in published_files(*, app=None, revision=PublishedFileRevision.Default, type=PublishedFileType.Community, language=None, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a user’s PublishedFiles.

Examples

Usage:

async for file in user.published_files(limit=10):
    print("Author:", file.author, "Published:", file.name)

All parameters are optional.

Parameters:

app (App | None) – The app to fetch published files in.
type (PublishedFileType) – The type of published file to fetch.
revision (PublishedFileRevision) – The desired revision of the published file to fetch.
language (Language | None) – The language to fetch the published file in. If None, the current language is used.
limit (int | None) – The maximum number of published files to search through. Setting this to None will fetch all of the user’s published files.
before (datetime | None) – A time to search for published files before.
after (datetime | None) – A time to search for published files after.

Yields:

await fetch_post(id, /)#

Fetch a post by its id.

Parameters:: id (int) – The id of the post to fetch.
Return type:: Post[Self]

await invite_to(app)#

Return type:: AppInvite

is_friend()#

Whether the user is in the ClientUser’s friends.

Return type:: bool

id64: Final#: The Steam ID’s 64-bit ID.

await comment(content, /, *, subscribe=True)#

Post a comment to a comments section.

Parameters:

content (str) – The message to add to the comment section.
subscribe (bool) – Whether to subscribe to notifications on any future activity in this comment’s thread.

Returns:

The created comment.

Return type:

Comment[Self, ClientUser]

async for ... in comments(*, oldest_first=False, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a comment section’s Comment objects.

Examples

Usage:

async for comment in commentable.comments(limit=10):
    print("Author:", comment.author, "Said:", comment.content)

All parameters are optional.

Parameters:

oldest_first (bool) – Whether or not to request comments with the oldest comments first or last. Defaults to False.
limit (int | None) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (datetime | None) – A time to search for comments before.
after (datetime | None) – A time to search for comments after.

Yields:

property community_url: str | None#

The Steam ID’s community url if it is a Type.Individual or Type.Clan.

e.g https://steamcommunity.com/profiles/123456789 or https://steamcommunity.com/gid/123456789.

await fetch_comment(id, /)#

Fetch a comment by its ID.

Parameters:: id (int) – The ID of the comment to fetch.
Return type:: Comment[Self]

staticmethod from_id2(value, /)#

Create an ID from a user’s id2.

Parameters:: value (str) – The ID2 e.g. STEAM_1:0:1234.

Note

The universe will be set to Universe.Public if it’s 0. See ID.id2_zero.

Return type:: IndividualID | None

staticmethod from_id3(value, /)#

Create an ID from an SteamID’s id3.

Parameters:: value (str) – The ID3 e.g. [U:1:1234].
Return type:: ID | None

staticmethod from_invite_code(value, /)#

Create an ID from a user’s invite_code.

Parameters:: value (str) – The invite code e.g. cv-dgb
Return type:: ID[Literal[Type.Individual]] | None

staticmethod await from_url(url, /, session=None)#

Fetches the ID associated with a Steam Community URL or None.

Note

Each call makes an HTTP request to https://steamcommunity.com.

Examples

The following are valid calls:

>>> await ID.from_url("https://steamcommunity.com/groups/Valve")
>>> await ID.from_url("https://steamcommunity.com/gid/103582791429521412")
>>> await ID.from_url("https://steamcommunity.com/gid/[g:1:4]")
ID(id=4, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

>>> await ID.from_url("https://steamcommunity.com/id/johnc")
>>> await ID.from_url("https://steamcommunity.com/profiles/76561197960265740")
>>> await ID.from_url("https://steamcommunity.com/profiles/[U:1:12]")
>>> await ID.from_url("https://steamcommunity.com/user/r")
ID(id=12, type=Type.Individual, universe=Universe.Public, instance=Instance.Desktop)

>>> await ID.from_url("https://steamcommunity.com/app/570")
ID(id=3703047, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

Parameters:

url (StrOrURL) – The Steam Community URL.
session (ClientSession | None) – The session to make the request with. If None, one is generated.

Return type:

ID[Literal[Type.Individual, Type.Clan]] | None

property id: ID32#: The Steam ID’s 32-bit ID.

property id2: str#

The Steam ID’s ID 2.

e.g STEAM_1:0:1234.

property id2_zero: str#: The Steam ID’s ID 2 accounted for bugged GoldSrc and Orange Box games.

Note

In these games the accounts universe, 1 for Type.Public, should be the X component of STEAM_X:0:1234 however, this was bugged and the value of X was 0.

e.g STEAM_0:0:1234.

property id3: str#

The Steam ID’s ID 3.

e.g [U:1:1234].

property instance: Instance#: The instance of the ID.

property invite_code: str | None#

The Steam ID’s invite code in the s.team invite code format.

e.g. cv-dgb.

property invite_url: str | None#

The Steam ID’s full invite code URL.

e.g https://s.team/p/cv-dgb.

is_valid()#

Whether this Steam ID is valid.

A Steam ID is currently considered valid if:

Return type:: bool

property type: TypeT#: The Steam type of the ID.

property universe: Universe#: The Steam universe of the ID.

class steam.ClientUser#

Represents your account.

x == y: Checks if two users are equal.

str(x): Returns the user’s name.

await friends()#

A list of the user’s friends.

Return type:: Sequence[Friend]

get_friend(id, /)#

Get a friend from the client user’s friends list.

Parameters:: id (int) – The ID64 of the friend to get.
Return type:: Friend | None

await inventory(app, /, *, context_id=None, language=None)#

Fetch a user’s Inventory for trading.

Parameters:

app (App) – The app to fetch the inventory for.
context_id (int | None) – The context ID for the inventory normally 2.
language (Language | None) – The language to fetch the inventory in. If None will default to the current language.

Raises:

Forbidden – The user’s inventory is private.

Return type:

Inventory[Item[Self], Self]

await setup_profile()#

Set up your profile if possible.

await clear_nicks()#

Clears the client user’s nickname/alias history.

await profile_items(*, language=None)#

Fetch all the client user’s profile items.

Parameters:: language (Language | None) – The language to fetch the profile items in. If None the current language is used
Return type:: OwnedProfileItems[Self]

await profile(*, language=None)#

Fetch a user’s entire profile information.

Parameters:: language (Language | None) – The language to fetch the profile items in. If None the current language is used

Note

This calls all the profile related functions to return a Profile object which has all the info set.

Return type:: ClientUserProfile

await profile_info()#

The friend’s profile info.

Return type:: ProfileInfo

await edit(*, name=None, real_name=None, url=None, summary=None, country=None, state=None, city=None, avatar=None)#

Edit the client user’s profile. Any values that aren’t set will use their defaults.

Parameters:

name (str | None) – The new name you wish to go by.
real_name (str | None) – The real name you wish to go by.
url (str | None) – The custom url ending/path you wish to use.
summary (str | None) – The summary/description you wish to use.
country (str | None) – The country you want to be from.
state (str | None) – The state you want to be from.
city (str | None) – The city you want to be from.
avatar (Media | None) –
The avatar you wish to use.

Note

This needs to be at least 184px x 184px.

Raises:

HTTPException – Editing your profile failed.

await achievements(app, /, *, language=None)#

Fetch the achievements for the user in the app.

Parameters:: language (Language | None) – The language to fetch the stats in. If None will default to the current language.
Return type:: list[UserAppAchievement]

app: PartialApp[str] | None#: The app the user is currently in. Is None if the user isn’t in an app.

await app_stats(app, /, *, language=None)#

Fetch the stats for the user in the app.

Parameters:: language (Language | None) – The language to fetch the stats in. If None will default to the current language.
Return type:: UserAppStats

await apps(*, include_free=True)#

Fetches the Apps the user owns.

Parameters:: include_free (bool) – Whether to include free apps in the list. Defaults to True.
Return type:: list[UserApp]

property avatar: Avatar#: The user’s avatar.

await badges()#

Fetches the user’s UserBadgess.

Return type:: UserBadges[Self]

await bans()#

Fetches the user’s Bans.

Return type:: Ban

await clans(*, auto_chunk=False)#

Fetches a list of Clans the user is in.

Parameters:: auto_chunk (bool) – Whether to automatically chunk the clans that are fetched. Defaults to False.
Return type:: list[Clan]

await comment(content, /, *, subscribe=True)#

Post a comment to a comments section.

Parameters:

content (str) – The message to add to the comment section.
subscribe (bool) – Whether to subscribe to notifications on any future activity in this comment’s thread.

Returns:

The created comment.

Return type:

Comment[Self, ClientUser]

async for ... in comments(*, oldest_first=False, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a comment section’s Comment objects.

Examples

Usage:

async for comment in commentable.comments(limit=10):
    print("Author:", comment.author, "Said:", comment.content)

All parameters are optional.

Parameters:

oldest_first (bool) – Whether or not to request comments with the oldest comments first or last. Defaults to False.
limit (int | None) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (datetime | None) – A time to search for comments before.
after (datetime | None) – A time to search for comments after.

Yields:

property community_url: str | None#

The Steam ID’s community url if it is a Type.Individual or Type.Clan.

e.g https://steamcommunity.com/profiles/123456789 or https://steamcommunity.com/gid/123456789.

await equipped_profile_items(*, language=None)#

The user’s equipped profile items.

Parameters:: language (Language | None) – The language to fetch the profile items in. If None the current language is used
Return type:: EquippedProfileItems[Self]

await favourite_badge()#

The user’s favourite badge.

Return type:: FavouriteBadge[PartialApp | Literal[STEAM]] | None

await fetch_comment(id, /)#

Fetch a comment by its ID.

Parameters:: id (int) – The ID of the comment to fetch.
Return type:: Comment[Self]

await fetch_post(id, /)#

Fetch a post by its id.

Parameters:: id (int) – The id of the post to fetch.
Return type:: Post[Self]

await fetch_published_file(id, /, *, revision=PublishedFileRevision.Default, language=None)#

Fetch a published file by its id.

Parameters:

id (int) – The id of the published file to fetch.
revision (PublishedFileRevision) – The desired revision of the published file to fetch.
language (Language | None) – The language to fetch the published file in. If None, the current language is used.

Return type:

PublishedFile[Self] | None

await fetch_review(app)#

Fetch this user’s review for an app.

Parameters:: app (App) – The apps to fetch the reviews for.
Return type:: Review

await fetch_reviews(*apps)#

Fetch this user’s review for apps.

Parameters:: apps (App) – The apps to fetch the reviews for.
Return type:: list[Review]

flags: PersonaStateFlag#: The persona state flags of the account.

staticmethod from_id2(value, /)#

Create an ID from a user’s id2.

Parameters:: value (str) – The ID2 e.g. STEAM_1:0:1234.

Note

The universe will be set to Universe.Public if it’s 0. See ID.id2_zero.

Return type:: IndividualID | None

staticmethod from_id3(value, /)#

Create an ID from an SteamID’s id3.

Parameters:: value (str) – The ID3 e.g. [U:1:1234].
Return type:: ID | None

staticmethod from_invite_code(value, /)#

Create an ID from a user’s invite_code.

Parameters:: value (str) – The invite code e.g. cv-dgb
Return type:: ID[Literal[Type.Individual]] | None

staticmethod await from_url(url, /, session=None)#

Fetches the ID associated with a Steam Community URL or None.

Note

Each call makes an HTTP request to https://steamcommunity.com.

Examples

The following are valid calls:

>>> await ID.from_url("https://steamcommunity.com/groups/Valve")
>>> await ID.from_url("https://steamcommunity.com/gid/103582791429521412")
>>> await ID.from_url("https://steamcommunity.com/gid/[g:1:4]")
ID(id=4, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

>>> await ID.from_url("https://steamcommunity.com/id/johnc")
>>> await ID.from_url("https://steamcommunity.com/profiles/76561197960265740")
>>> await ID.from_url("https://steamcommunity.com/profiles/[U:1:12]")
>>> await ID.from_url("https://steamcommunity.com/user/r")
ID(id=12, type=Type.Individual, universe=Universe.Public, instance=Instance.Desktop)

>>> await ID.from_url("https://steamcommunity.com/app/570")
ID(id=3703047, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

Parameters:

url (StrOrURL) – The Steam Community URL.
session (ClientSession | None) – The session to make the request with. If None, one is generated.

Return type:

ID[Literal[Type.Individual, Type.Clan]] | None

game_server_ip: IPv4Address | None#: The IP address of the game server the user is currently playing on.

game_server_port: int | None#: The port of the game server the user is currently playing on.

property id: ID32#: The Steam ID’s 32-bit ID.

property id2: str#

The Steam ID’s ID 2.

e.g STEAM_1:0:1234.

property id2_zero: str#: The Steam ID’s ID 2 accounted for bugged GoldSrc and Orange Box games.

Note

In these games the accounts universe, 1 for Type.Public, should be the X component of STEAM_X:0:1234 however, this was bugged and the value of X was 0.

e.g STEAM_0:0:1234.

property id3: str#

The Steam ID’s ID 3.

e.g [U:1:1234].

id64: Final#: The Steam ID’s 64-bit ID.

property instance: Instance#: The instance of the ID.

async for ... in inventories()#

Fetches all the inventories a user has.

Return type:: AsyncGenerator[Inventory[Item[Self], Self], None]

await inventory_info()#

Fetch the inventory info of the user.

Source for UserInventoryInfo:

@dataclass(slots=True)
class UserInventoryInfo(Generic[UserT]):
    user: UserT
    app: UserInventoryInfoApp
    total_count: int
    trade_permissions: str
    load_failed: bool
    store_vetted: bool
    owner_only: bool
    contexts: list[UserInventoryInfoContext]

    async def inventories(self) -> AsyncGenerator[Inventory[Item[UserT], UserT], None]:
        """An :term:`asynchronous iterator` for accessing a user's full inventory in an app."""
        for context in self.contexts:
            yield await self.user.inventory(App(id=self.app.id), context_id=context.id)

Return type:: list[UserInventoryInfo[Self]]

property invite_code: str | None#

The Steam ID’s invite code in the s.team invite code format.

e.g. cv-dgb.

await invite_to(app)#

Return type:: AppInvite

property invite_url: str | None#

The Steam ID’s full invite code URL.

e.g https://s.team/p/cv-dgb.

await is_banned()#

Specifies if the user is banned from any part of Steam.

Shorthand for:

bans = await user.bans()
bans.is_banned()

Return type:: bool

is_friend()#

Whether the user is in the ClientUser’s friends.

Return type:: bool

is_valid()#

Whether this Steam ID is valid.

A Steam ID is currently considered valid if:

Return type:: bool

last_logoff: datetime | None#: The last time the user logged off steam. Could be None (e.g. if they are currently online).

last_logon: datetime | None#: The last time the user logged into steam.

last_seen_online: datetime | None#: The last time the user was seen online.

await level()#

Fetches the user’s level.

Return type:: int

property mention: str#: The string used to mention the user in chat.

name: str#: The user’s username.

await profile_customisation_info()#

Fetch a user’s profile customisation information.

Return type:: ProfileCustomisation[Self]

async for ... in published_files(*, app=None, revision=PublishedFileRevision.Default, type=PublishedFileType.Community, language=None, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a user’s PublishedFiles.

Examples

Usage:

async for file in user.published_files(limit=10):
    print("Author:", file.author, "Published:", file.name)

All parameters are optional.

Parameters:

app (App | None) – The app to fetch published files in.
type (PublishedFileType) – The type of published file to fetch.
revision (PublishedFileRevision) – The desired revision of the published file to fetch.
language (Language | None) – The language to fetch the published file in. If None, the current language is used.
limit (int | None) – The maximum number of published files to search through. Setting this to None will fetch all of the user’s published files.
before (datetime | None) – A time to search for published files before.
after (datetime | None) – A time to search for published files after.

Yields:

await recently_played()#

Fetches the apps the user has recently played.

Return type:: list[UserRecentlyPlayedApp]

async for ... in reviews(*, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a user’s Reviews.

Examples

Usage:

async for review in user.reviews(limit=10):
    recommended = "recommended" if review.recommend else "doesn't recommend"
    print(f"Author: {review.author} {recommended} {review.app}")

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of reviews to search through. Setting this to None will fetch all the user’s reviews.
before (datetime | None) – A time to search for reviews before.
after (datetime | None) – A time to search for reviews after.

Yields:

rich_presence: dict[str, str] | None#: The user’s rich presence.

await server()#

Fetch the game server this user is currently playing on.

Return type:: GameServer

state: PersonaState#: The current persona state of the account (e.g. LookingToTrade).

property trade_url: URL#: The trade url of the user.

property type: TypeT#: The Steam type of the ID.

property universe: Universe#: The Steam universe of the ID.

await wishlist()#

Get the WishlistApps the user has on their wishlist.

Return type:: list[WishlistApp]

class steam.User#

Represents a Steam user’s account.

x == y: Checks if two users are equal.

str(x): Returns the user’s name.

await add()#

Sends a friend invite to the user to your friends list.

await remove()#

Remove the user from your friends list.

await cancel_invite()#

Cancels an invitation sent to the user. This effectively does the same thing as remove().

await block()#

Blocks the user.

await unblock()#

Unblocks the user.

await escrow(token=None)#

Check how long any received items would take to arrive. None if the user has no escrow or has a private inventory.

Parameters:: token (str | None) – The user’s trade offer token, not required if you are friends with the user.
Return type:: timedelta | None

await send(content=..., /, *, trade=None, media=None)#

Send a message, trade or image to an User.

Parameters:

content (Any) – The message to send to the user.
trade (TradeOffer[Asset[User], Asset[ClientUser], Any] | None) –
The trade offer to send to the user.

Note

This will have its id attribute updated after being sent.
media (Media | None) – The media to send to the user.

Raises:

HTTPException – Sending the message failed.
Forbidden – You do not have permission to send the message.

Returns:

The sent message only applicable if content is passed.

Return type:

async for ... in history(*, limit=100, before=None, after=None)#

An asynchronous iterator for accessing a channel’s steam.Messages.

Examples

Usage:

async for message in channel.history(limit=10):
    print("Author:", message.author, "Said:", message.content)

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of messages to search through. Setting this to None will fetch all of the channel’s messages, but this will be a very slow operation.
before (datetime | None) – A time to search for messages before.
after (datetime | None) – A time to search for messages after.

Yields:

async with typing()#

Send a typing indicator continuously to the channel while in the context manager.

Note

This only works in DMs.

Usage:

async with channel.typing():
    ...  # do your expensive operations

Return type:: AsyncGenerator[None, None]

await trigger_typing()#

Send a typing indicator to the channel once.

Note

This only works in DMs.

await achievements(app, /, *, language=None)#

Fetch the achievements for the user in the app.

Parameters:: language (Language | None) – The language to fetch the stats in. If None will default to the current language.
Return type:: list[UserAppAchievement]

app: PartialApp[str] | None#: The app the user is currently in. Is None if the user isn’t in an app.

await app_stats(app, /, *, language=None)#

Fetch the stats for the user in the app.

Parameters:: language (Language | None) – The language to fetch the stats in. If None will default to the current language.
Return type:: UserAppStats

await apps(*, include_free=True)#

Fetches the Apps the user owns.

Parameters:: include_free (bool) – Whether to include free apps in the list. Defaults to True.
Return type:: list[UserApp]

property avatar: Avatar#: The user’s avatar.

await badges()#

Fetches the user’s UserBadgess.

Return type:: UserBadges[Self]

await bans()#

Fetches the user’s Bans.

Return type:: Ban

await clans(*, auto_chunk=False)#

Fetches a list of Clans the user is in.

Parameters:: auto_chunk (bool) – Whether to automatically chunk the clans that are fetched. Defaults to False.
Return type:: list[Clan]

await comment(content, /, *, subscribe=True)#

Post a comment to a comments section.

Parameters:

content (str) – The message to add to the comment section.
subscribe (bool) – Whether to subscribe to notifications on any future activity in this comment’s thread.

Returns:

The created comment.

Return type:

Comment[Self, ClientUser]

async for ... in comments(*, oldest_first=False, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a comment section’s Comment objects.

Examples

Usage:

async for comment in commentable.comments(limit=10):
    print("Author:", comment.author, "Said:", comment.content)

All parameters are optional.

Parameters:

oldest_first (bool) – Whether or not to request comments with the oldest comments first or last. Defaults to False.
limit (int | None) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (datetime | None) – A time to search for comments before.
after (datetime | None) – A time to search for comments after.

Yields:

property community_url: str | None#

The Steam ID’s community url if it is a Type.Individual or Type.Clan.

e.g https://steamcommunity.com/profiles/123456789 or https://steamcommunity.com/gid/123456789.

await equipped_profile_items(*, language=None)#

The user’s equipped profile items.

Parameters:: language (Language | None) – The language to fetch the profile items in. If None the current language is used
Return type:: EquippedProfileItems[Self]

await favourite_badge()#

The user’s favourite badge.

Return type:: FavouriteBadge[PartialApp | Literal[STEAM]] | None

await fetch_comment(id, /)#

Fetch a comment by its ID.

Parameters:: id (int) – The ID of the comment to fetch.
Return type:: Comment[Self]

await fetch_message(id, /)#

Fetch a message by its Message.id.

Return type:: MessageT | None

await fetch_post(id, /)#

Fetch a post by its id.

Parameters:: id (int) – The id of the post to fetch.
Return type:: Post[Self]

await fetch_published_file(id, /, *, revision=PublishedFileRevision.Default, language=None)#

Fetch a published file by its id.

Parameters:

id (int) – The id of the published file to fetch.
revision (PublishedFileRevision) – The desired revision of the published file to fetch.
language (Language | None) – The language to fetch the published file in. If None, the current language is used.

Return type:

PublishedFile[Self] | None

await fetch_review(app)#

Fetch this user’s review for an app.

Parameters:: app (App) – The apps to fetch the reviews for.
Return type:: Review

await fetch_reviews(*apps)#

Fetch this user’s review for apps.

Parameters:: apps (App) – The apps to fetch the reviews for.
Return type:: list[Review]

flags: PersonaStateFlag#: The persona state flags of the account.

await friends()#

Fetch the list of the users friends.

Return type:: Sequence[User]

staticmethod from_id2(value, /)#

Create an ID from a user’s id2.

Parameters:: value (str) – The ID2 e.g. STEAM_1:0:1234.

Note

The universe will be set to Universe.Public if it’s 0. See ID.id2_zero.

Return type:: IndividualID | None

staticmethod from_id3(value, /)#

Create an ID from an SteamID’s id3.

Parameters:: value (str) – The ID3 e.g. [U:1:1234].
Return type:: ID | None

staticmethod from_invite_code(value, /)#

Create an ID from a user’s invite_code.

Parameters:: value (str) – The invite code e.g. cv-dgb
Return type:: ID[Literal[Type.Individual]] | None

staticmethod await from_url(url, /, session=None)#

Fetches the ID associated with a Steam Community URL or None.

Note

Each call makes an HTTP request to https://steamcommunity.com.

Examples

The following are valid calls:

>>> await ID.from_url("https://steamcommunity.com/groups/Valve")
>>> await ID.from_url("https://steamcommunity.com/gid/103582791429521412")
>>> await ID.from_url("https://steamcommunity.com/gid/[g:1:4]")
ID(id=4, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

>>> await ID.from_url("https://steamcommunity.com/id/johnc")
>>> await ID.from_url("https://steamcommunity.com/profiles/76561197960265740")
>>> await ID.from_url("https://steamcommunity.com/profiles/[U:1:12]")
>>> await ID.from_url("https://steamcommunity.com/user/r")
ID(id=12, type=Type.Individual, universe=Universe.Public, instance=Instance.Desktop)

>>> await ID.from_url("https://steamcommunity.com/app/570")
ID(id=3703047, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

Parameters:

url (StrOrURL) – The Steam Community URL.
session (ClientSession | None) – The session to make the request with. If None, one is generated.

Return type:

ID[Literal[Type.Individual, Type.Clan]] | None

game_server_ip: IPv4Address | None#: The IP address of the game server the user is currently playing on.

game_server_port: int | None#: The port of the game server the user is currently playing on.

property id: ID32#: The Steam ID’s 32-bit ID.

property id2: str#

The Steam ID’s ID 2.

e.g STEAM_1:0:1234.

property id2_zero: str#: The Steam ID’s ID 2 accounted for bugged GoldSrc and Orange Box games.

Note

In these games the accounts universe, 1 for Type.Public, should be the X component of STEAM_X:0:1234 however, this was bugged and the value of X was 0.

e.g STEAM_0:0:1234.

property id3: str#

The Steam ID’s ID 3.

e.g [U:1:1234].

id64: Final#: The Steam ID’s 64-bit ID.

property instance: Instance#: The instance of the ID.

async for ... in inventories()#

Fetches all the inventories a user has.

Return type:: AsyncGenerator[Inventory[Item[Self], Self], None]

await inventory(app, /, *, context_id=None, language=None)#

Fetch a user’s Inventory for trading.

Parameters:

app (App) – The app to fetch the inventory for.
context_id (int | None) – The context ID for the inventory normally 2.
language (Language | None) – The language to fetch the inventory in. If None will default to the current language.

Raises:

Forbidden – The user’s inventory is private.

Return type:

Inventory[Item[Self], Self]

await inventory_info()#

Fetch the inventory info of the user.

Source for UserInventoryInfo:

@dataclass(slots=True)
class UserInventoryInfo(Generic[UserT]):
    user: UserT
    app: UserInventoryInfoApp
    total_count: int
    trade_permissions: str
    load_failed: bool
    store_vetted: bool
    owner_only: bool
    contexts: list[UserInventoryInfoContext]

    async def inventories(self) -> AsyncGenerator[Inventory[Item[UserT], UserT], None]:
        """An :term:`asynchronous iterator` for accessing a user's full inventory in an app."""
        for context in self.contexts:
            yield await self.user.inventory(App(id=self.app.id), context_id=context.id)

Return type:: list[UserInventoryInfo[Self]]

property invite_code: str | None#

The Steam ID’s invite code in the s.team invite code format.

e.g. cv-dgb.

await invite_to(app)#

Return type:: AppInvite

property invite_url: str | None#

The Steam ID’s full invite code URL.

e.g https://s.team/p/cv-dgb.

await is_banned()#

Specifies if the user is banned from any part of Steam.

Shorthand for:

bans = await user.bans()
bans.is_banned()

Return type:: bool

is_friend()#

Whether the user is in the ClientUser’s friends.

Return type:: bool

is_valid()#

Whether this Steam ID is valid.

A Steam ID is currently considered valid if:

Return type:: bool

last_logoff: datetime | None#: The last time the user logged off steam. Could be None (e.g. if they are currently online).

last_logon: datetime | None#: The last time the user logged into steam.

last_seen_online: datetime | None#: The last time the user was seen online.

await level()#

Fetches the user’s level.

Return type:: int

property mention: str#: The string used to mention the user in chat.

name: str#: The user’s username.

await profile(*, language=None)#

Fetch a user’s entire profile information.

Parameters:: language (Language | None) – The language to fetch the profile items in. If None the current language is used

Note

This calls all the profile related functions to return a Profile object which has all the info set.

Return type:: Profile[Self]

await profile_customisation_info()#

Fetch a user’s profile customisation information.

Return type:: ProfileCustomisation[Self]

async for ... in published_files(*, app=None, revision=PublishedFileRevision.Default, type=PublishedFileType.Community, language=None, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a user’s PublishedFiles.

Examples

Usage:

async for file in user.published_files(limit=10):
    print("Author:", file.author, "Published:", file.name)

All parameters are optional.

Parameters:

app (App | None) – The app to fetch published files in.
type (PublishedFileType) – The type of published file to fetch.
revision (PublishedFileRevision) – The desired revision of the published file to fetch.
language (Language | None) – The language to fetch the published file in. If None, the current language is used.
limit (int | None) – The maximum number of published files to search through. Setting this to None will fetch all of the user’s published files.
before (datetime | None) – A time to search for published files before.
after (datetime | None) – A time to search for published files after.

Yields:

await recently_played()#

Fetches the apps the user has recently played.

Return type:: list[UserRecentlyPlayedApp]

async for ... in reviews(*, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a user’s Reviews.

Examples

Usage:

async for review in user.reviews(limit=10):
    recommended = "recommended" if review.recommend else "doesn't recommend"
    print(f"Author: {review.author} {recommended} {review.app}")

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of reviews to search through. Setting this to None will fetch all the user’s reviews.
before (datetime | None) – A time to search for reviews before.
after (datetime | None) – A time to search for reviews after.

Yields:

rich_presence: dict[str, str] | None#: The user’s rich presence.

await server()#

Fetch the game server this user is currently playing on.

Return type:: GameServer

state: PersonaState#: The current persona state of the account (e.g. LookingToTrade).

property trade_url: URL#: The trade url of the user.

property type: TypeT#: The Steam type of the ID.

property universe: Universe#: The Steam universe of the ID.

await wishlist()#

Get the WishlistApps the user has on their wishlist.

Return type:: list[WishlistApp]

class steam.Friend#

Represents a friend of the ClientUser.

await profile_info()#

The friend’s profile info.

Return type:: ProfileInfo

await profile(*, language=None)#

Fetch a user’s entire profile information.

Parameters:: language (Language | None) – The language to fetch the profile items in. If None the current language is used

Note

This calls all the profile related functions to return a Profile object which has all the info set.

Return type:: FriendProfile

await owns(app)#

Whether the app is owned by this friend.

Parameters:: app (App) – The app you want to check the ownership of.
Return type:: bool

await invite_to_group(group, /)#

Invites the user to a Group.

Parameters:: group (ID[Literal[Type.Chat]]) – The group to invite the user to.

await invite_to_clan(clan, /)#

Invites the user to a Clan.

Parameters:: clan (ID[Literal[Type.Clan]]) – The clan to invite the user to.

async for ... in posts(*, limit=None, before=None, after=None, app=None)#

Fetches this friend’s posts.

Parameters:

limit (int | None) – The maximum number of posts to fetch.
before (datetime | None) – Fetch posts before this date.
after (datetime | None) – Fetch posts after this date.
app (App | None) – Fetch posts for this app.
language – Fetch posts in this language.

Return type:

AsyncGenerator[Post[Self], None]

is_friend()#

Whether the user is in the ClientUser’s friends.

Return type:: bool

await achievements(app, /, *, language=None)#

Fetch the achievements for the user in the app.

Parameters:: language (Language | None) – The language to fetch the stats in. If None will default to the current language.
Return type:: list[UserAppAchievement]

await add()#

Sends a friend invite to the user to your friends list.

app: PartialApp[str] | None#: The app the user is currently in. Is None if the user isn’t in an app.

await app_stats(app, /, *, language=None)#

Fetch the stats for the user in the app.

Parameters:: language (Language | None) – The language to fetch the stats in. If None will default to the current language.
Return type:: UserAppStats

await apps(*, include_free=True)#

Fetches the Apps the user owns.

Parameters:: include_free (bool) – Whether to include free apps in the list. Defaults to True.
Return type:: list[UserApp]

property avatar: Avatar#: The user’s avatar.

await badges()#

Fetches the user’s UserBadgess.

Return type:: UserBadges[Self]

await bans()#

Fetches the user’s Bans.

Return type:: Ban

await block()#

Blocks the user.

await cancel_invite()#

Cancels an invitation sent to the user. This effectively does the same thing as remove().

await clans(*, auto_chunk=False)#

Fetches a list of Clans the user is in.

Parameters:: auto_chunk (bool) – Whether to automatically chunk the clans that are fetched. Defaults to False.
Return type:: list[Clan]

await comment(content, /, *, subscribe=True)#

Post a comment to a comments section.

Parameters:

content (str) – The message to add to the comment section.
subscribe (bool) – Whether to subscribe to notifications on any future activity in this comment’s thread.

Returns:

The created comment.

Return type:

Comment[Self, ClientUser]

async for ... in comments(*, oldest_first=False, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a comment section’s Comment objects.

Examples

Usage:

async for comment in commentable.comments(limit=10):
    print("Author:", comment.author, "Said:", comment.content)

All parameters are optional.

Parameters:

oldest_first (bool) – Whether or not to request comments with the oldest comments first or last. Defaults to False.
limit (int | None) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (datetime | None) – A time to search for comments before.
after (datetime | None) – A time to search for comments after.

Yields:

property community_url: str | None#

The Steam ID’s community url if it is a Type.Individual or Type.Clan.

e.g https://steamcommunity.com/profiles/123456789 or https://steamcommunity.com/gid/123456789.

await equipped_profile_items(*, language=None)#

The user’s equipped profile items.

Parameters:: language (Language | None) – The language to fetch the profile items in. If None the current language is used
Return type:: EquippedProfileItems[Self]

await escrow(token=None)#

Check how long any received items would take to arrive. None if the user has no escrow or has a private inventory.

Parameters:: token (str | None) – The user’s trade offer token, not required if you are friends with the user.
Return type:: timedelta | None

await favourite_badge()#

The user’s favourite badge.

Return type:: FavouriteBadge[PartialApp | Literal[STEAM]] | None

await fetch_comment(id, /)#

Fetch a comment by its ID.

Parameters:: id (int) – The ID of the comment to fetch.
Return type:: Comment[Self]

await fetch_message(id, /)#

Fetch a message by its Message.id.

Return type:: MessageT | None

await fetch_post(id, /)#

Fetch a post by its id.

Parameters:: id (int) – The id of the post to fetch.
Return type:: Post[Self]

await fetch_published_file(id, /, *, revision=PublishedFileRevision.Default, language=None)#

Fetch a published file by its id.

Parameters:

id (int) – The id of the published file to fetch.
revision (PublishedFileRevision) – The desired revision of the published file to fetch.
language (Language | None) – The language to fetch the published file in. If None, the current language is used.

Return type:

PublishedFile[Self] | None

await fetch_review(app)#

Fetch this user’s review for an app.

Parameters:: app (App) – The apps to fetch the reviews for.
Return type:: Review

await fetch_reviews(*apps)#

Fetch this user’s review for apps.

Parameters:: apps (App) – The apps to fetch the reviews for.
Return type:: list[Review]

flags: PersonaStateFlag#: The persona state flags of the account.

await friends()#

Fetch the list of the users friends.

Return type:: Sequence[User]

staticmethod from_id2(value, /)#

Create an ID from a user’s id2.

Parameters:: value (str) – The ID2 e.g. STEAM_1:0:1234.

Note

The universe will be set to Universe.Public if it’s 0. See ID.id2_zero.

Return type:: IndividualID | None

staticmethod from_id3(value, /)#

Create an ID from an SteamID’s id3.

Parameters:: value (str) – The ID3 e.g. [U:1:1234].
Return type:: ID | None

staticmethod from_invite_code(value, /)#

Create an ID from a user’s invite_code.

Parameters:: value (str) – The invite code e.g. cv-dgb
Return type:: ID[Literal[Type.Individual]] | None

staticmethod await from_url(url, /, session=None)#

Fetches the ID associated with a Steam Community URL or None.

Note

Each call makes an HTTP request to https://steamcommunity.com.

Examples

The following are valid calls:

>>> await ID.from_url("https://steamcommunity.com/groups/Valve")
>>> await ID.from_url("https://steamcommunity.com/gid/103582791429521412")
>>> await ID.from_url("https://steamcommunity.com/gid/[g:1:4]")
ID(id=4, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

>>> await ID.from_url("https://steamcommunity.com/id/johnc")
>>> await ID.from_url("https://steamcommunity.com/profiles/76561197960265740")
>>> await ID.from_url("https://steamcommunity.com/profiles/[U:1:12]")
>>> await ID.from_url("https://steamcommunity.com/user/r")
ID(id=12, type=Type.Individual, universe=Universe.Public, instance=Instance.Desktop)

>>> await ID.from_url("https://steamcommunity.com/app/570")
ID(id=3703047, type=Type.Clan, universe=Universe.Public, instance=Instance.All)

Parameters:

url (StrOrURL) – The Steam Community URL.
session (ClientSession | None) – The session to make the request with. If None, one is generated.

Return type:

ID[Literal[Type.Individual, Type.Clan]] | None

game_server_ip: IPv4Address | None#: The IP address of the game server the user is currently playing on.

game_server_port: int | None#: The port of the game server the user is currently playing on.

async for ... in history(*, limit=100, before=None, after=None)#

An asynchronous iterator for accessing a channel’s steam.Messages.

Examples

Usage:

async for message in channel.history(limit=10):
    print("Author:", message.author, "Said:", message.content)

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of messages to search through. Setting this to None will fetch all of the channel’s messages, but this will be a very slow operation.
before (datetime | None) – A time to search for messages before.
after (datetime | None) – A time to search for messages after.

Yields:

property id: ID32#: The Steam ID’s 32-bit ID.

property id2: str#

The Steam ID’s ID 2.

e.g STEAM_1:0:1234.

property id2_zero: str#: The Steam ID’s ID 2 accounted for bugged GoldSrc and Orange Box games.

Note

In these games the accounts universe, 1 for Type.Public, should be the X component of STEAM_X:0:1234 however, this was bugged and the value of X was 0.

e.g STEAM_0:0:1234.

property id3: str#

The Steam ID’s ID 3.

e.g [U:1:1234].

id64: Final#: The Steam ID’s 64-bit ID.

property instance: Instance#: The instance of the ID.

async for ... in inventories()#

Fetches all the inventories a user has.

Return type:: AsyncGenerator[Inventory[Item[Self], Self], None]

await inventory(app, /, *, context_id=None, language=None)#

Fetch a user’s Inventory for trading.

Parameters:

app (App) – The app to fetch the inventory for.
context_id (int | None) – The context ID for the inventory normally 2.
language (Language | None) – The language to fetch the inventory in. If None will default to the current language.

Raises:

Forbidden – The user’s inventory is private.

Return type:

Inventory[Item[Self], Self]

await inventory_info()#

Fetch the inventory info of the user.

Source for UserInventoryInfo:

@dataclass(slots=True)
class UserInventoryInfo(Generic[UserT]):
    user: UserT
    app: UserInventoryInfoApp
    total_count: int
    trade_permissions: str
    load_failed: bool
    store_vetted: bool
    owner_only: bool
    contexts: list[UserInventoryInfoContext]

    async def inventories(self) -> AsyncGenerator[Inventory[Item[UserT], UserT], None]:
        """An :term:`asynchronous iterator` for accessing a user's full inventory in an app."""
        for context in self.contexts:
            yield await self.user.inventory(App(id=self.app.id), context_id=context.id)

Return type:: list[UserInventoryInfo[Self]]

property invite_code: str | None#

The Steam ID’s invite code in the s.team invite code format.

e.g. cv-dgb.

await invite_to(app)#

Return type:: AppInvite

property invite_url: str | None#

The Steam ID’s full invite code URL.

e.g https://s.team/p/cv-dgb.

await is_banned()#

Specifies if the user is banned from any part of Steam.

Shorthand for:

bans = await user.bans()
bans.is_banned()

Return type:: bool

is_valid()#

Whether this Steam ID is valid.

A Steam ID is currently considered valid if:

Return type:: bool

last_logoff: datetime | None#: The last time the user logged off steam. Could be None (e.g. if they are currently online).

last_logon: datetime | None#: The last time the user logged into steam.

last_seen_online: datetime | None#: The last time the user was seen online.

await level()#

Fetches the user’s level.

Return type:: int

property mention: str#: The string used to mention the user in chat.

name: str#: The user’s username.

await profile_customisation_info()#

Fetch a user’s profile customisation information.

Return type:: ProfileCustomisation[Self]

async for ... in published_files(*, app=None, revision=PublishedFileRevision.Default, type=PublishedFileType.Community, language=None, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a user’s PublishedFiles.

Examples

Usage:

async for file in user.published_files(limit=10):
    print("Author:", file.author, "Published:", file.name)

All parameters are optional.

Parameters:

app (App | None) – The app to fetch published files in.
type (PublishedFileType) – The type of published file to fetch.
revision (PublishedFileRevision) – The desired revision of the published file to fetch.
language (Language | None) – The language to fetch the published file in. If None, the current language is used.
limit (int | None) – The maximum number of published files to search through. Setting this to None will fetch all of the user’s published files.
before (datetime | None) – A time to search for published files before.
after (datetime | None) – A time to search for published files after.

Yields:

await recently_played()#

Fetches the apps the user has recently played.

Return type:: list[UserRecentlyPlayedApp]

await remove()#

Remove the user from your friends list.

async for ... in reviews(*, limit=None, before=None, after=None)#

An asynchronous iterator for accessing a user’s Reviews.

Examples

Usage:

async for review in user.reviews(limit=10):
    recommended = "recommended" if review.recommend else "doesn't recommend"
    print(f"Author: {review.author} {recommended} {review.app}")

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of reviews to search through. Setting this to None will fetch all the user’s reviews.
before (datetime | None) – A time to search for reviews before.
after (datetime | None) – A time to search for reviews after.

Yields:

rich_presence: dict[str, str] | None#: The user’s rich presence.

await send(content=..., /, *, trade=None, media=None)#

Send a message, trade or image to an User.

Parameters:

content (Any) – The message to send to the user.
trade (TradeOffer[Asset[User], Asset[ClientUser], Any] | None) –
The trade offer to send to the user.

Note

This will have its id attribute updated after being sent.
media (Media | None) – The media to send to the user.

Raises:

HTTPException – Sending the message failed.
Forbidden – You do not have permission to send the message.

Returns:

The sent message only applicable if content is passed.

Return type:

await server()#

Fetch the game server this user is currently playing on.

Return type:: GameServer

state: PersonaState#: The current persona state of the account (e.g. LookingToTrade).

property trade_url: URL#: The trade url of the user.

await trigger_typing()#

Send a typing indicator to the channel once.

Note

This only works in DMs.

property type: TypeT#: The Steam type of the ID.

async with typing()#

Send a typing indicator continuously to the channel while in the context manager.

Note

This only works in DMs.

Usage:

async with channel.typing():
    ...  # do your expensive operations

Return type:: AsyncGenerator[None, None]

await unblock()#

Unblocks the user.

property universe: Universe#: The Steam universe of the ID.

await wishlist()#

Get the WishlistApps the user has on their wishlist.

Return type:: list[WishlistApp]

Wallet#

class steam.Wallet#

Wallet(_state: ‘ConnectionState’, balance: ‘int’, currency: ‘Currency’, balance_delayed: ‘int’, realm: ‘Realm’)

Data-Classes#

There are a few classes that can be constructed by the user, these include.

App#

class steam.App(*, id, name=None)#

Represents a Steam app.

id: AppID#: The app’s app ID.

name#: The app’s name.

is_valid()#

Whether the app could be a Steam app.

Return type:: bool

property url: str#

//steamcommunity.com.

Type:: The app’s URL on https

There are some predefined apps which are:

steam.TF2 = TF2#: This is “enum” to trick type checkers into allowing Literal[TF2] to be valid for overloads in extensions.

steam.DOTA2 = DOTA2#: This is “enum” to trick type checkers into allowing Literal[TF2] to be valid for overloads in extensions.

steam.CSGO = CSGO#: This is “enum” to trick type checkers into allowing Literal[TF2] to be valid for overloads in extensions.

steam.LFD2 = LFD2#: This is “enum” to trick type checkers into allowing Literal[TF2] to be valid for overloads in extensions.

steam.STEAM = STEAM#: This is “enum” to trick type checkers into allowing Literal[TF2] to be valid for overloads in extensions.

These are shorthand for Client.get_game(440) etc. (you need a client to have been constructed and be use to use the methods that they inherit from PartialApp), they are also valid as type parameters to typing.Literal

Apps can be manually constructed using their app ID eg:

my_rust_instance = steam.App(id=252490, name="Rust")
# this can then be used for trading an app name is not required for this

steam.CUSTOM_APP(name)#

Create a custom app instance for change_presence(). The App.id will be set to 15190414816125648896.

Example:

await client.change_presence(app=steam.CUSTOM_APP("my cool game"))

Parameters:: name (str) – The name of the app to set your playing status to.
Return type:: App[str]

class steam.OwnershipTicket#

Represents an ownership ticket. This is used to verify ownership of an app.

property expires: datetime#: The time at which the ticket expires.

is_expired()#

Whether the ticket has expired.

Return type:: bool

app#: The app the ticket is for.

created_at#: The time the ticket was created.

dlc#: The DLC the user owns.

external_ip#: The external IP address of the user.

flags#: The flags of the ticket.

internal_ip#: The internal IP address of the user.

licenses#: The licenses the user owns.

signature#: The signature of the ticket.

user#: The user who owns the ticket.

version#: The version of the ticket.

class steam.AuthenticationTicket#

Represents an authentication ticket. This is used to verify ownership of an app and to connect to the game server.

auth_ticket#: The authentication ticket for the app. The first 52 bytes of the ticket.

gc_token#: The Game Connect token for the app.

gc_token_created_at#: When the Game Connect token was created.

client_ip#: The IP address of the client.

client_connected_at#: The time the client has been connected to Steam

client_connection_count#: How many servers the client has connected to

await verify(*, publisher_api_key=None)#

Verify the ticket with the web API.

Parameters:: publisher_api_key (str | None) – The publisher API key to use for verification. If not provided, will use the standard (rate limited) API.
Return type:: AuthenticationTicketVerificationResult

await activate()#

Activate the ticket.

await deactivate()#

Deactivate the ticket. Ends our sessions with other users meaning we can’t get events from them anymore.

app#: The app the ticket is for.

created_at#: The time the ticket was created.

dlc#: The DLC the user owns.

property expires: datetime#: The time at which the ticket expires.

external_ip#: The external IP address of the user.

flags#: The flags of the ticket.

internal_ip#: The internal IP address of the user.

is_expired()#

Whether the ticket has expired.

Return type:: bool

licenses#: The licenses the user owns.

signature#: The signature of the ticket.

user#: The user who owns the ticket.

version#: The version of the ticket.

class steam.EncryptedTicket#

Represents an encrypted ticket.

user_data#: The user’s given data for the ticket.

version#: The version of the ticket.

user#: The user who owns the ticket.

app#: The app the ticket is for.

external_ip#: The external IP address of the user.

internal_ip#: The internal IP address of the user.

flags#: The flags of the ticket.

created_at#: The time the ticket was created.

licenses#: The licenses the user owns.

dlc#: The DLC the user owns.

signature#: The signature of the ticket.

class steam.AppShopItem(state, data, description, tags)#

Represents an item that can be purchased from the shop.

class_id: ClassID#: The classid of the item.

def_index#: The def index of the item in the app’s schema

class_#: Extra info about the item.

prices#: The prices of the asset in the store.

original_prices#: The original prices of any items if the price in prices is reduced.

updated_at#: The time the price was last updated

store_tags#: The tags associated with the item.

name#: The market_name of the item.

type#: The type of the item.

tags#: The tags of the item.

colour#: The colour of the item.

icon#: The icon url of the item. Uses the large image url where possible.

display_name#: The displayed name of the item. This could be different to Item.name if the item is user re-nameable.

market_hash_name#: The market_hash_name of the item.

descriptions#: The descriptions of the item.

owner_descriptions#: The descriptions of the item which are visible only to the owner of the item.

fraud_warnings#: The fraud warnings for the item.

actions#: The actions for the item.

owner_actions#: The owner actions for the item.

market_actions#: The market actions for the item.

market_fee#: The market fee percentage for the item.

property app: PartialApp[None]#: The app the item is from.

instance_id: InstanceID#: The instanceid of the item.

is_marketable()#

Whether the item is marketable.

Return type:: bool

is_tradable()#

Whether the item is tradable.

Return type:: bool

listings()#

Fetch the listings of this item on the Steam Community Market place.

Return type:: AsyncGenerator[Listing, None]

property market_fee_app: PartialApp[None]#: The app for which the Steam Community Market fee percentage is applied.

await name_id()#

Fetch the item_nameid of this item on the Steam Community Market place.

Return type:: int

await price(*, currency=None)#

Fetch the price of this item on the Steam Community Market place.

Shorthand for:

await client.fetch_price(item.market_hash_name, item.app, currency)

Return type:: PriceOverview

await price_history(*, currency=None)#

Fetch the price history of this item on the Steam Community Market place.

Shorthand for:

await client.fetch_price_history(item.market_hash_name, item.app, currency)

Return type:: list[PriceHistory]

class steam.AppShopItemTag(name: 'str', display_name: 'str', id: 'int')#

class steam.AppShopItems(items, tags)#

Represents the items that can be purchased from the shop.

x == y: Checks if two app shop items are equal.

len(x): Returns the number of items in the shop.

x[i]: Returns the item at index i.

items: Sequence[AppShopItem]#: The items that can be purchased from the shop

tags: Sequence[AppShopItemTag]#: All the possible tags for items to have.

count(value) → integer -- return number of occurrences of value#

index(value[, start[, stop]]) → integer -- return first index of value.#

Raises ValueError if the value is not present.

Supporting start and stop arguments is optional, but recommended.

class steam.CommunityItem(_state, type, app, name, title, description, image, movie, data, series, class_, editor, active, image_composed, image_composed_foil, deleted, edited_at)#

Represents a community item.

x == y: Checks if two community items are equal.

hash(x): Returns the community item’s hash.

type: int#: The type of the community item.

app: AppT#: The app the community item is from.

name: str#: The name of the community item.

title: str#: The title of the community item.

description: str#: The description of the community item.

image: CDNAsset | None#: The image of the community item. Attempts to use the larger image if possible.

movie: CDNAsset | None#: The movie of the community item. Uses the .mp4 version.

data: Mapping[str, Any] | None#: Data associated with the community item.

series: int#: The series of the community item.

class_: CommunityItemClass#: The class of the community item.

editor: Author | None#: The last editor of the community item.

active: bool#: Whether the community item is active.

image_composed: CDNAsset | None#: The composed image of the community item.

image_composed_foil: CDNAsset | None#: The composed foil image of the community item.

deleted: bool#: Whether the community item is deleted.

edited_at: datetime | None#: When the community item was last edited.

property badges: Sequence[AppBadge[AppT]]#: The badges for the item.

class steam.RewardItem(type, app, name, title, description, display_description, image, movie, animated, badges, def_index, quantity, class_, item_type, point_cost, created_at, updated_at, available_at, availability_ends, active, profile_theme_id, usable_duration, bundle_discount)#

Represents a reward item in the Steam Points Shop.

type: int#: The type of the reward item.

app: AppT#: The app the reward item is from.

name: str#: The name of the reward item.

title: str#: The title of the reward item.

description: str#: The description of the reward item.

display_description: str#: The displayed description of the reward item.

image: CDNAsset | None#: The image of the reward item. Attempts to use the larger image if possible.

movie: CDNAsset | None#: The movie of the reward item. Uses the .mp4 version.

animated: bool#: Whether the reward item is animated.

badges: Sequence[AppBadge[AppT]]#: The badges for the item.

def_index: int#: The def index of the reward item.

quantity: int#: The quantity of the reward item.

class_: CommunityItemClass#: The class of the reward item.

item_type: int#: The type of the reward item.

point_cost: int#: The cost of the reward item in Steam Points.

created_at: datetime#: When the reward item was created.

updated_at: datetime#: When the reward item was last updated.

available_at: datetime#: When the reward item was made available.

availability_ends: datetime#: When the reward item is no longer available.

active: bool#: Whether the reward item is active.

profile_theme_id: str#: The profile theme ID of the reward item.

usable_duration: timedelta#: How long the reward item is usable for.

bundle_discount: int#: The discount of the reward item if it is a bundle.

bundles: Sequence[Self]#: The bundles the reward contains.

class steam.app.PartialApp#

Apps that have state.

await clan()#

Fetch this app’s clan.

This can be useful to get an App’s updates.

clan = await app.clan()
async for update in clan.announcements():
    if update.type in (steam.EventType.MajorUpdate, steam.EventType.SmallUpdate):
        ...  # do something with the update

Raises:: ValueError – This app has no associated clan.
Return type:: Clan

await player_count()#

The apps current player count.

Return type:: int

await stats(*, language=None)#

The stats for this app.

Parameters:: language (Language | None) – The language to fetch the stats in. If None, the current language will be used.

See also

Return type:: AppStats

await achievements(*, language=None)#

The achievements for this app.

Parameters:: language (Language | None) – The language to fetch the achievements in. If None, the current language will be used.
Return type:: list[AppAchievement]

await leaderboards(*, language=None)#

The leaderboards for this app.

Parameters:: language (Language | None) – The language to fetch the leaderboards in. If None, the current language will be used.
Return type:: list[Leaderboard[Self, str]]

await fetch_leaderboard(name)#

Fetch a leaderboard by name.

Parameters:

name (str) –

The name of the leaderboard to fetch.

Note

This is not the name of the leaderboard shown in the app’s stat page, you can find the name of the leaderboard from leaderboards().

Return type:

Leaderboard[Self, None]

await create_leaderboard(name)#

Create a leaderboard with a given name.

Parameters:: name (str) – The name of the leaderboard to create.
Return type:: Leaderboard[Self, None]

await friends_who_own()#

Fetch the users in your friend list who own this app.

Return type:: list[Friend]

await review(content, *, recommend, public=True, commentable=True, received_compensation=False, language=None)#

Review an app.

Parameters:

content (str) – The content of the review.
recommend (bool) – Whether you recommended the app.
public (bool) – Whether the review should be public.
commentable (bool) – Whether the review should allow comments.
received_compensation (bool) – Whether you received compensation for this review.
language (Language | None) – The language the review is in.

Return type:

async for ... in reviews(*, limit=100, before=None, after=None)#

An asynchronous iterator for accessing a steam.App’s steam.Reviews.

Examples

Usage:

async for review in app.reviews(limit=10):
    print("Reviewer:", review.author)
    print("Said:", review.content)

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of reviews to search through. Default is 100. Setting this to None will fetch all the app’s reviews, but this will be a very slow operation.
before (datetime | None) – A time to search for reviews before.
after (datetime | None) – A time to search for reviews after.

Yields:

await friend_thoughts()#

Fetch the client user’s friends who recommended and didn’t recommend this app in a review.

Source for FriendThoughts:

class FriendThoughts(NamedTuple):
    recommended: list[Friend]
    not_recommended: list[Friend]

Return type:: FriendThoughts

await fetch(*, language=None)#

Fetch this app.

Shorthand for:

app = await client.fetch_app(app_id, language=language)

Return type:: FetchedApp

await store_item(*, language=None)#

Fetch the store item for this app.

Shorthand for:

(item,) = await client.fetch_store_item(apps=[app], language=language)

Return type:: AppStoreItem

await info()#

Fetches this app’s product info.

Shorthand for:

(info,) = await client.fetch_product_info(apps=[app])

Return type:: AppInfo

await depots()#

Fetch the depots for this app.

Return type:: Sequence[Depot | HeadlessDepot]

await fetch_manifest(*, id, depot_id, branch='public', password_hash='')#

Fetch a CDN manifest for an app.

Parameters:

id (int) – The ID of the manifest to fetch.
depot_id (int) – The ID of the manifest’s associated depot.
branch (str) – The name of the branch the manifest is from.
password_hash (str) – The hashed password for the manifest.

Return type:

async for ... in manifests(*, limit=100, before=None, after=None, branch='public', password=None, password_hash='')#

An asynchronous iterator for accessing a this app’s steam.Manifests.

Examples

Usage:

async for manifest in app.manifests(limit=10):
    print("Manifest:", manifest.name)
    print(f"Contains {len(manifest.paths)} manifests")

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of Manifests to return.
before (datetime | None) – The time to get manifests before.
after (datetime | None) – The time to get manifests after.
branch (str) – The name of the branch to fetch manifests from.
password (str | None) – The password for the branch, if any.
password_hash (str) – The hashed password for a manifest.

Yields:

Manifest

async for ... in published_files(*, type=PublishedFileQueryFileType.Items, revision=PublishedFileRevision.Default, language=None, limit=100, before=None, after=None)#

An asynchronous iterator for accessing an app’s steam.PublishedFiles.

Examples

Usage:

async for published_file in app.published_files(limit=10):
    print("Published file:", published_file.name)
    print("Published at:", published_file.created_at)
    print("Published by:", published_file.author)

All parameters are optional.

Parameters:

type (PublishedFileQueryFileType) – The type of published files to fetch.
revision (PublishedFileRevision) – The desired revision of the published files to fetch.
language (Language | None) – The language to fetch the published files in. If None the current language is used.
limit (int | None) – The maximum number of published files to search through. Default is 100. Setting this to None will fetch all the app’s published files, but this will be a very slow operation.
before (datetime | None) – A time to search for published files before.
after (datetime | None) – A time to search for published files after.

Yields:

await dlc(*, language=None)#

Fetch the app’s DLC.

Parameters:: language (Language | None) – The language to fetch the DLC in. If None, the current language will be used.
Return type:: list[DLC]

await packages(*, language=None)#

Fetch the app’s packages.

Parameters:: language (Language | None) – The language to fetch the packages in. If None, the current language will be used.
Return type:: list[FetchedAppPackage]

await add_free_licenses()#

Request the free licenses for this app.

Raises:: ValueError – No licenses were granted.
Return type:: list[License]

await shop_items(*, currency=None, language=None)#

Fetch the items that are purchasable inside of the app’s shop.

Parameters:

currency (Currency | None) – If passed only return the prices in this currency otherwise return the prices in all supported currencies.
language (Language | None) – The language to resolve the descriptions of the items to. If None uses the current language.

Return type:

await market_filters()#

Fetch the market filters for this app.

Return type:: list[AppMarketFilter]

async for ... in search_market(query='', *, limit=100, search_description=True, sort_by='popular', reverse=True, filters=())#

Fetch the Steam Community Market listings for this app.

Parameters:

query (str) – The query to search for.
limit (int | None) – The maximum number of listings to search through. Default is 100. Setting this to None will fetch all the app’s listings, but this will be a very slow operation.
search_description (bool) – Whether to search in the description of the listing.
sort_by (market.SortBy) – The column to sort the listings by.
reverse (bool) – Whether to sort the listings in descending order. Default is True. If False the listings will be sorted in ascending order.
filters (Sequence[AppMarketFilter]) – The filters to apply to the search.

Return type:

AsyncGenerator[MarketSearchListing, None]

await community_items(*, type=CommunityDefinitionItemType.NONE, language=None)#

Fetch the app’s community item definitions.

Parameters:

type (CommunityDefinitionItemType) – The type of community item definitions to fetch.
language (Language | None) – The language to fetch the community item definitions in. If None, the current language will be used.

Return type:

list[CommunityItem[Self]]

await reward_items(*, language=None)#

Fetch the app’s reward item definitions.

Parameters:: language (Language | None) – The language to fetch the reward item definitions in. If None, the current language will be used.
Return type:: list[RewardItem[Self]]

await badges(*, language=None)#

Fetch this app’s badges.

Parameters:: language (Language | None) – The language to fetch the badges in. If None, the current language will be used.
Return type:: Sequence[AppBadge[Self]]

await legacy_cd_key()#

Fetch the legacy CD key for this app.

Return type:: str

await encrypted_ticket(key, *, user_data=b'')#

Fetch an encrypted ticket for this app.

Parameters:

key (bytes) – The key to encrypt the ticket with.
user_data (bytes) – The user data to include in the ticket.

Return type:

await ownership_ticket()#

Fetch an ownership ticket for this app.

Return type:: OwnershipTicket

async with create_authentication_ticket()#

Create an authentication ticket for this app.

Examples

async with app.create_authentication_ticket() as ticket:
    ...  # send the ticket to a user or server
    # ticket will only be valid inside this block

Return type:: AsyncGenerator[AuthenticationTicket, None]

id: AppID#: The app’s app ID.

is_valid()#

Whether the app could be a Steam app.

Return type:: bool

name#: The app’s name.

property url: str#

//steamcommunity.com.

Type:: The app’s URL on https

class steam.UserApp#

Represents a Steam app fetched by steam.User.apps().

playtime_forever: timedelta#: The total time the app has been played for.

playtime_two_weeks: timedelta#: The amount of time the user has played the app in the last two weeks.

playtime_windows: timedelta#: The total amount of time the user has played the app on Windows.

playtime_mac_os: timedelta#: The total amount of time the user has played the app on macOS.

playtime_linux: timedelta#: The total amount of time the user has played the app on Linux.

icon#: The icon of the app.

last_played_at#: The time the user last played this app at.

content_descriptors#: The content descriptors of the app.

has_visible_stats()#

Whether the app has publicly visible stats.

Return type:: bool

has_workshop()#

Whether the app has a workshop.

Return type:: bool

await achievements(*, language=None)#

The achievements for this app.

Parameters:: language (Language | None) – The language to fetch the achievements in. If None, the current language will be used.
Return type:: list[AppAchievement]

await add_free_licenses()#

Request the free licenses for this app.

Raises:: ValueError – No licenses were granted.
Return type:: list[License]

await badges(*, language=None)#

Fetch this app’s badges.

Parameters:: language (Language | None) – The language to fetch the badges in. If None, the current language will be used.
Return type:: Sequence[AppBadge[Self]]

await clan()#

Fetch this app’s clan.

This can be useful to get an App’s updates.

clan = await app.clan()
async for update in clan.announcements():
    if update.type in (steam.EventType.MajorUpdate, steam.EventType.SmallUpdate):
        ...  # do something with the update

Raises:: ValueError – This app has no associated clan.
Return type:: Clan

await community_items(*, type=CommunityDefinitionItemType.NONE, language=None)#

Fetch the app’s community item definitions.

Parameters:

type (CommunityDefinitionItemType) – The type of community item definitions to fetch.
language (Language | None) – The language to fetch the community item definitions in. If None, the current language will be used.

Return type:

list[CommunityItem[Self]]

async with create_authentication_ticket()#

Create an authentication ticket for this app.

Examples

async with app.create_authentication_ticket() as ticket:
    ...  # send the ticket to a user or server
    # ticket will only be valid inside this block

Return type:: AsyncGenerator[AuthenticationTicket, None]

await create_leaderboard(name)#

Create a leaderboard with a given name.

Parameters:: name (str) – The name of the leaderboard to create.
Return type:: Leaderboard[Self, None]

await depots()#

Fetch the depots for this app.

Return type:: Sequence[Depot | HeadlessDepot]

await dlc(*, language=None)#

Fetch the app’s DLC.

Parameters:: language (Language | None) – The language to fetch the DLC in. If None, the current language will be used.
Return type:: list[DLC]

await encrypted_ticket(key, *, user_data=b'')#

Fetch an encrypted ticket for this app.

Parameters:

key (bytes) – The key to encrypt the ticket with.
user_data (bytes) – The user data to include in the ticket.

Return type:

await fetch(*, language=None)#

Fetch this app.

Shorthand for:

app = await client.fetch_app(app_id, language=language)

Return type:: FetchedApp

await fetch_leaderboard(name)#

Fetch a leaderboard by name.

Parameters:

name (str) –

The name of the leaderboard to fetch.

Note

This is not the name of the leaderboard shown in the app’s stat page, you can find the name of the leaderboard from leaderboards().

Return type:

Leaderboard[Self, None]

await fetch_manifest(*, id, depot_id, branch='public', password_hash='')#

Fetch a CDN manifest for an app.

Parameters:

id (int) – The ID of the manifest to fetch.
depot_id (int) – The ID of the manifest’s associated depot.
branch (str) – The name of the branch the manifest is from.
password_hash (str) – The hashed password for the manifest.

Return type:

await friend_thoughts()#

Fetch the client user’s friends who recommended and didn’t recommend this app in a review.

Source for FriendThoughts:

class FriendThoughts(NamedTuple):
    recommended: list[Friend]
    not_recommended: list[Friend]

Return type:: FriendThoughts

await friends_who_own()#

Fetch the users in your friend list who own this app.

Return type:: list[Friend]

has_market()#

Whether the app has a market.

Return type:: bool

id: AppID#: The app’s app ID.

await info()#

Fetches this app’s product info.

Shorthand for:

(info,) = await client.fetch_product_info(apps=[app])

Return type:: AppInfo

is_valid()#

Whether the app could be a Steam app.

Return type:: bool

await leaderboards(*, language=None)#

The leaderboards for this app.

Parameters:: language (Language | None) – The language to fetch the leaderboards in. If None, the current language will be used.
Return type:: list[Leaderboard[Self, str]]

await legacy_cd_key()#

Fetch the legacy CD key for this app.

Return type:: str

async for ... in manifests(*, limit=100, before=None, after=None, branch='public', password=None, password_hash='')#

An asynchronous iterator for accessing a this app’s steam.Manifests.

Examples

Usage:

async for manifest in app.manifests(limit=10):
    print("Manifest:", manifest.name)
    print(f"Contains {len(manifest.paths)} manifests")

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of Manifests to return.
before (datetime | None) – The time to get manifests before.
after (datetime | None) – The time to get manifests after.
branch (str) – The name of the branch to fetch manifests from.
password (str | None) – The password for the branch, if any.
password_hash (str) – The hashed password for a manifest.

Yields:

await market_filters()#

Fetch the market filters for this app.

Return type:: list[AppMarketFilter]

name#: The app’s name.

await ownership_ticket()#

Fetch an ownership ticket for this app.

Return type:: OwnershipTicket

await packages(*, language=None)#

Fetch the app’s packages.

Parameters:: language (Language | None) – The language to fetch the packages in. If None, the current language will be used.
Return type:: list[FetchedAppPackage]

await player_count()#

The apps current player count.

Return type:: int

async for ... in published_files(*, type=PublishedFileQueryFileType.Items, revision=PublishedFileRevision.Default, language=None, limit=100, before=None, after=None)#

An asynchronous iterator for accessing an app’s steam.PublishedFiles.

Examples

Usage:

async for published_file in app.published_files(limit=10):
    print("Published file:", published_file.name)
    print("Published at:", published_file.created_at)
    print("Published by:", published_file.author)

All parameters are optional.

Parameters:

type (PublishedFileQueryFileType) – The type of published files to fetch.
revision (PublishedFileRevision) – The desired revision of the published files to fetch.
language (Language | None) – The language to fetch the published files in. If None the current language is used.
limit (int | None) – The maximum number of published files to search through. Default is 100. Setting this to None will fetch all the app’s published files, but this will be a very slow operation.
before (datetime | None) – A time to search for published files before.
after (datetime | None) – A time to search for published files after.

Yields:

await review(content, *, recommend, public=True, commentable=True, received_compensation=False, language=None)#

Review an app.

Parameters:

content (str) – The content of the review.
recommend (bool) – Whether you recommended the app.
public (bool) – Whether the review should be public.
commentable (bool) – Whether the review should allow comments.
received_compensation (bool) – Whether you received compensation for this review.
language (Language | None) – The language the review is in.

Return type:

async for ... in reviews(*, limit=100, before=None, after=None)#

An asynchronous iterator for accessing a steam.App’s steam.Reviews.

Examples

Usage:

async for review in app.reviews(limit=10):
    print("Reviewer:", review.author)
    print("Said:", review.content)

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of reviews to search through. Default is 100. Setting this to None will fetch all the app’s reviews, but this will be a very slow operation.
before (datetime | None) – A time to search for reviews before.
after (datetime | None) – A time to search for reviews after.

Yields:

await reward_items(*, language=None)#

Fetch the app’s reward item definitions.

Parameters:: language (Language | None) – The language to fetch the reward item definitions in. If None, the current language will be used.
Return type:: list[RewardItem[Self]]

async for ... in search_market(query='', *, limit=100, search_description=True, sort_by='popular', reverse=True, filters=())#

Fetch the Steam Community Market listings for this app.

Parameters:

query (str) – The query to search for.
limit (int | None) – The maximum number of listings to search through. Default is 100. Setting this to None will fetch all the app’s listings, but this will be a very slow operation.
search_description (bool) – Whether to search in the description of the listing.
sort_by (market.SortBy) – The column to sort the listings by.
reverse (bool) – Whether to sort the listings in descending order. Default is True. If False the listings will be sorted in ascending order.
filters (Sequence[AppMarketFilter]) – The filters to apply to the search.

Return type:

AsyncGenerator[MarketSearchListing, None]

await shop_items(*, currency=None, language=None)#

Fetch the items that are purchasable inside of the app’s shop.

Parameters:

currency (Currency | None) – If passed only return the prices in this currency otherwise return the prices in all supported currencies.
language (Language | None) – The language to resolve the descriptions of the items to. If None uses the current language.

Return type:

await stats(*, language=None)#

The stats for this app.

Parameters:: language (Language | None) – The language to fetch the stats in. If None, the current language will be used.

See also

Return type:: AppStats

await store_item(*, language=None)#

Fetch the store item for this app.

Shorthand for:

(item,) = await client.fetch_store_item(apps=[app], language=language)

Return type:: AppStoreItem

property url: str#

//steamcommunity.com.

Type:: The app’s URL on https

has_dlc()#

Whether the app has DLC.

Return type:: bool

has_leaderboards()#

Whether the app has leaderboards.

Return type:: bool

class steam.WishlistApp#

Represents a Steam app fetched by steam.User.wishlist().

await achievements(*, language=None)#

The achievements for this app.

Parameters:: language (Language | None) – The language to fetch the achievements in. If None, the current language will be used.
Return type:: list[AppAchievement]

await add_free_licenses()#

Request the free licenses for this app.

Raises:: ValueError – No licenses were granted.
Return type:: list[License]

await badges(*, language=None)#

Fetch this app’s badges.

Parameters:: language (Language | None) – The language to fetch the badges in. If None, the current language will be used.
Return type:: Sequence[AppBadge[Self]]

await clan()#

Fetch this app’s clan.

This can be useful to get an App’s updates.

clan = await app.clan()
async for update in clan.announcements():
    if update.type in (steam.EventType.MajorUpdate, steam.EventType.SmallUpdate):
        ...  # do something with the update

Raises:: ValueError – This app has no associated clan.
Return type:: Clan

await community_items(*, type=CommunityDefinitionItemType.NONE, language=None)#

Fetch the app’s community item definitions.

Parameters:

type (CommunityDefinitionItemType) – The type of community item definitions to fetch.
language (Language | None) – The language to fetch the community item definitions in. If None, the current language will be used.

Return type:

list[CommunityItem[Self]]

async with create_authentication_ticket()#

Create an authentication ticket for this app.

Examples

async with app.create_authentication_ticket() as ticket:
    ...  # send the ticket to a user or server
    # ticket will only be valid inside this block

Return type:: AsyncGenerator[AuthenticationTicket, None]

await create_leaderboard(name)#

Create a leaderboard with a given name.

Parameters:: name (str) – The name of the leaderboard to create.
Return type:: Leaderboard[Self, None]

await depots()#

Fetch the depots for this app.

Return type:: Sequence[Depot | HeadlessDepot]

await dlc(*, language=None)#

Fetch the app’s DLC.

Parameters:: language (Language | None) – The language to fetch the DLC in. If None, the current language will be used.
Return type:: list[DLC]

await encrypted_ticket(key, *, user_data=b'')#

Fetch an encrypted ticket for this app.

Parameters:

key (bytes) – The key to encrypt the ticket with.
user_data (bytes) – The user data to include in the ticket.

Return type:

await fetch(*, language=None)#

Fetch this app.

Shorthand for:

app = await client.fetch_app(app_id, language=language)

Return type:: FetchedApp

await fetch_leaderboard(name)#

Fetch a leaderboard by name.

Parameters:

name (str) –

The name of the leaderboard to fetch.

Note

This is not the name of the leaderboard shown in the app’s stat page, you can find the name of the leaderboard from leaderboards().

Return type:

Leaderboard[Self, None]

await fetch_manifest(*, id, depot_id, branch='public', password_hash='')#

Fetch a CDN manifest for an app.

Parameters:

id (int) – The ID of the manifest to fetch.
depot_id (int) – The ID of the manifest’s associated depot.
branch (str) – The name of the branch the manifest is from.
password_hash (str) – The hashed password for the manifest.

Return type:

await friend_thoughts()#

Fetch the client user’s friends who recommended and didn’t recommend this app in a review.

Source for FriendThoughts:

class FriendThoughts(NamedTuple):
    recommended: list[Friend]
    not_recommended: list[Friend]

Return type:: FriendThoughts

await friends_who_own()#

Fetch the users in your friend list who own this app.

Return type:: list[Friend]

id: AppID#: The app’s app ID.

await info()#

Fetches this app’s product info.

Shorthand for:

(info,) = await client.fetch_product_info(apps=[app])

Return type:: AppInfo

is_valid()#

Whether the app could be a Steam app.

Return type:: bool

await leaderboards(*, language=None)#

The leaderboards for this app.

Parameters:: language (Language | None) – The language to fetch the leaderboards in. If None, the current language will be used.
Return type:: list[Leaderboard[Self, str]]

await legacy_cd_key()#

Fetch the legacy CD key for this app.

Return type:: str

async for ... in manifests(*, limit=100, before=None, after=None, branch='public', password=None, password_hash='')#

An asynchronous iterator for accessing a this app’s steam.Manifests.

Examples

Usage:

async for manifest in app.manifests(limit=10):
    print("Manifest:", manifest.name)
    print(f"Contains {len(manifest.paths)} manifests")

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of Manifests to return.
before (datetime | None) – The time to get manifests before.
after (datetime | None) – The time to get manifests after.
branch (str) – The name of the branch to fetch manifests from.
password (str | None) – The password for the branch, if any.
password_hash (str) – The hashed password for a manifest.

Yields:

await market_filters()#

Fetch the market filters for this app.

Return type:: list[AppMarketFilter]

name#: The app’s name.

await ownership_ticket()#

Fetch an ownership ticket for this app.

Return type:: OwnershipTicket

await packages(*, language=None)#

Fetch the app’s packages.

Parameters:: language (Language | None) – The language to fetch the packages in. If None, the current language will be used.
Return type:: list[FetchedAppPackage]

await player_count()#

The apps current player count.

Return type:: int

async for ... in published_files(*, type=PublishedFileQueryFileType.Items, revision=PublishedFileRevision.Default, language=None, limit=100, before=None, after=None)#

An asynchronous iterator for accessing an app’s steam.PublishedFiles.

Examples

Usage:

async for published_file in app.published_files(limit=10):
    print("Published file:", published_file.name)
    print("Published at:", published_file.created_at)
    print("Published by:", published_file.author)

All parameters are optional.

Parameters:

type (PublishedFileQueryFileType) – The type of published files to fetch.
revision (PublishedFileRevision) – The desired revision of the published files to fetch.
language (Language | None) – The language to fetch the published files in. If None the current language is used.
limit (int | None) – The maximum number of published files to search through. Default is 100. Setting this to None will fetch all the app’s published files, but this will be a very slow operation.
before (datetime | None) – A time to search for published files before.
after (datetime | None) – A time to search for published files after.

Yields:

await review(content, *, recommend, public=True, commentable=True, received_compensation=False, language=None)#

Review an app.

Parameters:

content (str) – The content of the review.
recommend (bool) – Whether you recommended the app.
public (bool) – Whether the review should be public.
commentable (bool) – Whether the review should allow comments.
received_compensation (bool) – Whether you received compensation for this review.
language (Language | None) – The language the review is in.

Return type:

async for ... in reviews(*, limit=100, before=None, after=None)#

An asynchronous iterator for accessing a steam.App’s steam.Reviews.

Examples

Usage:

async for review in app.reviews(limit=10):
    print("Reviewer:", review.author)
    print("Said:", review.content)

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of reviews to search through. Default is 100. Setting this to None will fetch all the app’s reviews, but this will be a very slow operation.
before (datetime | None) – A time to search for reviews before.
after (datetime | None) – A time to search for reviews after.

Yields:

await reward_items(*, language=None)#

Fetch the app’s reward item definitions.

Parameters:: language (Language | None) – The language to fetch the reward item definitions in. If None, the current language will be used.
Return type:: list[RewardItem[Self]]

async for ... in search_market(query='', *, limit=100, search_description=True, sort_by='popular', reverse=True, filters=())#

Fetch the Steam Community Market listings for this app.

Parameters:

query (str) – The query to search for.
limit (int | None) – The maximum number of listings to search through. Default is 100. Setting this to None will fetch all the app’s listings, but this will be a very slow operation.
search_description (bool) – Whether to search in the description of the listing.
sort_by (market.SortBy) – The column to sort the listings by.
reverse (bool) – Whether to sort the listings in descending order. Default is True. If False the listings will be sorted in ascending order.
filters (Sequence[AppMarketFilter]) – The filters to apply to the search.

Return type:

AsyncGenerator[MarketSearchListing, None]

await shop_items(*, currency=None, language=None)#

Fetch the items that are purchasable inside of the app’s shop.

Parameters:

currency (Currency | None) – If passed only return the prices in this currency otherwise return the prices in all supported currencies.
language (Language | None) – The language to resolve the descriptions of the items to. If None uses the current language.

Return type:

await stats(*, language=None)#

The stats for this app.

Parameters:: language (Language | None) – The language to fetch the stats in. If None, the current language will be used.

See also

Return type:: AppStats

await store_item(*, language=None)#

Fetch the store item for this app.

Shorthand for:

(item,) = await client.fetch_store_item(apps=[app], language=language)

Return type:: AppStoreItem

property url: str#

//steamcommunity.com.

Type:: The app’s URL on https

priority#: The priority of the app in the wishlist.

type#: The type of the app.

logo#: The logo of the app.

score#: The score of the app out of ten.

total_reviews#: The total number reviews for the app.

review_status#: The review status of the app.

created_at#: The time the app was uploaded at.

screenshots#: The screenshots of the app.

added_at#: The time that the app was added to their wishlist.

background#: The background of the app.

tags#: The tags of the app.

rank#: The global rank of the app by popularity.

partial_packages: list[PartialPackage]#: The packages this app is included in.

partial_bundles: list[PartialBundle]#: The bundles this app is included in.

is_free()#

Whether the app is free to download.

Return type:: bool

is_on_windows()#

Whether the app is playable on Windows.

Return type:: bool

is_on_mac_os()#

Whether the app is playable on macOS.

Return type:: bool

is_on_linux()#

Whether the app is playable on Linux.

Return type:: bool

class steam.FetchedApp#

Represents a Steam app fetched by steam.Client.fetch_app().

await achievements(*, language=None)#

The achievements for this app.

Parameters:: language (Language | None) – The language to fetch the achievements in. If None, the current language will be used.
Return type:: list[AppAchievement]

await add_free_licenses()#

Request the free licenses for this app.

Raises:: ValueError – No licenses were granted.
Return type:: list[License]

await badges(*, language=None)#

Fetch this app’s badges.

Parameters:: language (Language | None) – The language to fetch the badges in. If None, the current language will be used.
Return type:: Sequence[AppBadge[Self]]

await clan()#

Fetch this app’s clan.

This can be useful to get an App’s updates.

clan = await app.clan()
async for update in clan.announcements():
    if update.type in (steam.EventType.MajorUpdate, steam.EventType.SmallUpdate):
        ...  # do something with the update

Raises:: ValueError – This app has no associated clan.
Return type:: Clan

await community_items(*, type=CommunityDefinitionItemType.NONE, language=None)#

Fetch the app’s community item definitions.

Parameters:

type (CommunityDefinitionItemType) – The type of community item definitions to fetch.
language (Language | None) – The language to fetch the community item definitions in. If None, the current language will be used.

Return type:

list[CommunityItem[Self]]

async with create_authentication_ticket()#

Create an authentication ticket for this app.

Examples

async with app.create_authentication_ticket() as ticket:
    ...  # send the ticket to a user or server
    # ticket will only be valid inside this block

Return type:: AsyncGenerator[AuthenticationTicket, None]

await create_leaderboard(name)#

Create a leaderboard with a given name.

Parameters:: name (str) – The name of the leaderboard to create.
Return type:: Leaderboard[Self, None]

await depots()#

Fetch the depots for this app.

Return type:: Sequence[Depot | HeadlessDepot]

await dlc(*, language=None)#

Fetch the app’s DLC.

Parameters:: language (Language | None) – The language to fetch the DLC in. If None, the current language will be used.
Return type:: list[DLC]

await encrypted_ticket(key, *, user_data=b'')#

Fetch an encrypted ticket for this app.

Parameters:

key (bytes) – The key to encrypt the ticket with.
user_data (bytes) – The user data to include in the ticket.

Return type:

await fetch(*, language=None)#

Fetch this app.

Shorthand for:

app = await client.fetch_app(app_id, language=language)

Return type:: FetchedApp

await fetch_leaderboard(name)#

Fetch a leaderboard by name.

Parameters:

name (str) –

The name of the leaderboard to fetch.

Note

This is not the name of the leaderboard shown in the app’s stat page, you can find the name of the leaderboard from leaderboards().

Return type:

Leaderboard[Self, None]

await fetch_manifest(*, id, depot_id, branch='public', password_hash='')#

Fetch a CDN manifest for an app.

Parameters:

id (int) – The ID of the manifest to fetch.
depot_id (int) – The ID of the manifest’s associated depot.
branch (str) – The name of the branch the manifest is from.
password_hash (str) – The hashed password for the manifest.

Return type:

await friend_thoughts()#

Fetch the client user’s friends who recommended and didn’t recommend this app in a review.

Source for FriendThoughts:

class FriendThoughts(NamedTuple):
    recommended: list[Friend]
    not_recommended: list[Friend]

Return type:: FriendThoughts

await friends_who_own()#

Fetch the users in your friend list who own this app.

Return type:: list[Friend]

id: AppID#: The app’s app ID.

await info()#

Fetches this app’s product info.

Shorthand for:

(info,) = await client.fetch_product_info(apps=[app])

Return type:: AppInfo

is_valid()#

Whether the app could be a Steam app.

Return type:: bool

await leaderboards(*, language=None)#

The leaderboards for this app.

Parameters:: language (Language | None) – The language to fetch the leaderboards in. If None, the current language will be used.
Return type:: list[Leaderboard[Self, str]]

await legacy_cd_key()#

Fetch the legacy CD key for this app.

Return type:: str

async for ... in manifests(*, limit=100, before=None, after=None, branch='public', password=None, password_hash='')#

An asynchronous iterator for accessing a this app’s steam.Manifests.

Examples

Usage:

async for manifest in app.manifests(limit=10):
    print("Manifest:", manifest.name)
    print(f"Contains {len(manifest.paths)} manifests")

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of Manifests to return.
before (datetime | None) – The time to get manifests before.
after (datetime | None) – The time to get manifests after.
branch (str) – The name of the branch to fetch manifests from.
password (str | None) – The password for the branch, if any.
password_hash (str) – The hashed password for a manifest.

Yields:

await market_filters()#

Fetch the market filters for this app.

Return type:: list[AppMarketFilter]

name#: The app’s name.

await ownership_ticket()#

Fetch an ownership ticket for this app.

Return type:: OwnershipTicket

await player_count()#

The apps current player count.

Return type:: int

async for ... in published_files(*, type=PublishedFileQueryFileType.Items, revision=PublishedFileRevision.Default, language=None, limit=100, before=None, after=None)#

An asynchronous iterator for accessing an app’s steam.PublishedFiles.

Examples

Usage:

async for published_file in app.published_files(limit=10):
    print("Published file:", published_file.name)
    print("Published at:", published_file.created_at)
    print("Published by:", published_file.author)

All parameters are optional.

Parameters:

type (PublishedFileQueryFileType) – The type of published files to fetch.
revision (PublishedFileRevision) – The desired revision of the published files to fetch.
language (Language | None) – The language to fetch the published files in. If None the current language is used.
limit (int | None) – The maximum number of published files to search through. Default is 100. Setting this to None will fetch all the app’s published files, but this will be a very slow operation.
before (datetime | None) – A time to search for published files before.
after (datetime | None) – A time to search for published files after.

Yields:

await review(content, *, recommend, public=True, commentable=True, received_compensation=False, language=None)#

Review an app.

Parameters:

content (str) – The content of the review.
recommend (bool) – Whether you recommended the app.
public (bool) – Whether the review should be public.
commentable (bool) – Whether the review should allow comments.
received_compensation (bool) – Whether you received compensation for this review.
language (Language | None) – The language the review is in.

Return type:

async for ... in reviews(*, limit=100, before=None, after=None)#

An asynchronous iterator for accessing a steam.App’s steam.Reviews.

Examples

Usage:

async for review in app.reviews(limit=10):
    print("Reviewer:", review.author)
    print("Said:", review.content)

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of reviews to search through. Default is 100. Setting this to None will fetch all the app’s reviews, but this will be a very slow operation.
before (datetime | None) – A time to search for reviews before.
after (datetime | None) – A time to search for reviews after.

Yields:

await reward_items(*, language=None)#

Fetch the app’s reward item definitions.

Parameters:: language (Language | None) – The language to fetch the reward item definitions in. If None, the current language will be used.
Return type:: list[RewardItem[Self]]

async for ... in search_market(query='', *, limit=100, search_description=True, sort_by='popular', reverse=True, filters=())#

Fetch the Steam Community Market listings for this app.

Parameters:

query (str) – The query to search for.
limit (int | None) – The maximum number of listings to search through. Default is 100. Setting this to None will fetch all the app’s listings, but this will be a very slow operation.
search_description (bool) – Whether to search in the description of the listing.
sort_by (market.SortBy) – The column to sort the listings by.
reverse (bool) – Whether to sort the listings in descending order. Default is True. If False the listings will be sorted in ascending order.
filters (Sequence[AppMarketFilter]) – The filters to apply to the search.

Return type:

AsyncGenerator[MarketSearchListing, None]

await shop_items(*, currency=None, language=None)#

Fetch the items that are purchasable inside of the app’s shop.

Parameters:

currency (Currency | None) – If passed only return the prices in this currency otherwise return the prices in all supported currencies.
language (Language | None) – The language to resolve the descriptions of the items to. If None uses the current language.

Return type:

await stats(*, language=None)#

The stats for this app.

Parameters:: language (Language | None) – The language to fetch the stats in. If None, the current language will be used.

See also

Return type:: AppStats

await store_item(*, language=None)#

Fetch the store item for this app.

Shorthand for:

(item,) = await client.fetch_store_item(apps=[app], language=language)

Return type:: AppStoreItem

property url: str#

//steamcommunity.com.

Type:: The app’s URL on https

logo#: The logo of the app.

background#: The background of the app.

created_at#: The time the app was uploaded at.

type#: The type of the app.

price_overview#: The price overview of the app.

partial_dlc#: The app’s downloadable content.

website_url#: The website URL of the app.

developers#: The developers of the app.

publishers#: The publishers of the app.

description#: The short description of the app.

full_description#: The full description of the app.

movies#: A list of the app’s movies, each of which has name, id, url and optional created_at attributes.

content_descriptors#: The app’s content descriptors for explicit content

await packages(*, language=None)#

Fetch the app’s packages.

Parameters:: language (Language | None) – The language to fetch the packages in. If None, the current language will be used.
Return type:: list[FetchedAppPackage]

is_free()#

Whether the app is free to download.

Return type:: bool

is_on_windows()#

Whether the app is playable on Windows.

Return type:: bool

is_on_mac_os()#

Whether the app is playable on macOS.

Return type:: bool

is_on_linux()#

Whether the app is playable on Linux.

Return type:: bool

class steam.DLC#

Represents DLC (downloadable content) for an app.

created_at#: The time the DLC was released at.

logo#: The logo url of the DLC.

price_overview#: A price overview for the DLC.

is_free()#

Whether the app is free to download.

Return type:: bool

is_on_windows()#

Whether the app is playable on Windows.

Return type:: bool

is_on_mac_os()#

Whether the app is playable on macOS.

Return type:: bool

is_on_linux()#

Whether the app is playable on Linux.

Return type:: bool

await achievements(*, language=None)#

The achievements for this app.

Parameters:: language (Language | None) – The language to fetch the achievements in. If None, the current language will be used.
Return type:: list[AppAchievement]

await add_free_licenses()#

Request the free licenses for this app.

Raises:: ValueError – No licenses were granted.
Return type:: list[License]

await badges(*, language=None)#

Fetch this app’s badges.

Parameters:: language (Language | None) – The language to fetch the badges in. If None, the current language will be used.
Return type:: Sequence[AppBadge[Self]]

await clan()#

Fetch this app’s clan.

This can be useful to get an App’s updates.

clan = await app.clan()
async for update in clan.announcements():
    if update.type in (steam.EventType.MajorUpdate, steam.EventType.SmallUpdate):
        ...  # do something with the update

Raises:: ValueError – This app has no associated clan.
Return type:: Clan

await community_items(*, type=CommunityDefinitionItemType.NONE, language=None)#

Fetch the app’s community item definitions.

Parameters:

type (CommunityDefinitionItemType) – The type of community item definitions to fetch.
language (Language | None) – The language to fetch the community item definitions in. If None, the current language will be used.

Return type:

list[CommunityItem[Self]]

async with create_authentication_ticket()#

Create an authentication ticket for this app.

Examples

async with app.create_authentication_ticket() as ticket:
    ...  # send the ticket to a user or server
    # ticket will only be valid inside this block

Return type:: AsyncGenerator[AuthenticationTicket, None]

await create_leaderboard(name)#

Create a leaderboard with a given name.

Parameters:: name (str) – The name of the leaderboard to create.
Return type:: Leaderboard[Self, None]

await depots()#

Fetch the depots for this app.

Return type:: Sequence[Depot | HeadlessDepot]

await dlc(*, language=None)#

Fetch the app’s DLC.

Parameters:: language (Language | None) – The language to fetch the DLC in. If None, the current language will be used.
Return type:: list[DLC]

await encrypted_ticket(key, *, user_data=b'')#

Fetch an encrypted ticket for this app.

Parameters:

key (bytes) – The key to encrypt the ticket with.
user_data (bytes) – The user data to include in the ticket.

Return type:

await fetch(*, language=None)#

Fetch this app.

Shorthand for:

app = await client.fetch_app(app_id, language=language)

Return type:: FetchedApp

await fetch_leaderboard(name)#

Fetch a leaderboard by name.

Parameters:

name (str) –

The name of the leaderboard to fetch.

Note

This is not the name of the leaderboard shown in the app’s stat page, you can find the name of the leaderboard from leaderboards().

Return type:

Leaderboard[Self, None]

await fetch_manifest(*, id, depot_id, branch='public', password_hash='')#

Fetch a CDN manifest for an app.

Parameters:

id (int) – The ID of the manifest to fetch.
depot_id (int) – The ID of the manifest’s associated depot.
branch (str) – The name of the branch the manifest is from.
password_hash (str) – The hashed password for the manifest.

Return type:

await friend_thoughts()#

Fetch the client user’s friends who recommended and didn’t recommend this app in a review.

Source for FriendThoughts:

class FriendThoughts(NamedTuple):
    recommended: list[Friend]
    not_recommended: list[Friend]

Return type:: FriendThoughts

await friends_who_own()#

Fetch the users in your friend list who own this app.

Return type:: list[Friend]

id: AppID#: The app’s app ID.

await info()#

Fetches this app’s product info.

Shorthand for:

(info,) = await client.fetch_product_info(apps=[app])

Return type:: AppInfo

is_valid()#

Whether the app could be a Steam app.

Return type:: bool

await leaderboards(*, language=None)#

The leaderboards for this app.

Parameters:: language (Language | None) – The language to fetch the leaderboards in. If None, the current language will be used.
Return type:: list[Leaderboard[Self, str]]

await legacy_cd_key()#

Fetch the legacy CD key for this app.

Return type:: str

async for ... in manifests(*, limit=100, before=None, after=None, branch='public', password=None, password_hash='')#

An asynchronous iterator for accessing a this app’s steam.Manifests.

Examples

Usage:

async for manifest in app.manifests(limit=10):
    print("Manifest:", manifest.name)
    print(f"Contains {len(manifest.paths)} manifests")

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of Manifests to return.
before (datetime | None) – The time to get manifests before.
after (datetime | None) – The time to get manifests after.
branch (str) – The name of the branch to fetch manifests from.
password (str | None) – The password for the branch, if any.
password_hash (str) – The hashed password for a manifest.

Yields:

await market_filters()#

Fetch the market filters for this app.

Return type:: list[AppMarketFilter]

name#: The app’s name.

await ownership_ticket()#

Fetch an ownership ticket for this app.

Return type:: OwnershipTicket

await packages(*, language=None)#

Fetch the app’s packages.

Parameters:: language (Language | None) – The language to fetch the packages in. If None, the current language will be used.
Return type:: list[FetchedAppPackage]

await player_count()#

The apps current player count.

Return type:: int

async for ... in published_files(*, type=PublishedFileQueryFileType.Items, revision=PublishedFileRevision.Default, language=None, limit=100, before=None, after=None)#

An asynchronous iterator for accessing an app’s steam.PublishedFiles.

Examples

Usage:

async for published_file in app.published_files(limit=10):
    print("Published file:", published_file.name)
    print("Published at:", published_file.created_at)
    print("Published by:", published_file.author)

All parameters are optional.

Parameters:

type (PublishedFileQueryFileType) – The type of published files to fetch.
revision (PublishedFileRevision) – The desired revision of the published files to fetch.
language (Language | None) – The language to fetch the published files in. If None the current language is used.
limit (int | None) – The maximum number of published files to search through. Default is 100. Setting this to None will fetch all the app’s published files, but this will be a very slow operation.
before (datetime | None) – A time to search for published files before.
after (datetime | None) – A time to search for published files after.

Yields:

await review(content, *, recommend, public=True, commentable=True, received_compensation=False, language=None)#

Review an app.

Parameters:

content (str) – The content of the review.
recommend (bool) – Whether you recommended the app.
public (bool) – Whether the review should be public.
commentable (bool) – Whether the review should allow comments.
received_compensation (bool) – Whether you received compensation for this review.
language (Language | None) – The language the review is in.

Return type:

async for ... in reviews(*, limit=100, before=None, after=None)#

An asynchronous iterator for accessing a steam.App’s steam.Reviews.

Examples

Usage:

async for review in app.reviews(limit=10):
    print("Reviewer:", review.author)
    print("Said:", review.content)

All parameters are optional.

Parameters:

limit (int | None) – The maximum number of reviews to search through. Default is 100. Setting this to None will fetch all the app’s reviews, but this will be a very slow operation.
before (datetime | None) – A time to search for reviews before.
after (datetime | None) – A time to search for reviews after.

Yields:

await reward_items(*, language=None)#

Fetch the app’s reward item definitions.

Parameters:: language (Language | None) – The language to fetch the reward item definitions in. If None, the current language will be used.
Return type:: list[RewardItem[Self]]

async for ... in search_market(query='', *, limit=100, search_description=True, sort_by='popular', reverse=True, filters=())#

Fetch the Steam Community Market listings for this app.

Parameters:

query (str) – The query to search for.
limit (int | None) – The maximum number of listings to search through. Default is 100. Setting this to None will fetch all the app’s listings, but this will be a very slow operation.
search_description (bool) – Whether to search in the description of the listing.
sort_by (market.SortBy) – The column to sort the listings by.
reverse (bool) – Whether to sort the listings in descending order. Default is True. If False the listings will be sorted in ascending order.
filters (Sequence[AppMarketFilter]) – The filters to apply to the search.

Return type:

AsyncGenerator[MarketSearchListing, None]

await shop_items(*, currency=None, language=None)#

Fetch the items that are purchasable inside of the app’s shop.

Parameters:

currency (Currency | None) – If passed only return the prices in this currency otherwise return the prices in all supported currencies.
language (Language | None) – The language to resolve the descriptions of the items to. If None uses the current language.

Return type:

await stats(*, language=None)#

The stats for this app.

Parameters:: language (Language | None) – The language to fetch the stats in. If None, the current language will be used.

See also