API reference ¶

await fetch_review(game)¶

Fetch this user’s review for a game.

Parameters:: game (Game) – The games to fetch the reviews for.
Return type:: steam.review.Review

await fetch_reviews(*games)¶

Fetch this user’s review for games.

Parameters:: games (Game) – The games to fetch the reviews for.
Return type:: list[steam.review.Review]

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

An AsyncIterator for accessing a user’s PublishedFiles.

Examples

Usage:

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

Flattening into a list:

files = await user.published_files(limit=50).flatten()
# files is now a list of PublishedFile

All parameters are optional.

Parameters:

game (Optional[Game]) – The game 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 (Optional[Language]) – The language to fetch the published file in. If None, the current language is used.
limit (Optional[int]) – The maximum number of published files to search through. Setting this to None will fetch all of the user’s published files.
before (Optional[datetime]) – A time to search for published files before.
after (Optional[datetime]) – A time to search for published files after.

Yields:

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:

steam.comment.Comment

comments(*, oldest_first=False, limit=None, before=None, after=None)¶

An AsyncIterator 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)

Flattening into a list:

comments = await commentable.comments(limit=50).flatten()
# comments is now a list of Comment

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:: steam.comment.Comment

staticmethod await from_url(url, session=None)¶

A helper function creates a SteamID instance from a Steam community url.

Note

See id64_from_url() for the full parameter list.

Return type:: Optional[steam.abc.SteamID]

property id: ID32¶: The SteamID’s 32-bit ID.

property id2: str¶

The SteamID’s ID 2.

e.g STEAM_1:0:1234.

property id2_zero: str¶: The SteamID’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 SteamID’s ID 3.

e.g [U:1:1234].

property id64: ID64¶: The SteamID’s 64-bit ID.

property instance: InstanceFlag¶: The instance of the SteamID.

property invite_code: str | None¶

The SteamID’s invite code in the s.team invite code format.

e.g. cv-dgb.

property invite_url: str | None¶

The SteamID’s full invite code URL.

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

is_valid()¶

Whether the SteamID is valid.

Return type:: bool

property type: Type¶: The Steam type of the SteamID.

property universe: Universe¶: The Steam universe of the SteamID.

Methods

defhistory
asyncsend

class steam.abc.Channel¶

abstractmethod history(*, limit=100, before=None, after=None)¶

An AsyncIterator for accessing a channel’s steam.Messages.

Examples

Usage:

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

Flattening into a list:

messages = await channel.history(limit=50).flatten()
# messages is now a list of Message

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 (Optional[datetime]) – A time to search for messages before.
after (Optional[datetime]) – A time to search for messages after.

Yields:

await send(content=None, image=None)¶

Send a message to a certain destination.

Parameters:

content (Any) – The content of the message to send.
image (Image | None) – The image 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:

Optional[steam.abc.M_co]

Methods

asyncsend

class steam.abc.Messageable¶

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

User

ClanChannel

GroupChannel

DMChannel

await send(content=None, image=None)¶

Send a message to a certain destination.

Parameters:

content (Optional[Any]) – The content of the message to send.
image (Optional[Image]) – The image 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:

Optional[steam.abc.M_co]

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.

Announcements¶

Methods

asynccomment
async forcomments
asyncdelete
asyncdownvote
asyncedit
asyncfetch_comment
asyncupvote

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

Represents an announcement in a clan.

id¶

The announcement’s ID.

Type:: int

author¶

The announcement’s author.

Type:: Optional[Union[steam.user.User, steam.abc.SteamID]]

name¶

The announcement’s name.

Type:: str

content¶

The announcement’s content.

Type:: str

game¶

The game that the announcement is for.

Type:: Optional[steam.game.StatefulGame]

clan¶

The announcement’s clan.

Type:: steam.clan.Clan

starts_at¶

The announcement’s start time.

Type:: datetime.datetime

becomes_visible¶

The time at which the announcement becomes visible.

Type:: Optional[datetime.datetime]

stops_being_visible¶

The time at which the announcement stops being visible.

Type:: Optional[datetime.datetime]

ends_at¶

The time at which the announcement ends.

Type:: Optional[datetime.datetime]

type¶

The announcement’s type.

Type:: steam.event.ClanEventT

last_edited_at¶

The time the announcement was last edited at.

Type:: Optional[datetime.datetime]

last_edited_by¶

The user who made the announcement last edited.

Type:: Optional[Union[steam.user.User, steam.abc.SteamID]]

hidden¶

Whether the announcement is currently hidden.

Type:: bool

published¶

Whether the announcement is currently published.

Type:: bool

upvotes¶

The number of up votes on the announcement.

Type:: int

downvotes¶

The number of down votes on the announcement.

Type:: int

comment_count¶

The number of comments on the announcement.

Type:: int

topic_id¶

The id of the forum post comments are sent to.

Type:: Optional[int]

created_at¶

The time at which the announcement was created at.

Type:: datetime.datetime

updated_at¶

The time at which the announcement was last updated_at.

Type:: datetime.datetime

approved_at¶

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

Type:: Optional[datetime.datetime]

tags¶

The announcement’s tags.

Type:: Sequence[str]

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 (Optional[str]) – The announcement’s name.
content (Optional[str]) – The announcement’s content.

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:

steam.comment.Comment

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

An AsyncIterator 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)

Flattening into a list:

comments = await commentable.comments(limit=50).flatten()
# comments is now a list of Comment

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 (Optional[int]) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (Optional[datetime]) – A time to search for comments before.
after (Optional[datetime]) – A time to search for comments after.

Yields:

await delete()¶

Delete this announcement.

await fetch_comment(id)¶

Fetch a comment by its ID.

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

await upvote()¶

Upvote this announcement.

await downvote()¶

Downvote this announcement.

Badge¶

Attributes

completion_time
game
id
level
scarcity
xp

class steam.Badge¶

Represents a Steam badge.

id¶

The badge’s ID.

Type:: int

level¶

The badge’s level.

Type:: int

game¶

The game associated with the badge.

Type:: Optional[steam.game.StatefulGame]

xp¶

The badge’s XP.

Type:: int

completion_time¶

The time the badge was completed at.

Type:: datetime.datetime

scarcity¶

The scarcity of the badge.

Type:: int

Attributes

badges
level
xp
xp_needed_for_current_level
xp_needed_to_level_up

class steam.UserBadges¶

Represents a Steam User’s badges/level.

level¶

The badge’s level.

Type:: int

xp¶

The badge’s XP.

Type:: int

xp_needed_to_level_up¶

The amount of XP the user needs to level up.

Type:: int

xp_needed_for_current_level¶

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

Type:: int

badges¶

A list of the user’s badges.

Type:: Sequence[steam.Badge]

Attributes

border_colour
game
id
item_id
level
type

class steam.FavouriteBadge¶

Represents a User’s favourite badge.

id¶

The badge’s ID.

Type:: int

level¶

The badge’s level.

Type:: int

game¶

The game associated with the badge.

Type:: Optional[steam.game.StatefulGame]

item_id¶

The badge’s item’s ID.

Type:: int

type¶

The badge’s type.

Type:: int

border_colour¶

The colour of the boarder of the badge.

Type:: int

Ban¶

Attributes

number_of_game_bans
since_last_ban

Methods

defis_banned
defis_community_banned
defis_market_banned
defis_vac_banned

class steam.Ban¶

Represents a Steam ban.

since_last_ban¶

How many days since the user was last banned

Type:: datetime.timedelta

number_of_game_bans¶

The number of game bans the user has.

Type:: int

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

Channel¶

Attributes

participant

Methods

async forhistory
asyncsend
asynctrigger_typing
async withtyping

class steam.DMChannel¶

Represents the channel a DM is sent in.

participant¶

The recipient of any messages sent.

Type:: steam.user.User

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:: contextlib._AsyncGeneratorContextManager[None]

await trigger_typing()¶

Send a typing indicator to the channel once.

Note

This only works in DMs.

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

An AsyncIterator for accessing a channel’s steam.Messages.

Examples

Usage:

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

Flattening into a list:

messages = await channel.history(limit=50).flatten()
# messages is now a list of Message

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 (Optional[datetime]) – A time to search for messages before.
after (Optional[datetime]) – A time to search for messages after.

Yields:

await send(content=None, image=None)¶

Send a message to a certain destination.

Parameters:

content (Optional[Any]) – The content of the message to send.
image (Optional[Image]) – The image 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:

Optional[steam.abc.M_co]

Attributes

group
id
joined_at
last_message
name
position

Methods

defhistory
asyncsend

class steam.GroupChannel¶

Represents a group channel.

id¶

The ID of the channel.

Type:: int

name¶

The name of the channel, this could be the same as the name if it’s the main channel.

Type:: Optional[str]

group¶

The group to which messages are sent.

Type:: Optional[steam.group.Group]

joined_at¶

The time the client joined the chat.

Type:: Optional[datetime.datetime]

position¶

The position of the channel in the channel list.

Type:: Optional[int]

last_message¶

The last message sent in the channel.

Type:: Optional[steam.chat.ChatMessageT]

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

An AsyncIterator for accessing a channel’s steam.Messages.

Examples

Usage:

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

Flattening into a list:

messages = await channel.history(limit=50).flatten()
# messages is now a list of Message

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 (Optional[datetime]) – A time to search for messages before.
after (Optional[datetime]) – A time to search for messages after.

Yields:

await send(content=None, image=None)¶

Send a message to a certain destination.

Parameters:

content (Optional[Any]) – The content of the message to send.
image (Optional[Image]) – The image 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:

Optional[steam.abc.M_co]

Attributes

clan
id
joined_at
last_message
name
position

Methods

defhistory
asyncsend

class steam.ClanChannel¶

Represents a group channel.

id¶

The ID of the channel.

Type:: int

name¶

The name of the channel, this could be the same as the name if it’s the main channel.

Type:: Optional[str]

clan¶

The clan to which messages are sent.

Type:: Optional[steam.clan.Clan]

joined_at¶

The time the client joined the chat.

Type:: Optional[datetime.datetime]

position¶

The position of the channel in the channel list.

Type:: Optional[int]

last_message¶

The last message sent in the channel.

Type:: Optional[steam.chat.ChatMessageT]

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

An AsyncIterator for accessing a channel’s steam.Messages.

Examples

Usage:

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

Flattening into a list:

messages = await channel.history(limit=50).flatten()
# messages is now a list of Message

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 (Optional[datetime]) – A time to search for messages before.
after (Optional[datetime]) – A time to search for messages after.

Yields:

await send(content=None, image=None)¶

Send a message to a certain destination.

Parameters:

content (Optional[Any]) – The content of the message to send.
image (Optional[Image]) – The image 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:

Optional[steam.abc.M_co]

Clan¶

Methods

async forannouncements
asyncchunk
asynccomment
async forcomments
asynccreate_announcement
asynccreate_event
async forevents
asyncfetch_announcement
asyncfetch_comment
asyncfetch_event
asyncfetch_members
defget_channel
defget_member
defget_role
asyncinvite
defis_valid
asyncjoin
asyncleave
asyncsearch

class steam.Clan¶

Represents a Steam clan.

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

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

name¶

The name of the clan.

Type:: str

avatar_url¶

The icon url of the clan. Uses the large (184x184 px) image url.

Type:: str

content¶

The content of the clan.

Type:: str

tagline¶

The clan’s tagline.

Type:: str

member_count¶

The amount of users in the clan.

Type:: int

online_count¶

The amount of users currently online.

Type:: int

active_member_count¶

The amount of currently users in the clan’s chat room.

Type:: int

in_game_count¶

The amount of user’s currently in game.

Type:: int

created_at¶

The time the clan was created_at.

Type:: Optional[datetime.datetime]

language¶

The language set for the clan.

Type:: steam.enums.Language

location¶

The location set for the clan.

Type:: str

game¶

The clan’s associated game.

Type:: Optional[steam.game.StatefulGame]

owner¶: The clan’s owner.

admins¶

A list of the clan’s administrators.

Type:: list[steam.user.ClanMember]

mods¶

A list of the clan’s moderators.

Type:: list[steam.user.ClanMember]

await chunk()¶

Get a list of all members in the group.

Return type:: Sequence[steam.user.ClanMember]

await fetch_members()¶

Fetches a clan’s member list.

Note

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

Return type:: list[steam.abc.SteamID]

property description: str¶: An alias to content.

Deprecated since version 0.8.0: Use content instead.

property icon_url: str¶: An alias to avatar_url.

Deprecated since version 0.8.0: Use avatar_url instead.

await join(*, invite_code=None)¶

Joins the clan.

await leave()¶

Leaves the clan.

await fetch_event(id)¶

Fetch an event from its ID.

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

await fetch_announcement(id)¶

Fetch an announcement from its ID.

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

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

An AsyncIterator 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 (Optional[datetime]) – A time to search for events before.
after (Optional[datetime]) – A time to search for events after.

Yields:

Event

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

An AsyncIterator 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 (Optional[datetime]) – A time to search for announcements before.
after (Optional[datetime]) – A time to search for announcements after.

Yields:

Announcement

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

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:

steam.comment.Comment

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

An AsyncIterator 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)

Flattening into a list:

comments = await commentable.comments(limit=50).flatten()
# comments is now a list of Comment

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 (Optional[int]) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (Optional[datetime]) – A time to search for comments before.
after (Optional[datetime]) – A time to search for comments after.

Yields:

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

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

await fetch_comment(id)¶

Fetch a comment by its ID.

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

staticmethod await from_url(url, session=None)¶

A helper function creates a SteamID instance from a Steam community url.

Note

See id64_from_url() for the full parameter list.

Return type:: Optional[steam.abc.SteamID]

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 (ID64) – 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 SteamID’s 32-bit ID.

property id2: str¶

The SteamID’s ID 2.

e.g STEAM_1:0:1234.

property id2_zero: str¶: The SteamID’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 SteamID’s ID 3.

e.g [U:1:1234].

property id64: ID64¶: The SteamID’s 64-bit ID.

property instance: InstanceFlag¶: The instance of the SteamID.

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 SteamID’s invite code in the s.team invite code format.

e.g. cv-dgb.

property invite_url: str | None¶

The SteamID’s full invite code URL.

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

is_valid()¶

Whether the SteamID is valid.

Return type:: bool

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 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:: list[MemberT]

property top_members: Sequence[Union[MemberT, SteamID]]¶: A list of the chat group’s top members.

property type: Type¶: The Steam type of the SteamID.

property universe: Universe¶: The Steam universe of the SteamID.

await create_event(name: str, content: str, *, type: ~typing.Literal[<EventType.Game: 2>] = EventType.Other, starts_at: datetime.datetime | None = None, game: ~steam.game.Game, server_address: str | None = None, server_password: str | None = None) → Game: 2>]]¶

await create_event(name: str, content: str, *, type: BoringEventT = EventType.Other, starts_at: datetime.datetime | None = None) → Event[BoringEventT]

Create an event.

Parameters:

name – The name of the event
content – The content for the event.
type – The type of the event, defaults to ClanEvent.Other.
game – The game that will be played in the event. Required if type is ClanEvent.Game.
starts_at – The time the event will start at.
server_address – The address of the server that the event will be played on. This is only allowed if type is ClanEvent.Game.
server_password – The password for the server that the event will be played on. This is only allowed if type is ClanEvent.Game.

Note

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

Returns:: The created event.
Return type:: Union[steam.event.Event[Any], steam.event.Event[steam.clan.BoringEventT]]

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:

steam.Announcement

Comment¶

Attributes

author
content
created_at
id
owner
reactions

Methods

asyncdelete
asyncreport

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¶

The comment’s ID.

Type:: int

content¶

The comment’s content.

Type:: str

author¶

The author of the comment.

Type:: Union[steam.user.User, steam.user.ClientUser, steam.abc.SteamID]

created_at¶

The time the comment was posted at.

Type:: datetime.datetime

owner¶

The comment sections owner.

Type:: steam.comment.OwnerT

reactions¶

The comment’s reactions.

Type:: list[steam.reaction.AwardReaction]

await report()¶

Reports the comment.

await delete()¶

Deletes the comment.

Events¶

Methods

asynccomment
async forcomments
asyncdelete
asyncedit
asyncfetch_comment
asyncserver

class steam.Event(state, clan, data)¶

Represents an event in a clan.

id¶

The event’s id.

Type:: int

author¶

The event’s author.

Type:: Optional[Union[steam.user.User, steam.abc.SteamID]]

name¶

The event’s name.

Type:: str

content¶

The event’s content.

Type:: str

game¶

The game that the event is going to play in.

Type:: Optional[steam.game.StatefulGame]

clan¶

The event’s clan.

Type:: steam.Clan

starts_at¶

The event’s start time.

Type:: datetime.datetime

becomes_visible¶

The time at which the event becomes visible.

Type:: Optional[datetime.datetime]

stops_being_visible¶

The time at which the event stops being visible.

Type:: Optional[datetime.datetime]

ends_at¶

The time at which the event ends.

Type:: Optional[datetime.datetime]

type¶

The event’s type.

Type:: steam.event.ClanEventT

last_edited_at¶

The time the event was last edited at.

Type:: Optional[datetime.datetime]

last_edited_by¶

The user who made the event last edited.

Type:: Optional[Union[steam.user.User, steam.abc.SteamID]]

hidden¶

Whether the event is currently hidden.

Type:: bool

published¶

Whether the event is currently published.

Type:: bool

upvotes¶

The number of up votes on the event.

Type:: int

downvotes¶

The number of down votes on the event.

Type:: int

comment_count¶

The number of comments on the event.

Type:: int

server_address¶

The event’s server address.

Type:: Optional[str]

server_password¶

The event’s server password.

Type:: Optional[str]

await server()¶

The server that the game will be run on, None if not found.

Note

This is shorthand for

await client.fetch_server(ip=event.server_address)

Return type:: Optional[steam.game_server.GameServer]

await edit(name: str, content: str, *, game: steam.game.Game | None = None, starts_at: datetime.datetime | None = None, server_address: str | None = None, server_password: str | None = None) → None¶

await edit(name: str, content: str, *, type: ~typing.Optional[~typing.Literal[<EventType.Other: 1>, <EventType.Chat: 9>, <EventType.Party: 3>, <EventType.Meeting: 4>, <EventType.SpecialCause: 5>, <EventType.MusicAndArts: 6>, <EventType.Sports: 7>, <EventType.Trip: 8>]] = None, starts_at: datetime.datetime | None = None) → None

await edit(name: str, content: str, *, type: ~typing.Literal[<EventType.Game: 2>] = None, starts_at: datetime.datetime | None = None, game: ~steam.game.Game, server_address: 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 content.
type – The event’s type.
game – The event’s game.
starts_at – The event’s start time.
server_address – The event’s server’s address.
server_password – The event’s server’s password.

Return type:

None

await delete()¶

Delete this event.

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:

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

An AsyncIterator 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)

Flattening into a list:

comments = await commentable.comments(limit=50).flatten()
# comments is now a list of Comment

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 (Optional[int]) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (Optional[datetime]) – A time to search for comments before.
after (Optional[datetime]) – A time to search for comments after.

Yields:

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

await fetch_comment(id)¶

Fetch a comment by its ID.

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

Game Servers¶

Attributes

bot_count
community_url
from_url
game
id
id2
id2_zero
id3
id64
instance
invite_code
invite_url
ip
map
max_player_count
name
player_count
port
region
tags
type
universe
version

Methods

defis_dedicated
defis_secure
defis_valid
asyncplayers
asyncrules

class steam.GameServer¶

Represents a game server.

name¶

The name of the server.

Type:: str

game¶

The game of the server.

Type:: steam.game.StatefulGame

ip¶

The ip of the server.

Type:: str

port¶

The port of the server.

Type:: int

tags¶

The tags of the server.

Type:: list[str]

map¶

The map the server is running.

Type:: str

bot_count¶

The number of bots in the server.

Type:: int

player_count¶

The number of players the server.

Type:: int

max_player_count¶

The maximum player count of the server.

Type:: int

region¶: The region the server is in.

version¶

The version of the server.

Type:: str

is_secure()¶

Whether the sever is secured, likely with VAC.

Return type:: bool

is_dedicated()¶

Whether the sever is dedicated.

Return type:: bool

await players(*, challenge=0)¶

Fetch a server’s players.

Parameters:

challenge (Literal[-1, 0]) –

The challenge for the request default is 0 can also be -1. You may need to change if the server doesn’t seem to respond.

Deprecated since version 0.9.0: This parameter no longer does anything.

Returns:

ServerPlayer is a typing.NamedTuple defined as: .. source:: steam.ServerPlayer

Return type:

list[tuple[int, str, int, datetime.timedelta]]

await rules(*, challenge=0)¶

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

Parameters:

challenges –

The challenge for the request default is 0 can also be -1. You may need to change if the server doesn’t seem to respond.

Deprecated since version 0.9.0: This parameter no longer does anything.

Return type:

dict[str, str]

property community_url: str | None¶

The SteamID’s community url.

staticmethod await from_url(url, session=None)¶

A helper function creates a SteamID instance from a Steam community url.

Note

See id64_from_url() for the full parameter list.

Return type:: Optional[steam.abc.SteamID]

property id: ID32¶: The SteamID’s 32-bit ID.

property id2: str¶

The SteamID’s ID 2.

e.g STEAM_1:0:1234.

property id2_zero: str¶: The SteamID’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 SteamID’s ID 3.

e.g [U:1:1234].

property id64: ID64¶: The SteamID’s 64-bit ID.

property instance: InstanceFlag¶: The instance of the SteamID.

property invite_code: str | None¶

The SteamID’s invite code in the s.team invite code format.

e.g. cv-dgb.

property invite_url: str | None¶

The SteamID’s full invite code URL.

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

is_valid()¶

Whether the SteamID is valid.

Return type:: bool

property type: Type¶: The Steam type of the SteamID.

property universe: Universe¶: The Steam universe of the SteamID.

Attributes

query

Methods

clsQuery.all
clsQuery.dedicated
clsQuery.empty
clsQuery.ip
clsQuery.linux
clsQuery.match_any_hidden_tags
clsQuery.match_hidden_tags
clsQuery.match_tags
clsQuery.name_match
clsQuery.no_password
clsQuery.not_empty
clsQuery.not_full
clsQuery.not_running
clsQuery.proxy
clsQuery.region
clsQuery.running
clsQuery.running_map
clsQuery.running_mod
clsQuery.secure
clsQuery.unique_addresses
clsQuery.version_match
clsQuery.whitelisted

class steam.Query¶

A pathlib.Path like class for constructing Global Master Server queries.

x == y: Checks if two queries are equal, order is checked.

x / y: Appends y’s query to x.

x | y: Combines the two queries in \nor\[x\y] (not or).

x & y: Combines the two queries in \nand\[x\y] (not and).

Examples

Match games running TF2, that are not empty and are using VAC

>>> Query.running / TF2 / Query.not_empty / Query.secure
<Query query='\\appid\\440\\empty\\1\\secure\\1'>

Matches games that are not empty, not full and are not using VAC

>>> Query.not_empty / Query.not_full | Query.secure
<Query query='\\empty\\1\\nor\\[\\full\\1\\secure\\1]'>

Match games where the server name is not “A cool Server” or the server doesn’t support alltalk or increased max players

>>> Query.name_match / "A not cool server" | Query.match_tags / ["alltalk", "increased_maxplayers"]
<Query query='\\nor\\[\\name_match\\A not cool server\\gametype\\[alltalk,increased_maxplayers]]'>

Match games where the server is not on linux and the server doesn’t have no password (has a password)

>>> Query.linux & Query.no_password

property query: str¶: The actual query used for querying Global Master Servers.

class property all: QueryAll¶: Fetches any servers. Any operations on this will fail.

class property dedicated: Q¶: Fetches servers that are running dedicated.

class property empty: Q¶: Fetches servers that are empty.

class property ip: Query[str]¶: Fetches servers on the specified IP address, port is optional.

See also

Client.fetch_server()

class property linux: Q¶: Fetches servers running on a Linux platform.

class property match_any_hidden_tags: Query[list[str]]¶: Fetches servers with any of the given tag(s) in their ‘hidden’ tags only applies for steam.LFD2.

class property match_hidden_tags: Query[list[str]]¶: Fetches servers with all the given tag(s) in their ‘hidden’ tags only applies for steam.LFD2.

class property match_tags: Query[list[str]]¶: Fetches servers with all the given tag(s) in GameServer.tags.

class property name_match: Query[str]¶: Fetches servers with their hostname matching “x” ("*" is wildcard).

class property no_password: Q¶: Fetches servers that are not password protected.

class property not_empty: Q¶: Fetches servers that are not empty.

class property not_full: Q¶: Fetches servers that are not full.

class property not_running: Query[Game | int]¶: Fetches servers not running a Game or an int app id.

class property proxy: Q¶: Fetches servers that are spectator proxies.

class property region: Query[GameServerRegion]¶: Fetches servers in a given region.

class property running: Query[Game | int]¶: Fetches servers running a Game or an int app id.

class property running_map: Query[str]¶: Fetches servers running the specified map (e.g. cs_italy)

class property running_mod: Query[str]¶: Fetches servers running the specified modification (e.g. cstrike).

class property secure: Q¶: Fetches servers that are using anti-cheat technology (VAC, but potentially others as well).

class property unique_addresses: Q¶: Fetches only one server for each unique IP address matched.

class property version_match: Query[str]¶: Fetches servers running version “x” ("*" is wildcard).

class property whitelisted: Q¶: Fetches servers that are whitelisted.

Group¶

Attributes

channels
community_url
default_channel
default_role
from_url
id
id2
id2_zero
id3
id64
instance
invite_code
invite_url
me
members
roles
top_members
type
universe

Methods

asyncchunk
defget_channel
defget_member
defget_role
asyncinvite
defis_valid
asyncjoin
asyncleave
asyncsearch

class steam.Group¶

Represents a Steam group.

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

await chunk()¶

Get a list of all members in the group.

Return type:: Sequence[steam.user.GroupMember]

property community_url: str | None¶

The SteamID’s community url.

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

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

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

staticmethod await from_url(url, session=None)¶

A helper function creates a SteamID instance from a Steam community url.

Note

See id64_from_url() for the full parameter list.

Return type:: Optional[steam.abc.SteamID]

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 (ID64) – 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 SteamID’s 32-bit ID.

property id2: str¶

The SteamID’s ID 2.

e.g STEAM_1:0:1234.

property id2_zero: str¶: The SteamID’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 SteamID’s ID 3.

e.g [U:1:1234].

property id64: ID64¶: The SteamID’s 64-bit ID.

property instance: InstanceFlag¶: The instance of the SteamID.

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 SteamID’s invite code in the s.team invite code format.

e.g. cv-dgb.

property invite_url: str | None¶

The SteamID’s full invite code URL.

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

is_valid()¶

Whether the SteamID is valid.

Return type:: bool

await join(*, invite_code=None)¶

Joins the chat group.

Parameters:: invite_code (Optional[str]) – The invite code to use to join the chat group.

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 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:: list[MemberT]

property top_members: Sequence[Union[MemberT, SteamID]]¶: A list of the chat group’s top members.

property type: Type¶: The Steam type of the SteamID.

property universe: Universe¶: The Steam universe of the SteamID.

Invite¶

Attributes

invitee
relationship

Methods

asyncaccept
asyncdecline

class steam.UserInvite¶

Represents a invite from a user to become their friend.

invitee¶

The user who sent the invite.

Type:: Union[steam.user.User, steam.abc.SteamID]

relationship¶

The relationship you have with the invitee.

Type:: Optional[steam.enums.FriendRelationship]

await accept()¶

Accept the invite request.

await decline()¶

Decline the invite request.

Attributes

clan
invitee
relationship

Methods

asyncaccept
asyncdecline

class steam.ClanInvite¶

Represents a invite to join a Clan from a user.

clan¶

The clan to join.

Type:: Union[steam.Clan, steam.abc.SteamID]

invitee¶

The user who sent the invite.

Type:: Union[steam.user.User, steam.abc.SteamID]

relationship¶

The relationship you have with the clan.

Type:: Optional[steam.enums.FriendRelationship]

await accept()¶

Accept the invite request.

await decline()¶

Decline the invite request.

Manifests¶

Attributes

compressed
created_at
depot_id
game
id
name
paths
size_compressed
size_original

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.

name¶

The name of the manifest.

Type:: Optional[str]

game¶

The game that this manifest was fetched from.

Type:: steam.game.StatefulGame

created_at¶

The time at which the depot was created at.

Type:: datetime.datetime

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

property id: int¶: The ID of this manifest. This is randomly generated by Steam.

property depot_id: int¶: The ID of this manifest’s depot.

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.

Attributes

anchor
chunks
drive
flags
name
parent
parents
parts
root
size
stem
suffix
suffixes

Methods

defas_posix
defas_uri
defglob
asyncimage
defis_absolute
defis_dir
defis_executable
defis_file
defis_hidden
defis_relative_to
defis_reserved
defis_symlink
defiterdir
defjoinpath
defmatch
async withopen
asyncread
asyncread_bytes
asyncread_text
asyncread_vdf
defreadlink
defrelative_to
defrglob
asyncsave
defwith_name
defwith_stem
defwith_suffix

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 is less than the other.

property parents: ManifestPathParents¶: A sequence 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.

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

for ... in iterdir()¶

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

Return type:: Generator

for ... in glob(pattern)¶

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

Return type:: Generator

for ... in rglob(pattern)¶

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

Return type:: Generator

async with open()¶

Reads the entire contents of the file into a io.BytesIO object.

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:

contextlib._AsyncGeneratorContextManager[_io.BytesIO]

await read_bytes(**kwargs)¶

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

Return type:: bytes

await read()¶

Read the whole contents of this file.

Return type:: Never

await read_text(encoding=None)¶

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

Return type:: str

await read_vdf(encoding=None)¶

Read the contents of the file into a VDFDict.

Return type:: multidict._multidict.MultiDict[Union[str, Any]]

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.

await image(*, spoiler=False, **kwargs)¶

Return this file as an image for uploading.

Return type:: Image

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.

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 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.

Attributes

build_id
depots
description
manifests
name
password
password_required
updated_at

Methods

asyncfetch_manifests

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.

Message¶

Attributes

author
channel
clan
clean_content
content
created_at
group
id
mentions
ordinal
reactions

Methods

asyncadd_emoticon
asyncadd_sticker
asyncremove_emoticon
asyncremove_sticker

class steam.Message¶

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

The following classes implement this:

UserMessage

GroupMessage

ClanMessage

x == y: Checks if two messages are equal

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

author: Union[User, ClientUser, SteamID]¶: The message’s author.

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

channel: Channel¶: The channel the message was sent in.

group: Optional[Group]¶: The group the message was sent in. Will be None if the message wasn’t sent in a Group.

clan: Optional[Clan]¶: The clan the message was sent in. Will be None if the message wasn’t sent in a Clan.

content: str¶: 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.

mentions: Optional[Mentions]¶: An object representing mentions in this message.

reactions: list[steam.reaction.MessageReaction]¶: The reactions this message has received.

id¶: 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.

abstractmethod await add_emoticon(emoticon)¶

Adds an emoticon to this message.

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

abstractmethod await remove_emoticon(emoticon)¶

Removes an emoticon from this message.

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

abstractmethod await add_sticker(sticker)¶

Adds a sticker to this message.

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

abstractmethod await remove_sticker(sticker)¶

Adds a sticker to this message.

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

Attributes

author
channel
clan
clean_content
content
created_at
group
id
mentions
ordinal
reactions

Methods

asyncadd_emoticon
asyncadd_sticker
asyncremove_emoticon
asyncremove_sticker

class steam.UserMessage¶

Represents a message from a user.

channel: Channel¶: The channel the message was sent in.

mentions: Optional[Mentions]¶: An object representing mentions in this message.

author: Union[User, ClientUser, SteamID]¶: The message’s author.

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

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.
Return type:: Any

await add_sticker(sticker)¶

Adds a sticker to this message.

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

await remove_sticker(sticker)¶

Adds a sticker to this message.

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

content: str¶: The message’s content.

Note

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

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

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

group: Optional[Group]¶: The group the message was sent in. Will be None if the message wasn’t sent in a Group.

clan: Optional[Clan]¶: The clan the message was sent in. Will be None if the message wasn’t sent in a Clan.

reactions: list[steam.reaction.MessageReaction]¶: The reactions this message has received.

id¶: 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.

Attributes

author
channel
clan
clean_content
content
created_at
group
id
mentions
ordinal
reactions

Methods

asyncadd_emoticon
asyncadd_sticker
asyncfetch_reaction
asyncfetch_reactions
asyncremove_emoticon
asyncremove_sticker

class steam.GroupMessage¶

Represents a message in a group.

channel: Channel¶: The channel the message was sent in.

group: Optional[Group]¶: The group the message was sent in. Will be None if the message wasn’t sent in a Group.

clan: Optional[Clan]¶: The clan the message was sent in. Will be None if the message wasn’t sent in a Clan.

author: Union[User, ClientUser, SteamID]¶: The message’s author.

content: str¶: The message’s content.

Note

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

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

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

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

mentions: Optional[Mentions]¶: An object representing mentions in this message.

reactions: list[steam.reaction.MessageReaction]¶: The reactions this message has received.

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.

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]

id¶: 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 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.

Attributes

author
channel
clan
clean_content
content
created_at
group
id
mentions
ordinal
reactions

Methods

asyncadd_emoticon
asyncadd_sticker
asyncfetch_reaction
asyncfetch_reactions
asyncremove_emoticon
asyncremove_sticker

class steam.ClanMessage¶

Represents a message in a clan.

channel: Channel¶: The channel the message was sent in.

clan: Optional[Clan]¶: The clan the message was sent in. Will be None if the message wasn’t sent in a Clan.

group: Optional[Group]¶: The group the message was sent in. Will be None if the message wasn’t sent in a Group.

author: Union[User, ClientUser, SteamID]¶: The message’s author.

content: str¶: The message’s content.

Note

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

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

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

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

mentions: Optional[Mentions]¶: An object representing mentions in this message.

reactions: list[steam.reaction.MessageReaction]¶: The reactions this message has received.

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.

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]

id¶: 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 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 information on a package which is a collection of one or more applications and depots.

PriceOverview¶

Attributes

currency
lowest_price
median_price
volume

class steam.PriceOverview¶

Represents the data received from https://steamcommunity.com/market/priceoverview.

currency¶

The currency identifier for the item e.g. “$” or “£”.

Type:: str

volume¶

The amount of items that sold in the last 24 hours.

Type:: int

lowest_price¶

The lowest price observed by the market.

Type:: Union[float, str]

median_price¶

The median price observed by the market.

Type:: Union[float, str]

Profile¶

Attributes

city_name
country_name
created_at
headline
real_name
state_name
summary

class steam.ProfileInfo¶

Represents the user’s profile info.

created_at: datetime¶

real_name: Optional[str]¶

city_name: Optional[str]¶

state_name: Optional[str]¶

country_name: Optional[str]¶

headline: Optional[str]¶

summary: str¶

Attributes

class_
description
equipped_flags
game
id
movie
name
title
type
url

Methods

asyncequip
asyncitem

class steam.ProfileItem¶

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

id: int¶

url: str¶

name: str¶

title: str¶

description: str¶

game: StatefulGame¶

type¶

class_¶

movie: ProfileMovie¶

equipped_flags: int¶

await equip()¶

Equip the profile item.

await item(*, language=None)¶

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

Return type:: steam.trade.Item

Attributes

animated_avatars
avatar_frames
backgrounds
mini_profile_backgrounds
modifiers

class steam.OwnedProfileItems¶

Represents the ClientUser's owned items.

backgrounds: list[steam.ProfileItem]¶

mini_profile_backgrounds: list[steam.ProfileItem]¶

avatar_frames: list[steam.ProfileItem]¶

animated_avatars: list[steam.ProfileItem]¶

modifiers: list[steam.ProfileItem]¶

Attributes

animated_avatar
avatar_frame
background
mini_profile_background
modifier

class steam.EquippedProfileItems¶

Represents the items the user has equipped.

background: Optional[ProfileItem]¶

mini_profile_background: Optional[ProfileItem]¶

avatar_frame: Optional[ProfileItem]¶

animated_avatar: Optional[ProfileItem]¶

modifier: Optional[ProfileItem]¶

Attributes

active
large
level
purchase_id
slots
style
type

Methods

asyncbadges
asyncitems
asyncpublished_file

class steam.ProfileShowcase¶

ProfileShowcase(_state: ‘ConnectionState’, owner: ‘BaseUser’, type: ‘ProfileItemType’, large: ‘bool’, active: ‘bool’, purchase_id: ‘int’, level: ‘int’, style: ‘ProfileCustomisationStyle’, slots: ‘list[ProfileShowcaseSlot]’)

type: ProfileItemType¶

large: bool¶

active: bool¶

purchase_id: int¶

level: int¶

style: ProfileCustomisationStyle¶

slots: list[steam.profile.ProfileShowcaseSlot]¶

await items(*, language)¶

Fetches the associated :class:`.Item`s for the entire showcase.

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

await published_file(*, revision=PublishedFileRevision.Default, language=None)¶

Fetches the associated PublishedFile from published_file_id.

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:

steam.published_file.PublishedFile

await badges()¶

Fetches the associated :class:`.Badge`s for the entire showcase.

Return type:: list[steam.Badge]

class steam.Profile¶

Represents a user’s complete profile.

PublishedFile¶

Methods

asyncadd_child
asyncaward
asynccomment
async forcomments
asyncdownvote
asyncedit
asyncfetch_children
asyncfetch_comment
asyncfetch_history_entry
asynchistory
asyncis_subscribed
asyncmanifest
asyncparents
asyncremove_child
asyncsubscribe
asyncunsubscribe
asyncupvote

class steam.PublishedFile(state, proto, author)¶

Represents a published file on SteamPipe.

id: int¶

name: str¶

author: Union[User, ClientUser, SteamID]¶

game: StatefulGame¶

created_with: StatefulGame¶

created_at: datetime¶

updated_at: datetime¶

url: str¶

manifest_id: int¶

revision¶

available_revisions: list¶

change_number: int¶

type¶

views: int¶

youtube_id: str¶

description: str¶

visibility¶

flags: int¶

accepted: bool¶

show_subscribe_all: bool¶

number_of_developer_comments: int¶

number_of_public_comments: int¶

spoiler: bool¶

children: list[steam.published_file.PublishedFileChild]¶

filename: str¶

size: int¶

cdn_url: str¶

preview: PreviewInfo¶

previews: list[steam.published_file.DetailsPreview]¶

banned: bool¶

ban_reason: Optional[str]¶

banner: Optional[int]¶

ban_text_check_result: EBanContentCheckResult¶

can_be_deleted: bool¶

incompatible: bool¶

can_subscribe: bool¶

subscriptions: int¶

time_subscribed: int¶

favourited: int¶

followers: int¶

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:

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

An AsyncIterator 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)

Flattening into a list:

comments = await commentable.comments(limit=50).flatten()
# comments is now a list of Comment

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 (Optional[int]) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (Optional[datetime]) – A time to search for comments before.
after (Optional[datetime]) – A time to search for comments after.

Yields:

list[steam.PublishedFile]

await fetch_comment(id)¶

Fetch a comment by its ID.

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

lifetime_subscriptions: int¶

lifetime_favourited: int¶

lifetime_followers: int¶

lifetime_playtime: int¶

lifetime_playtime_sessions: int¶

image_width: int¶

image_height: int¶

image_url: str¶

shortcut_id: int¶

shortcut_name: str¶

consumer_shortcut_id: int¶

tags: list[steam.protobufs.published_file.PublishedFileDetailsTag]¶

kv_tags: dict[str, str]¶

reports: int¶

upvotes: int¶

downvotes: int¶

score: float¶

playtime_stats: PublishedFileDetailsPlaytimeStats¶

for_sale_data: PublishedFileDetailsForSaleData¶

metadata: str¶

language¶

maybe_inappropriate_sex: bool¶

maybe_inappropriate_violence: bool¶

reactions: list[steam.reaction.AwardReaction]¶

await manifest()¶

The manifest associated with this published file.

Return type:: steam.Manifest

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

Fetches this published file’s children.

Parameters:

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

Return type:

await parents(*, revision=PublishedFileRevision.Default, language=None)¶

Fetches this published file’s parents.

Parameters:

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

Return type:

list[steam.PublishedFile]

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 (Optional[Language]) – The language to fetch history in. If None, the current language is used.
Return type:: list[steam.published_file.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 (Optional[Language]) – The language to fetch history entries in. If None, the current language is used.

Return type:

steam.published_file.PublishedFileChange

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

Edits this published file.

Parameters:

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

Trading¶

steam.Inventory¶: alias of BaseInventory[Item]

Attributes

actions
asset_id
colour
descriptions
display_name
fraud_warnings
game
icon_url
name
owner_descriptions
tags
type
url

Methods

defis_marketable
defis_tradable

class steam.Item¶

Represents an item in a User’s inventory.

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

name¶

The market_name of the item.

Type:: Optional[str]

display_name¶

The displayed name of the item. This could be different to Item.name if the item is user re-nameable.

Type:: Optional[str]

colour¶

The colour of the item.

Type:: Optional[int]

descriptions¶

The descriptions of the item.

Type:: Optional[list]

owner_descriptions¶

The descriptions of the item which are visible only to the owner of the item.

Type:: list

type¶

The type of the item.

Type:: Optional[str]

tags¶

The tags of the item.

Type:: Optional[list]

icon_url¶

The icon url of the item. Uses the large (184x184 px) image url.

Type:: Optional[str]

fraud_warnings¶

The fraud warnings for the item.

Type:: list[str]

actions¶

The actions for the item.

Type:: list

is_tradable()¶

Whether the item is tradable.

Return type:: bool

is_marketable()¶

Whether the item is marketable.

Return type:: bool

property asset_id: int¶: The assetid of the item.

Deprecated since version 0.9.0::: Use id instead.

game¶: The game the item is from.

property url: str¶

The URL for the asset in the owner’s inventory.

e.g. https://steamcommunity.com/profiles/76561198248053954/inventory/#440_2_8526584188

Attributes

amount
asset_id
class_id
game
id
instance_id
owner
post_rollback_id
url

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.

Type:: int

amount¶

The amount of the same asset there are in the inventory.

Type:: int

instance_id¶

The instanceid of the item.

Type:: int

class_id¶

The classid of the item.

Type:: int

post_rollback_id¶: The assetid of the item after a rollback (cancelled, etc.). None if not rolled back.

owner¶

The owner of the asset

Type:: steam.abc.BaseUser

property asset_id: int¶: The assetid of the item.

Deprecated since version 0.9.0::: Use id instead.

game¶: The game the item is from.

property url: str¶

The URL for the asset in the owner’s inventory.

e.g. https://steamcommunity.com/profiles/76561198248053954/inventory/#440_2_8526584188

Attributes

new_asset_id
new_context_id
new_id

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.

Type:: int

new_context_id¶

The new_contextid field.

Type:: int

property new_asset_id: int¶: The new asset ID of the item in the partner’s inventory.

Reactions¶

Attributes

animated_url
id
name
url

Methods

asyncimage
async withopen
asyncread
asyncsave

class steam.Award¶

Represents an award.

id¶

The ID of the award.

Type:: int

name¶

The english localised name of the award.

Type:: str

property url: str¶: The reaction’s icon URL.

property animated_url: str¶: The reaction’s icon animated URL.

async with open(*, animated=False)¶

Open this file as and returns its contents as an in memory buffer.

Return type:: contextlib._AsyncGeneratorContextManager[_io.BytesIO]

await image(*, spoiler=False, **kwargs)¶

Return this file as an image for uploading.

Return type:: Image

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

Attributes

award
count

class steam.AwardReaction¶

Represents an award on user generated content.

award¶

The award given to the user generated content.

Type:: steam.Award

count¶

The reactions count on the post.

Type:: int

Attributes

emoticon
message
sticker

class steam.PartialMessageReaction¶

Represents a partial reaction to a message.

message: Message¶

emoticon: Optional[Emoticon]¶

sticker: Optional[Sticker]¶

Attributes

created_at
ordinal
user

class steam.MessageReaction¶

Represents a reaction to a message.

user: Union[User, ClientUser, SteamID]¶

created_at: Optional[datetime] = None¶

ordinal: Optional[int] = None¶

Attributes

name
url

Methods

asyncgame
asyncimage
async withopen
asyncread
asyncsave

class steam.Emoticon¶

Represents an emoticon in chat.

str(x): The string to send this emoticon in chat.

name¶

The name of this emoticon.

Type:: str

property url: str¶: The URL for this emoticon.

await game()¶

Fetches this emoticon’s associated game.

Note

This game has its name set unlike Sticker.game().

Return type:: steam.StatefulGame

await image(*, spoiler=False, **kwargs)¶

Return this file as an image for uploading.

Return type:: Image

async with open(**kwargs)¶

Open this file as and returns its contents as an in memory buffer.

Return type:: AsyncGenerator[BytesIO, None]

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

Attributes

name
url

Methods

asyncgame
asyncimage
async withopen
asyncread
asyncsave

class steam.Sticker¶

Represents a sticker in chat.

str(x): The way to send this sticker in chat.

Note

Unlike Emoticon this can only be sent in a message by itself.

name¶

The name of this sticker.

Type:: str

property url: str¶: The URL for this sticker.

await game()¶

Fetches this sticker’s associated game.

Return type:: steam.StatefulGame

await image(*, spoiler=False, **kwargs)¶

Return this file as an image for uploading.

Return type:: Image

async with open(**kwargs)¶

Open this file as and returns its contents as an in memory buffer.

Return type:: AsyncGenerator[BytesIO, None]

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

Attributes

Methods

asyncgame
asyncimage
async withopen
asyncread
asyncsave

class steam.ClientEmoticon¶

Represents an Emoticon the ClientUser owns.

await game()¶

Fetches this emoticon’s associated game.

Note

This game has its name set unlike Sticker.game().

Return type:: steam.StatefulGame

await image(*, spoiler=False, **kwargs)¶

Return this file as an image for uploading.

Return type:: Image

async with open(**kwargs)¶

Open this file as and returns its contents as an in memory buffer.

Return type:: AsyncGenerator[BytesIO, None]

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

property url: str¶: The URL for this emoticon.

Attributes

Methods

asyncgame
asyncimage
async withopen
asyncread
asyncsave

class steam.ClientSticker¶

Represents a Sticker the ClientUser owns.

await image(*, spoiler=False, **kwargs)¶

Return this file as an image for uploading.

Return type:: Image

async with open(**kwargs)¶

Open this file as and returns its contents as an in memory buffer.

Return type:: AsyncGenerator[BytesIO, None]

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

property url: str¶: The URL for this sticker.

await game()¶

Fetches this sticker’s associated game.

Return type:: steam.StatefulGame

Reviews¶

Attributes

author
comment_count
commentable
content
created_at
developer_responded_at
developer_response
game
id
language
reactions
received_compensation
recommended
steam_purchase
updated_at
votes_funny
votes_helpful
weighted_vote_score
written_during_early_access

Methods

asyncaward
asynccomment
async forcomments
asyncdelete
asyncedit
asyncfetch_comment
asyncmark_funny
asyncmark_helpful
asyncmark_not_helpful

class steam.Review¶

Represents a review for a game.

id: int¶

author: ReviewUser¶

game: ReviewGame¶

recommended: bool¶

language: Language¶

content: str¶

created_at: datetime¶

updated_at: datetime¶

votes_helpful: int¶

votes_funny: int¶

weighted_vote_score: float¶

commentable: Optional[bool]¶

comment_count: int¶

steam_purchase: Optional[bool]¶

received_compensation: bool¶

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:

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

An AsyncIterator 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)

Flattening into a list:

comments = await commentable.comments(limit=50).flatten()
# comments is now a list of Comment

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 (Optional[int]) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (Optional[datetime]) – A time to search for comments before.
after (Optional[datetime]) – 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:: steam.Comment

written_during_early_access: bool¶

developer_response: Optional[str]¶

developer_responded_at: Optional[datetime]¶

reactions: Optional[list[steam.AwardReaction]]¶

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 (Optional[bool]) – Whether the review should be commentable.
language (Optional[Language]) – The language of the review. Defaults to the current value.
written_during_early_access (Optional[bool]) – Whether the review was written during early access. Defaults to the current value.
received_compensation (Optional[bool]) – Whether the user received compensation for this review. Defaults to the current value.

await delete()¶

Delete this review.

Roles¶

class steam.Role¶

Users¶

Methods

asyncbadges
asyncbans
asyncclans
asyncclear_nicks
asynccomment
async forcomments
asyncedit
asyncequipped_profile_items
asyncfavourite_badge
asyncfetch_comment
asyncfetch_review
asyncfetch_reviews
asyncfriends
asyncgames
defget_friend
asyncinventory
asyncis_banned
defis_commentable
defis_private
defis_valid
asynclevel
asyncprofile
asyncprofile_customisation_info
asyncprofile_info
asyncprofile_items
async forpublished_files
async forreviews
asyncsetup_profile
asyncwishlist

class steam.ClientUser¶

Represents your account.

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

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

name¶

The user’s username.

Type:: str

friends¶

A list of the ClientUser’s friends.

state¶

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

Type:: Optional[steam.enums.PersonaState]

game¶

The Game instance attached to the user. Is None if the user isn’t in a game or one that is recognised by the api.

Type:: Optional[steam.StatefulGame]

avatar_url¶

The avatar url of the user. Uses the large (184x184 px) image url.

Type:: Optional[str]

real_name¶

The user’s real name defined by them. Could be None.

Type:: Optional[str]

primary_clan¶

The user’s primary clan. Could be None

Type:: Optional[steam.Clan]

created_at¶

The time at which the user’s account was created. Could be None.

Type:: Optional[datetime.datetime]

last_logon¶

The last time the user logged into steam. This is only None if user hasn’t been updated from the websocket.

Type:: Optional[datetime.datetime]

last_logoff¶

The last time the user logged off from steam. Could be None (e.g. if they are currently online).

Type:: Optional[datetime.datetime]

last_seen_online¶

The last time the user could be seen online. This is only None if user hasn’t been updated from the websocket.

Type:: Optional[datetime.datetime]

country¶

The country code of the account. Could be None.

Type:: Optional[str]

flags¶

The persona state flags of the account.

Type:: Optional[steam.enums.PersonaStateFlag]

await friends()¶

Returns a list of the user’s friends.

Return type:: list[steam.user.Friend]

get_friend(id)¶

Get a friend from the client user’s friends list.

Return type:: Optional[steam.user.Friend]

await inventory(game, *, language=None)¶

Fetch a user’s Inventory for trading.

Parameters:

game (Game) – The game to fetch the inventory for.
language (Optional[Language]) – 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:

steam.trade.BaseInventory[steam.Item]

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 (Optional[Language]) – The language to fetch the profile items in. If None the current language is used
Return type:: steam.OwnedProfileItems

await profile(*, language=None)¶

Fetch a user’s entire profile information.

Parameters:: language (Optional[Language]) – 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:: steam.profile.ClientUserProfile

await profile_info()¶

The friend’s profile info.

Return type:: steam.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 (Image | None) –
The avatar you wish to use.

Note

This needs to be at least 184px x 184px.

Raises:

HTTPException – Editing your profile failed.

await badges()¶

Fetches the user’s UserBadgess.

Return type:: steam.UserBadges

await bans()¶

Fetches the user’s Bans.

Return type:: steam.Ban

await clans()¶

Fetches a list of Clans the user is in.

Return type:: list[steam.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:

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

An AsyncIterator 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)

Flattening into a list:

comments = await commentable.comments(limit=50).flatten()
# comments is now a list of Comment

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 (Optional[int]) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (Optional[datetime]) – A time to search for comments before.
after (Optional[datetime]) – A time to search for comments after.

Yields:

community_url: Optional[str]¶

await equipped_profile_items(*, language=None)¶

The user’s equipped profile items.

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

await favourite_badge()¶

The user’s favourite badge.

Return type:: Optional[steam.FavouriteBadge]

await fetch_comment(id)¶

Fetch a comment by its ID.

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

await fetch_review(game)¶

Fetch this user’s review for a game.

Parameters:: game (Game) – The games to fetch the reviews for.
Return type:: steam.Review

await fetch_reviews(*games)¶

Fetch this user’s review for games.

Parameters:: games (Game) – The games to fetch the reviews for.
Return type:: list[steam.Review]

staticmethod await from_url(url, session=None)¶

A helper function creates a SteamID instance from a Steam community url.

Note

See id64_from_url() for the full parameter list.

Return type:: Optional[steam.abc.SteamID]

await games(*, include_free=True)¶

Fetches the Games the user owns.

Parameters:: include_free (bool) – Whether to include free games in the list. Defaults to True.
Return type:: list[steam.game.UserGame]

property id: ID32¶: The SteamID’s 32-bit ID.

property id2: str¶

The SteamID’s ID 2.

e.g STEAM_1:0:1234.

property id2_zero: str¶: The SteamID’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 SteamID’s ID 3.

e.g [U:1:1234].

property id64: ID64¶: The SteamID’s 64-bit ID.

property instance: InstanceFlag¶: The instance of the SteamID.

property invite_code: str | None¶

The SteamID’s invite code in the s.team invite code format.

e.g. cv-dgb.

property invite_url: str | None¶

The SteamID’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_commentable()¶

Specifies if the user’s account can be commented on.

Return type:: bool

is_private()¶

Specifies if the user has a private profile.

Return type:: bool

is_valid()¶

Whether the SteamID is valid.

Return type:: bool

await level()¶

Fetches the user’s level if your account is premium, otherwise it’s cached.

Return type:: int

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

await profile_customisation_info(*, language=None)¶

Fetch a user’s profile customisation information.

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

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

An AsyncIterator for accessing a user’s PublishedFiles.

Examples

Usage:

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

Flattening into a list:

files = await user.published_files(limit=50).flatten()
# files is now a list of PublishedFile

All parameters are optional.

Parameters:

game (Optional[Game]) – The game 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 (Optional[Language]) – The language to fetch the published file in. If None, the current language is used.
limit (Optional[int]) – The maximum number of published files to search through. Setting this to None will fetch all of the user’s published files.
before (Optional[datetime]) – A time to search for published files before.
after (Optional[datetime]) – A time to search for published files after.

Yields:

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

An AsyncIterator for accessing a user’s Reviews.

Examples

Usage:

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

Flattening into a list:

reviews = await user.reviews(limit=50).flatten()
# reviews is now a list of Review

All parameters are optional.

Parameters:

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

Yields:

Optional[steam.UserMessage]

property type: Type¶: The Steam type of the SteamID.

property universe: Universe¶: The Steam universe of the SteamID.

await wishlist()¶

Get the WishlistGames the user has on their wishlist.

Return type:: list[steam.game.WishlistGame]

Methods

asyncadd
asyncbadges
asyncbans
asyncblock
asynccancel_invite
asyncclans
asynccomment
async forcomments
asyncequipped_profile_items
asyncescrow
asyncfavourite_badge
asyncfetch_comment
asyncfetch_review
asyncfetch_reviews
asyncfriends
asyncgames
asyncis_banned
defis_commentable
defis_friend
defis_private
defis_valid
asynclevel
asyncprofile
asyncprofile_customisation_info
async forpublished_files
asyncremove
async forreviews
asyncsend
asyncunblock
asyncwishlist

class steam.User¶

Represents a Steam user’s account.

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

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

name¶

The user’s username.

Type:: str

state¶

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

Type:: Optional[steam.enums.PersonaState]

game¶

The Game instance attached to the user. Is None if the user isn’t in a game or one that is recognised by the api.

Type:: Optional[steam.StatefulGame]

avatar_url¶

The avatar url of the user. Uses the large (184x184 px) image url.

Type:: Optional[str]

real_name¶

The user’s real name defined by them. Could be None.

Type:: Optional[str]

primary_clan¶

The user’s primary clan.

Type:: Optional[steam.Clan]

created_at¶

The time at which the user’s account was created. Could be None.

Type:: Optional[datetime.datetime]

last_logon¶

The last time the user logged into steam. This is only None if user hasn’t been updated from the websocket.

Type:: Optional[datetime.datetime]

last_logoff¶

The last time the user logged off from steam. Could be None (e.g. if they are currently online).

Type:: Optional[datetime.datetime]

last_seen_online¶

The last time the user could be seen online. This is only None if user hasn’t been updated from the websocket.

Type:: Optional[datetime.datetime]

country¶

The country code of the account. Could be None.

Type:: Optional[str]

flags¶

The persona state flags of the account.

Type:: Optional[steam.enums.PersonaStateFlag]

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 (Optional[str]) – The user’s trade offer token, not required if you are friends with the user.
Return type:: Optional[datetime.timedelta]

await send(content=None, *, trade=None, image=None)¶

Send a message, trade or image to an User.

Parameters:

content (Any) – The message to send to the user.
trade (TradeOffer | None) –
The trade offer to send to the user.

Note

This will have its id attribute updated after being sent.
image (Image | None) – The image 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:

is_friend()¶

Whether the user is in the ClientUser’s friends.

Return type:: bool

await badges()¶

Fetches the user’s UserBadgess.

Return type:: steam.UserBadges

await bans()¶

Fetches the user’s Bans.

Return type:: steam.Ban

await clans()¶

Fetches a list of Clans the user is in.

Return type:: list[steam.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:

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

An AsyncIterator 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)

Flattening into a list:

comments = await commentable.comments(limit=50).flatten()
# comments is now a list of Comment

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 (Optional[int]) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (Optional[datetime]) – A time to search for comments before.
after (Optional[datetime]) – A time to search for comments after.

Yields:

community_url: Optional[str]¶

await equipped_profile_items(*, language=None)¶

The user’s equipped profile items.

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

await favourite_badge()¶

The user’s favourite badge.

Return type:: Optional[steam.FavouriteBadge]

await fetch_comment(id)¶

Fetch a comment by its ID.

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

await fetch_review(game)¶

Fetch this user’s review for a game.

Parameters:: game (Game) – The games to fetch the reviews for.
Return type:: steam.Review

await fetch_reviews(*games)¶

Fetch this user’s review for games.

Parameters:: games (Game) – The games to fetch the reviews for.
Return type:: list[steam.Review]

await friends()¶

Fetch the list of the users friends.

Return type:: list[steam.User]

staticmethod await from_url(url, session=None)¶

A helper function creates a SteamID instance from a Steam community url.

Note

See id64_from_url() for the full parameter list.

Return type:: Optional[steam.abc.SteamID]

await games(*, include_free=True)¶

Fetches the Games the user owns.

Parameters:: include_free (bool) – Whether to include free games in the list. Defaults to True.
Return type:: list[steam.game.UserGame]

property id: ID32¶: The SteamID’s 32-bit ID.

property id2: str¶

The SteamID’s ID 2.

e.g STEAM_1:0:1234.

property id2_zero: str¶: The SteamID’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 SteamID’s ID 3.

e.g [U:1:1234].

property id64: ID64¶: The SteamID’s 64-bit ID.

property instance: InstanceFlag¶: The instance of the SteamID.

property invite_code: str | None¶

The SteamID’s invite code in the s.team invite code format.

e.g. cv-dgb.

property invite_url: str | None¶

The SteamID’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_commentable()¶

Specifies if the user’s account can be commented on.

Return type:: bool

is_private()¶

Specifies if the user has a private profile.

Return type:: bool

is_valid()¶

Whether the SteamID is valid.

Return type:: bool

await level()¶

Fetches the user’s level if your account is premium, otherwise it’s cached.

Return type:: int

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

await profile(*, language=None)¶

Fetch a user’s entire profile information.

Parameters:: language (Optional[Language]) – 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:: steam.Profile

await profile_customisation_info(*, language=None)¶

Fetch a user’s profile customisation information.

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

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

An AsyncIterator for accessing a user’s PublishedFiles.

Examples

Usage:

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

Flattening into a list:

files = await user.published_files(limit=50).flatten()
# files is now a list of PublishedFile

All parameters are optional.

Parameters:

game (Optional[Game]) – The game 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 (Optional[Language]) – The language to fetch the published file in. If None, the current language is used.
limit (Optional[int]) – The maximum number of published files to search through. Setting this to None will fetch all of the user’s published files.
before (Optional[datetime]) – A time to search for published files before.
after (Optional[datetime]) – A time to search for published files after.

Yields:

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

An AsyncIterator for accessing a user’s Reviews.

Examples

Usage:

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

Flattening into a list:

reviews = await user.reviews(limit=50).flatten()
# reviews is now a list of Review

All parameters are optional.

Parameters:

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

Yields:

property type: Type¶: The Steam type of the SteamID.

property universe: Universe¶: The Steam universe of the SteamID.

await wishlist()¶

Get the WishlistGames the user has on their wishlist.

Return type:: list[steam.game.WishlistGame]

Methods

asyncadd
asyncbadges
asyncbans
asyncblock
asynccancel_invite
asyncclans
asynccomment
async forcomments
asyncequipped_profile_items
asyncescrow
asyncfavourite_badge
asyncfetch_comment
asyncfetch_review
asyncfetch_reviews
asyncfriends
asyncgames
asyncinvite_to_clan
asyncinvite_to_group
asyncis_banned
defis_commentable
defis_friend
defis_private
defis_valid
asynclevel
asyncowns
asyncprofile
asyncprofile_customisation_info
asyncprofile_info
async forpublished_files
asyncremove
async forreviews
asyncsend
asyncunblock
asyncwishlist

class steam.Friend¶

Represents a Steam user’s account.

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

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

name¶

The user’s username.

Type:: str

state¶

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

Type:: Optional[steam.enums.PersonaState]

game¶

The Game instance attached to the user. Is None if the user isn’t in a game or one that is recognised by the api.

Type:: Optional[steam.StatefulGame]

avatar_url¶

The avatar url of the user. Uses the large (184x184 px) image url.

Type:: Optional[str]

real_name¶

The user’s real name defined by them. Could be None.

Type:: Optional[str]

primary_clan¶

The user’s primary clan.

Type:: Optional[steam.Clan]

created_at¶

The time at which the user’s account was created. Could be None.

Type:: Optional[datetime.datetime]

last_logon¶

The last time the user logged into steam. This is only None if user hasn’t been updated from the websocket.

Type:: Optional[datetime.datetime]

last_logoff¶

The last time the user logged off from steam. Could be None (e.g. if they are currently online).

Type:: Optional[datetime.datetime]

last_seen_online¶

The last time the user could be seen online. This is only None if user hasn’t been updated from the websocket.

Type:: Optional[datetime.datetime]

country¶

The country code of the account. Could be None.

Type:: Optional[str]

flags¶

The persona state flags of the account.

Type:: Optional[steam.enums.PersonaStateFlag]

await add()¶

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

property avatar_url¶

attrgetter(attr, …) –> attrgetter object

Return a callable object that fetches the given attribute(s) from its operand. After f = attrgetter(‘name’), the call f(r) returns r.name. After g = attrgetter(‘name’, ‘date’), the call g(r) returns (r.name, r.date). After h = attrgetter(‘name.first’, ‘name.last’), the call h(r) returns (r.name.first, r.name.last).

await badges()¶

Fetches the user’s UserBadgess.

Return type:: steam.UserBadges

await bans()¶

Fetches the user’s Bans.

Return type:: steam.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()¶

Fetches a list of Clans the user is in.

Return type:: list[steam.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:

property comment_permissions¶

attrgetter(attr, …) –> attrgetter object

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

An AsyncIterator 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)

Flattening into a list:

comments = await commentable.comments(limit=50).flatten()
# comments is now a list of Comment

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 (Optional[int]) – The maximum number of comments to search through. Default is None which will fetch the all the comments in the comments section.
before (Optional[datetime]) – A time to search for comments before.
after (Optional[datetime]) – A time to search for comments after.

Yields:

property community_url¶

attrgetter(attr, …) –> attrgetter object

property country¶

attrgetter(attr, …) –> attrgetter object

property created_at¶

attrgetter(attr, …) –> attrgetter object

await equipped_profile_items(*, language=None)¶

The user’s equipped profile items.

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

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 (Optional[str]) – The user’s trade offer token, not required if you are friends with the user.
Return type:: Optional[datetime.timedelta]

await favourite_badge()¶

The user’s favourite badge.

Return type:: Optional[steam.FavouriteBadge]

await fetch_comment(id)¶

Fetch a comment by its ID.

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

await fetch_review(game)¶

Fetch this user’s review for a game.

Parameters:: game (Game) – The games to fetch the reviews for.
Return type:: steam.Review

await fetch_reviews(*games)¶

Fetch this user’s review for games.

Parameters:: games (Game) – The games to fetch the reviews for.
Return type:: list[steam.Review]

property flags¶

attrgetter(attr, …) –> attrgetter object

await friends()¶

Fetch the list of the users friends.

Return type:: list[steam.User]

staticmethod await from_url(url, session=None)¶

A helper function creates a SteamID instance from a Steam community url.

Note

See id64_from_url() for the full parameter list.

Return type:: Optional[steam.abc.SteamID]

property game¶

attrgetter(attr, …) –> attrgetter object

await games(*, include_free=True)¶

Fetches the Games the user owns.

Parameters:: include_free (bool) – Whether to include free games in the list. Defaults to True.
Return type:: list[steam.game.UserGame]

property id: ID32¶: The SteamID’s 32-bit ID.

property id2: str¶

The SteamID’s ID 2.

e.g STEAM_1:0:1234.

property id2_zero: str¶: The SteamID’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 SteamID’s ID 3.

e.g [U:1:1234].

property id64: ID64¶: The SteamID’s 64-bit ID.

property instance: InstanceFlag¶: The instance of the SteamID.

property invite_code: str | None¶

The SteamID’s invite code in the s.team invite code format.

e.g. cv-dgb.

await invite_to_clan(clan)¶

Invites the user to a Clan.

Parameters:: clan (Clan) – The clan to invite the user to.

await invite_to_group(group)¶

Invites the user to a Group.

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

property invite_url: str | None¶

The SteamID’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_commentable()¶

Specifies if the user’s account can be commented on.

Return type:: bool

is_friend()¶

Whether the user is in the ClientUser’s friends.

Return type:: bool

is_private()¶

Specifies if the user has a private profile.

Return type:: bool

is_valid()¶

Whether the SteamID is valid.

Return type:: bool

property last_logoff¶

attrgetter(attr, …) –> attrgetter object

property last_logon¶

attrgetter(attr, …) –> attrgetter object

property last_seen_online¶

attrgetter(attr, …) –> attrgetter object

await level()¶

Fetches the user’s level if your account is premium, otherwise it’s cached.

Return type:: int

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

property name¶

attrgetter(attr, …) –> attrgetter object

await owns(game)¶

Whether the game is owned by this friend.

Parameters:: game (Game) – The game you want to check the ownership of.
Return type:: bool

property primary_clan¶

attrgetter(attr, …) –> attrgetter object

property privacy_state¶

attrgetter(attr, …) –> attrgetter object

await profile(*, language=None)¶

Fetch a user’s entire profile information.

Parameters:: language (Optional[Language]) – 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:: steam.profile.FriendProfile

await profile_customisation_info(*, language=None)¶

Fetch a user’s profile customisation information.

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

await profile_info()¶

The friend’s profile info.

Return type:: steam.ProfileInfo

property profile_state¶

attrgetter(attr, …) –> attrgetter object

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

An AsyncIterator for accessing a user’s PublishedFiles.

Examples

Usage:

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

Flattening into a list:

files = await user.published_files(limit=50).flatten()
# files is now a list of PublishedFile

All parameters are optional.

Parameters:

game (Optional[Game]) – The game 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 (Optional[Language]) – The language to fetch the published file in. If None, the current language is used.
limit (Optional[int]) – The maximum number of published files to search through. Setting this to None will fetch all of the user’s published files.
before (Optional[datetime]) – A time to search for published files before.
after (Optional[datetime]) – A time to search for published files after.

Yields:

property real_name¶

attrgetter(attr, …) –> attrgetter object

await remove()¶

Remove the user from your friends list.

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

An AsyncIterator for accessing a user’s Reviews.

Examples

Usage:

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

Flattening into a list:

reviews = await user.reviews(limit=50).flatten()
# reviews is now a list of Review

All parameters are optional.

Parameters:

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

Yields:

Optional[steam.UserMessage]

property rich_presence¶

attrgetter(attr, …) –> attrgetter object

await send(content=None, *, trade=None, image=None)¶

Send a message, trade or image to an User.

Parameters:

content (Optional[Any]) – The message to send to the user.
trade (Optional[TradeOffer]) –
The trade offer to send to the user.

Note

This will have its id attribute updated after being sent.
image (Optional[Image]) – The image 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:

property state¶

attrgetter(attr, …) –> attrgetter object

property trade_url¶

attrgetter(attr, …) –> attrgetter object

property type: Type¶: The Steam type of the SteamID.

await unblock()¶

Unblocks the user.

property universe: Universe¶: The Steam universe of the SteamID.

await wishlist()¶

Get the WishlistGames the user has on their wishlist.

Return type:: list[steam.game.WishlistGame]

Data-Classes¶

There are a few classes that can be constructed by the user, these include.

Game¶

Attributes

context_id
id
name
title
url

Methods

defis_steam_game

class steam.Game(*, id=None, name=None, title=None, context_id=None)¶

Represents a Steam game.

name¶

The game’s name.

Type:: Optional[str]

id¶

The game’s app ID.

Type:: int

context_id¶

The context id of the game normally 2.

Type:: int

is_steam_game()¶

Whether the game could be a Steam game.

Return type:: bool

property title: str | None¶: The game’s name.

Deprecated since version 0.8.0: Use name instead.

property url: str¶: What should be the game’s url on steamcommunity if applicable.

There are some predefined games which are:

Game Name	Accessed via
Team Fortress 2	`steam.TF2`
DOTA2	`steam.DOTA2`
Counter Strike Global-Offensive	`steam.CSGO`
Left for Dead 2	`steam.LFD2`
Steam	`steam.STEAM`

Games can be manually constructed using there app id eg:

my_rust_instance = steam.Game(id=252490, name="Rust")
# this can then be used for trading a game name is not required for this
# but it is for setting in game statuses if the game isn't a Steam game.

steam.CUSTOM_GAME(name: str) → Game¶

Create a custom game instance for change_presence(). The Game.id will be set to 15190414816125648896 and the Game.context_id to None.

Example:

await client.change_presence(game=steam.CUSTOM_GAME("my cool game"))

Parameters:: name – The name of the game to set your playing status to.
Return type:: Game

Attributes

title
url

Methods

asyncadd_free_licenses
asyncclan
asyncdlc
asyncfetch
asyncfetch_manifest
asyncfriend_thoughts
asyncfriends_who_own
asyncinfo
defis_steam_game
async formanifests
asyncpackages
asyncplayer_count
async forpublished_files
asyncreview
async forreviews

class steam.game.StatefulGame¶

Games that have state.

await add_free_licenses()¶

Request the free licenses for this game.

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

await clan()¶

Fetch this game’s clan.

This can be useful to get a Game’s updates.

clan = await game.clan()
async for update in clan.announcements().filter(
    lambda announcement: announcement.type in (steam.ClanEvent.MajorUpdate, steam.ClanEvent.SmallUpdate)
):
    ...  # do something with the update

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

await dlc(*, language=None)¶

Fetch the game’s DLC.

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

await fetch(*, language=None)¶

Shorthand for:

game = await client.fetch_game(game)

Return type:: steam.game.FetchedGame

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

Fetch a CDN manifest for a game.

Parameters:

id (int) – The ID of the manifest to fetch.
depot_id (int) – The ID of the manifest’s associated depot.

Return type:

await friend_thoughts()¶

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

Return type:: tuple[list[steam.Friend], list[steam.Friend]]

await friends_who_own()¶

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

Return type:: list[steam.Friend]

await info()¶

Shorthand for:

(info,) = await client.fetch_product_info(games=[game])

Return type:: steam.GameInfo

is_steam_game()¶

Whether the game could be a Steam game.

Return type:: bool

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

An AsyncIterator for accessing a steam.Game’s steam.Manifests.

Examples

Usage:

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

Flattening into a list:

manifests = await game.manifests(limit=50).flatten()
# manifests is now a list of Manifest

All parameters are optional.

Parameters:

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

Yields:

Manifest

await packages(*, language=None)¶

Fetch the game’s packages.

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

await player_count()¶

The games 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 AsyncIterator for accessing a game’s steam.PublishedFiles.

Examples

Usage:

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

Flattening into a list:

published_files = await game.published_files(limit=50).flatten()
# published_files is now a list of PublishedFile

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 (Optional[Language]) – 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 game’s published files, but this will be a very slow operation.
before (Optional[datetime]) – A time to search for published files before.
after (Optional[datetime]) – A time to search for published files after.

Yields:

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

Review a game.

Parameters:

content (str) – The content of the review.
recommend (bool) – Whether you recommended the game.
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 AsyncIterator for accessing a steam.Game’s steam.Reviews.

Examples

Usage:

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

Flattening into a list:

reviews = await game.reviews(limit=50).flatten()
# reviews is now a list of Review

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 game’s reviews, but this will be a very slow operation.
before (Optional[datetime]) – A time to search for reviews before.
after (Optional[datetime]) – A time to search for reviews after.

Yields:

property title: str | None¶: The game’s name.

Deprecated since version 0.8.0: Use name instead.

property url: str¶: What should be the game’s url on steamcommunity if applicable.

Attributes

icon_url
last_played_at
playtime_forever
playtime_linux
playtime_mac_os
playtime_two_weeks
playtime_windows
title
url

Methods

asyncadd_free_licenses
asyncclan
asyncdlc
asyncfetch
asyncfetch_manifest
asyncfriend_thoughts
asyncfriends_who_own
defhas_visible_stats
asyncinfo
defis_steam_game
async formanifests
asyncpackages
asyncplayer_count
async forpublished_files
asyncreview
async forreviews

class steam.UserGame¶

Represents a Steam game fetched by steam.User.games()

playtime_forever¶

The total time the game has been played for.

Type:: datetime.timedelta

icon_url¶

The icon url of the game.

Type:: str

playtime_two_weeks¶

The amount of time the user has played the game in the last two weeks.

Type:: datetime.timedelta

playtime_windows¶

The total amount of time the user has played the game on Windows.

Type:: datetime.timedelta

playtime_mac_os¶

The total amount of time the user has played the game on macOS.

Type:: datetime.timedelta

playtime_linux¶

The total amount of time the user has played the game on Linux.

Type:: datetime.timedelta

last_played_at¶

The time the user last played this game at.

Type:: datetime.datetime

has_visible_stats()¶

Whether the game has publicly visible stats.

Return type:: bool

await add_free_licenses()¶

Request the free licenses for this game.

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

await clan()¶

Fetch this game’s clan.

This can be useful to get a Game’s updates.

clan = await game.clan()
async for update in clan.announcements().filter(
    lambda announcement: announcement.type in (steam.ClanEvent.MajorUpdate, steam.ClanEvent.SmallUpdate)
):
    ...  # do something with the update

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

await dlc(*, language=None)¶

Fetch the game’s DLC.

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

await fetch(*, language=None)¶

Shorthand for:

game = await client.fetch_game(game)

Return type:: steam.game.FetchedGame

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

Fetch a CDN manifest for a game.

Parameters:

id (int) – The ID of the manifest to fetch.
depot_id (int) – The ID of the manifest’s associated depot.

Return type:

await friend_thoughts()¶

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

Return type:: tuple[list[steam.Friend], list[steam.Friend]]

await friends_who_own()¶

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

Return type:: list[steam.Friend]

await info()¶

Shorthand for:

(info,) = await client.fetch_product_info(games=[game])

Return type:: steam.GameInfo

is_steam_game()¶

Whether the game could be a Steam game.

Return type:: bool

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

An AsyncIterator for accessing a steam.Game’s steam.Manifests.

Examples

Usage:

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

Flattening into a list:

manifests = await game.manifests(limit=50).flatten()
# manifests is now a list of Manifest

All parameters are optional.

Parameters:

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

Yields:

await packages(*, language=None)¶

Fetch the game’s packages.

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

await player_count()¶

The games 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 AsyncIterator for accessing a game’s steam.PublishedFiles.

Examples

Usage:

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

Flattening into a list:

published_files = await game.published_files(limit=50).flatten()
# published_files is now a list of PublishedFile

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 (Optional[Language]) – The language to fetch the published files in. If None the current language is used.
limit (Optional[int]) – The maximum number of published files to search through. Default is 100. Setting this to None will fetch all the game’s published files, but this will be a very slow operation.
before (Optional[datetime]) – A time to search for published files before.
after (Optional[datetime]) – A time to search for published files after.

Yields:

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

Review a game.

Parameters:

content (str) – The content of the review.
recommend (bool) – Whether you recommended the game.
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 (Optional[Language]) – The language the review is in.

Return type:

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

An AsyncIterator for accessing a steam.Game’s steam.Reviews.

Examples

Usage:

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

Flattening into a list:

reviews = await game.reviews(limit=50).flatten()
# reviews is now a list of Review

All parameters are optional.

Parameters:

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

Yields:

property title: str | None¶: The game’s name.

Deprecated since version 0.8.0: Use name instead.

property url: str¶: What should be the game’s url on steamcommunity if applicable.

Attributes

added_at
background_url
created_at
logo_url
priority
rank
review_status
score
screenshots
tags
title
total_reviews
type
url

Methods

asyncadd_free_licenses
asyncclan
asyncdlc
asyncfetch
asyncfetch_manifest
asyncfriend_thoughts
asyncfriends_who_own
asyncinfo
defis_free
defis_on_linux
defis_on_mac_os
defis_on_windows
defis_steam_game
async formanifests
asyncpackages
asyncplayer_count
async forpublished_files
asyncreview
async forreviews

class steam.WishlistGame¶

Represents a Steam game fetched by steam.User.wishlist().

priority¶

The priority of the game in the wishlist.

Type:: int

added_at¶

The time that the game was added to their wishlist.

Type:: datetime.datetime

created_at¶

The time the game was uploaded at.

Type:: datetime.datetime

background_url¶

The background URL of the game.

Type:: str

rank¶

The global rank of the game by popularity.

Type:: int

review_status¶

The review status of the game.

Type:: Any

score¶

The score of the game out of ten.

Type:: int

screenshots¶

The screenshots of the game.

Type:: list[str]

tags¶

The tags of the game.

Type:: list[str]

total_reviews¶

The total number reviews for the game.

Type:: int

type¶

The type of the app.

Type:: str

logo_url¶

The logo url of the game.

Type:: str

is_free()¶

Whether the game is free to download.

Return type:: bool

is_on_windows()¶

Whether the game is playable on Windows.

Return type:: bool

is_on_mac_os()¶

Whether the game is playable on macOS.

Return type:: bool

is_on_linux()¶

Whether the game is playable on Linux.

Return type:: bool

await add_free_licenses()¶

Request the free licenses for this game.

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

await clan()¶

Fetch this game’s clan.

This can be useful to get a Game’s updates.

clan = await game.clan()
async for update in clan.announcements().filter(
    lambda announcement: announcement.type in (steam.ClanEvent.MajorUpdate, steam.ClanEvent.SmallUpdate)
):
    ...  # do something with the update

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

await dlc(*, language=None)¶

Fetch the game’s DLC.

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

await fetch(*, language=None)¶

Shorthand for:

game = await client.fetch_game(game)

Return type:: steam.game.FetchedGame

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

Fetch a CDN manifest for a game.

Parameters:

id (int) – The ID of the manifest to fetch.
depot_id (int) – The ID of the manifest’s associated depot.

Return type:

await friend_thoughts()¶

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

Return type:: tuple[list[steam.Friend], list[steam.Friend]]

await friends_who_own()¶

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

Return type:: list[steam.Friend]

await info()¶

Shorthand for:

(info,) = await client.fetch_product_info(games=[game])

Return type:: steam.GameInfo

is_steam_game()¶

Whether the game could be a Steam game.

Return type:: bool

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

An AsyncIterator for accessing a steam.Game’s steam.Manifests.

Examples

Usage:

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

Flattening into a list:

manifests = await game.manifests(limit=50).flatten()
# manifests is now a list of Manifest

All parameters are optional.

Parameters:

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

Yields:

await packages(*, language=None)¶

Fetch the game’s packages.

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

await player_count()¶

The games 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 AsyncIterator for accessing a game’s steam.PublishedFiles.

Examples

Usage:

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

Flattening into a list:

published_files = await game.published_files(limit=50).flatten()
# published_files is now a list of PublishedFile

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 (Optional[Language]) – The language to fetch the published files in. If None the current language is used.
limit (Optional[int]) – The maximum number of published files to search through. Default is 100. Setting this to None will fetch all the game’s published files, but this will be a very slow operation.
before (Optional[datetime]) – A time to search for published files before.
after (Optional[datetime]) – A time to search for published files after.

Yields:

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

Review a game.

Parameters:

content (str) – The content of the review.
recommend (bool) – Whether you recommended the game.
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 (Optional[Language]) – The language the review is in.

Return type:

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

An AsyncIterator for accessing a steam.Game’s steam.Reviews.

Examples

Usage:

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

Flattening into a list:

reviews = await game.reviews(limit=50).flatten()
# reviews is now a list of Review

All parameters are optional.

Parameters:

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

Yields:

property title: str | None¶: The game’s name.

Deprecated since version 0.8.0: Use name instead.

property url: str¶: What should be the game’s url on steamcommunity if applicable.

Attributes

background_url
created_at
description
developers
full_description
logo_url
movies
partial_dlc
price_overview
publishers
title
type
url
website_url

Methods

asyncadd_free_licenses
asyncclan
asyncdlc
asyncfetch
asyncfetch_manifest
asyncfriend_thoughts
asyncfriends_who_own
asyncinfo
defis_free
defis_on_linux
defis_on_mac_os
defis_on_windows
defis_steam_game
async formanifests
asyncpackages
asyncplayer_count
async forpublished_files
asyncreview
async forreviews

class steam.FetchedGame¶

Represents a Steam game fetched by steam.Client.fetch_game().

created_at¶

The time the game was uploaded at.

Type:: Optional[datetime.datetime]

background_url¶

The background URL of the game.

Type:: str

type¶: The type of the app.

logo_url¶

The logo URL of the game.

Type:: str

partial_dlc¶

The game’s downloadable content.

Type:: list[steam.StatefulGame]

website_url¶

The website URL of the game.

Type:: Optional[str]

developers¶

The developers of the game.

Type:: list[str]

publishers¶

The publishers of the game.

Type:: list[str]

description¶

The short description of the game.

Type:: str

full_description¶

The full description of the game.

Type:: str

movies¶

A list of the game’s movies, each of which has name, id, url and optional created_at attributes.

Type:: Optional[list[steam.game.Movie]]

price_overview¶

The price overview of the game.

Type:: steam.game.GamePriceOverview

await add_free_licenses()¶

Request the free licenses for this game.

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

await clan()¶

Fetch this game’s clan.

This can be useful to get a Game’s updates.

clan = await game.clan()
async for update in clan.announcements().filter(
    lambda announcement: announcement.type in (steam.ClanEvent.MajorUpdate, steam.ClanEvent.SmallUpdate)
):
    ...  # do something with the update

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

await dlc(*, language=None)¶

Fetch the game’s DLC.

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

await fetch(*, language=None)¶

Shorthand for:

game = await client.fetch_game(game)

Return type:: steam.FetchedGame

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

Fetch a CDN manifest for a game.

Parameters:

id (int) – The ID of the manifest to fetch.
depot_id (int) – The ID of the manifest’s associated depot.

Return type:

await friend_thoughts()¶

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

Return type:: tuple[list[steam.Friend], list[steam.Friend]]

await friends_who_own()¶

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

Return type:: list[steam.Friend]

await info()¶

Shorthand for:

(info,) = await client.fetch_product_info(games=[game])

Return type:: steam.GameInfo

is_steam_game()¶

Whether the game could be a Steam game.

Return type:: bool

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

An AsyncIterator for accessing a steam.Game’s steam.Manifests.

Examples

Usage:

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

Flattening into a list:

manifests = await game.manifests(limit=50).flatten()
# manifests is now a list of Manifest

All parameters are optional.

Parameters:

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

Yields:

await player_count()¶

The games 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 AsyncIterator for accessing a game’s steam.PublishedFiles.

Examples

Usage:

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

Flattening into a list:

published_files = await game.published_files(limit=50).flatten()
# published_files is now a list of PublishedFile

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 (Optional[Language]) – The language to fetch the published files in. If None the current language is used.
limit (Optional[int]) – The maximum number of published files to search through. Default is 100. Setting this to None will fetch all the game’s published files, but this will be a very slow operation.
before (Optional[datetime]) – A time to search for published files before.
after (Optional[datetime]) – A time to search for published files after.

Yields:

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

Review a game.

Parameters:

content (str) – The content of the review.
recommend (bool) – Whether you recommended the game.
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 (Optional[Language]) – The language the review is in.

Return type:

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

An AsyncIterator for accessing a steam.Game’s steam.Reviews.

Examples

Usage:

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

Flattening into a list:

reviews = await game.reviews(limit=50).flatten()
# reviews is now a list of Review

All parameters are optional.

Parameters:

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

Yields:

property title: str | None¶: The game’s name.

Deprecated since version 0.8.0: Use name instead.

property url: str¶: What should be the game’s url on steamcommunity if applicable.

await packages(*, languages=None)¶

Fetch the game’s packages.

Parameters:: language – The language to fetch the packages in. If None, the current language will be used.
Return type:: list[steam.FetchedGamePackage]

is_free()¶

Whether the game is free to download.

Return type:: bool

is_on_windows()¶

Whether the game is playable on Windows.

Return type:: bool

is_on_mac_os()¶

Whether the game is playable on macOS.

Return type:: bool

is_on_linux()¶

Whether the game is playable on Linux.

Return type:: bool

Attributes

created_at
logo_url
price_overview
title
url

Methods

asyncadd_free_licenses
asyncclan
asyncdlc
asyncfetch
asyncfetch_manifest
asyncfriend_thoughts
asyncfriends_who_own
asyncinfo
defis_free
defis_on_linux
defis_on_mac_os
defis_on_windows
defis_steam_game
async formanifests
asyncpackages
asyncplayer_count
async forpublished_files
asyncreview
async forreviews

class steam.DLC¶

Represents DLC (downloadable content) for a game.

created_at¶

The time the DLC was released at.

Type:: datetime.datetime

logo_url¶

The logo url of the DLC.

Type:: str

price_overview¶

A price overview for the DLC.

Type:: steam.game.PartialGamePriceOverview

is_free()¶

Whether the game is free to download.

Return type:: bool

is_on_windows()¶

Whether the game is playable on Windows.

Return type:: bool

is_on_mac_os()¶

Whether the game is playable on macOS.

Return type:: bool

is_on_linux()¶

Whether the game is playable on Linux.

Return type:: bool

await add_free_licenses()¶

Request the free licenses for this game.

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

await clan()¶

Fetch this game’s clan.

This can be useful to get a Game’s updates.

clan = await game.clan()
async for update in clan.announcements().filter(
    lambda announcement: announcement.type in (steam.ClanEvent.MajorUpdate, steam.ClanEvent.SmallUpdate)
):
    ...  # do something with the update

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

await dlc(*, language=None)¶

Fetch the game’s DLC.

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

await fetch(*, language=None)¶

Shorthand for:

game = await client.fetch_game(game)

Return type:: steam.FetchedGame

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

Fetch a CDN manifest for a game.

Parameters:

id (int) – The ID of the manifest to fetch.
depot_id (int) – The ID of the manifest’s associated depot.

Return type:

await friend_thoughts()¶

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

Return type:: tuple[list[steam.Friend], list[steam.Friend]]

await friends_who_own()¶

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

Return type:: list[steam.Friend]

await info()¶

Shorthand for:

(info,) = await client.fetch_product_info(games=[game])

Return type:: steam.GameInfo

is_steam_game()¶

Whether the game could be a Steam game.

Return type:: bool

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

An AsyncIterator for accessing a steam.Game’s steam.Manifests.

Examples

Usage:

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

Flattening into a list:

manifests = await game.manifests(limit=50).flatten()
# manifests is now a list of Manifest

All parameters are optional.

Parameters:

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

Yields:

await packages(*, language=None)¶

Fetch the game’s packages.

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

await player_count()¶

The games 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 AsyncIterator for accessing a game’s steam.PublishedFiles.

Examples

Usage:

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

Flattening into a list:

published_files = await game.published_files(limit=50).flatten()
# published_files is now a list of PublishedFile

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 (Optional[Language]) – The language to fetch the published files in. If None the current language is used.
limit (Optional[int]) – The maximum number of published files to search through. Default is 100. Setting this to None will fetch all the game’s published files, but this will be a very slow operation.
before (Optional[datetime]) – A time to search for published files before.
after (Optional[datetime]) – A time to search for published files after.

Yields:

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

Review a game.

Parameters:

content (str) – The content of the review.
recommend (bool) – Whether you recommended the game.
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 (Optional[Language]) – The language the review is in.

Return type:

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

An AsyncIterator for accessing a steam.Game’s steam.Reviews.

Examples

Usage:

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

Flattening into a list:

reviews = await game.reviews(limit=50).flatten()
# reviews is now a list of Review

All parameters are optional.

Parameters:

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

Yields: