Services and methods

This page lists every method of every service in the Go SDK, with the REST API and docs each one maps to. For what parameters and returned fields mean, see each API's docs; for how parameters and results map to Go types, see Calling the API.

What the columns mean:

Method: the service name is left out, so Get(ctx, username) in the Users section is client.Users.Get(ctx, username). Capitalized parameters are types (such as UpdateUserParams); the rest are parameter names.
Result: what's returned on success; — means only error is returned. The last return value of every method is error (except iterator methods, which return iter.Seq2 and yield errors during iteration).
API: the HTTP method and path (without the /{org_name}/{app_name} prefix), and the API name. The API name appears in errors' Op, in logs, in hooks' RequestInfo.Op and in Client.Stats(), and drimtest's fake server sets responses by it.
Category: decides whether network errors, timeouts and 5xx are retried automatically; see Retries and idempotency:

Category	Retried automatically
Query	Yes
Dedup ID	Yes, with the same `client_msg_id`
Unique key	Yes; if a retry gets `already_exists`, the error's `Retried` is `true`
Idempotent	Yes; if a retry gets `not_found` or `version_conflict`, the error's `Retried` is `true`
Not idempotent	No (when the request may already have been sent)

Rate-limited requests weren't executed, so every category is resent after waiting; see Rate limits. The SDK gets the App Token itself (API name app.token), so there's no method for it; see Getting and caching the App Token.

Users: client.Users

Users, sign-in tickets, signed-in devices and global mutes.

Method	Result	API	Category	Docs
`ListMuted(ctx, ListMutedParams)`	`*Page[UserMute]`	`GET /mutes` `users.list_muted`	Query	List muted users
`AllMuted(ctx, ListMutedParams)`	`iter.Seq2[UserMute, error]`	Same as `ListMuted`, auto-paging	Query	List muted users
`Create(ctx, CreateUserParams)`	`*User`	`POST /users` `users.create`	Unique key	Create a user
`List(ctx, ListUsersParams)`	`*Page[User]`	`GET /users` `users.list`	Query	List users
`All(ctx, ListUsersParams)`	`iter.Seq2[User, error]`	Same as `List`, auto-paging	Query	List users
`BatchCreate(ctx, []CreateUserParams)`	`*BatchCreateUsersResult`	`POST /users/batch` `users.batch_create`	Unique key	Create users in batches
`BatchCreateAll(ctx, []CreateUserParams)`	`*BatchCreateUsersResult`	Same as `BatchCreate`, split into batches of 100, submitted in turn, results merged	Unique key	Create users in batches
`Lookup(ctx, usernames)`	`[]User`	`POST /users/lookup` `users.lookup`	Query	Look up users by username
`Get(ctx, username)`	`*User`	`GET /users/{username}` `users.get`	Query	Get a user
`Update(ctx, username, UpdateUserParams)`	`*User`	`PATCH /users/{username}` `users.update`	Idempotent	Update a user's profile
`Delete(ctx, username)`	—	`DELETE /users/{username}` `users.delete`	Idempotent	Delete a user
`Disable(ctx, username, DisableUserParams)`	`*User`	`POST /users/{username}/disable` `users.disable`	Idempotent	Ban a user
`Enable(ctx, username)`	`*User`	`POST /users/{username}/enable` `users.enable`	Idempotent	Unban a user
`IssueLoginTicket(ctx, username, IssueLoginTicketParams)`	`*LoginTicket`	`POST /users/{username}/login-tickets` `users.issue_login_ticket`	Idempotent	Issue a sign-in ticket
`Mutes(ctx, username)`	`[]UserMute`	`GET /users/{username}/mutes` `users.mutes`	Query	Get a user's mutes
`Mute(ctx, username, scope, MuteParams)`	`*UserMute`	`PUT /users/{username}/mutes/{scope}` `users.mute`	Idempotent	Mute a user
`Unmute(ctx, username, scope)`	—	`DELETE /users/{username}/mutes/{scope}` `users.unmute`	Idempotent	Unmute a user
`SetPassword(ctx, username, password)`	—	`PUT /users/{username}/password` `users.set_password`	Not idempotent	Set a password
`Sessions(ctx, username)`	`[]Session`	`GET /users/{username}/sessions` `users.sessions`	Query	List devices
`KickAll(ctx, username)`	—	`DELETE /users/{username}/sessions` `users.kick_all`	Not idempotent	Sign out all devices
`Kick(ctx, username, sessionID)`	—	`DELETE /users/{username}/sessions/{session_id}` `users.kick`	Idempotent	Sign out one device

Friends: client.Friends

Friends, friend requests and how others can add the user.

Method	Result	API	Category	Docs
`Requests(ctx, username, ListFriendRequestsParams)`	`*Page[FriendRequest]`	`GET /users/{username}/friend-requests` `friends.requests`	Query	Query friend requests
`AllRequests(ctx, username, ListFriendRequestsParams)`	`iter.Seq2[FriendRequest, error]`	Same as `Requests`, auto-paging	Query	Query friend requests
`Settings(ctx, username)`	`*FriendSettings`	`GET /users/{username}/friend-settings` `friends.settings`	Query	Get the friend add mode
`SetSettings(ctx, username, Field[string])`	`*FriendSettings`	`PUT /users/{username}/friend-settings` `friends.set_settings`	Idempotent	Set the friend add mode
`List(ctx, username, ListFriendsParams)`	`*VersionedPage[Friend]`	`GET /users/{username}/friends` `friends.list`	Query	List friends
`All(ctx, username, ListFriendsParams)`	`iter.Seq2[Friend, error]`	Same as `List`, auto-paging	Query	List friends
`DeleteAll(ctx, username)`	`int`	`DELETE /users/{username}/friends` `friends.delete_all`	Idempotent	Remove all friends
`BatchAdd(ctx, username, []AddFriendItem)`	`*BatchAddFriendsResult`	`POST /users/{username}/friends/batch` `friends.batch_add`	Idempotent	Add friends in batches
`BatchAddAll(ctx, username, []AddFriendItem)`	`*BatchAddFriendsResult`	Same as `BatchAdd`, split into batches of 100, submitted in turn, results merged	Idempotent	Add friends in batches
`BatchDelete(ctx, username, usernames)`	`*BatchDeleteFriendsResult`	`POST /users/{username}/friends/batch-delete` `friends.batch_delete`	Idempotent	Remove friends in batches
`Check(ctx, username, usernames)`	`[]FriendCheck`	`POST /users/{username}/friends/check` `friends.check`	Query	Check relationships
`Get(ctx, username, friend)`	`*Friend`	`GET /users/{username}/friends/{friend}` `friends.get`	Query	Get a friend
`Add(ctx, username, friend, AddFriendParams)`	`*FriendChange`	`PUT /users/{username}/friends/{friend}` `friends.add`	Idempotent	Add a friend
`Update(ctx, username, friend, UpdateFriendParams)`	`*FriendChange`	`PATCH /users/{username}/friends/{friend}` `friends.update`	Idempotent	Update a friend's remark and custom attributes
`Delete(ctx, username, friend)`	`*FriendChange`	`DELETE /users/{username}/friends/{friend}` `friends.delete`	Idempotent	Remove a friend

Blocklist: client.Blacklist

Users' blocklists.

Method	Result	API	Category	Docs
`List(ctx, username, ListBlacklistParams)`	`*VersionedPage[BlacklistEntry]`	`GET /users/{username}/blacklist` `blacklist.list`	Query	Get the block list
`All(ctx, username, ListBlacklistParams)`	`iter.Seq2[BlacklistEntry, error]`	Same as `List`, auto-paging	Query	Get the block list
`BatchAdd(ctx, username, usernames)`	`*BatchBlacklistResult`	`POST /users/{username}/blacklist/batch` `blacklist.batch_add`	Idempotent	Block in batches
`BatchRemove(ctx, username, usernames)`	`*BatchBlacklistResult`	`POST /users/{username}/blacklist/batch-delete` `blacklist.batch_remove`	Idempotent	Unblock in batches
`Add(ctx, username, target)`	`*BlacklistChange`	`PUT /users/{username}/blacklist/{target}` `blacklist.add`	Idempotent	Block a user
`Remove(ctx, username, target)`	`*BlacklistChange`	`DELETE /users/{username}/blacklist/{target}` `blacklist.remove`	Idempotent	Unblock a user

Groups: client.Groups

Groups, group members, group block lists, join requests and users' group settings.

Method	Result	API	Category	Docs
`Create(ctx, CreateGroupParams)`	`*CreateGroupResult`	`POST /groups` `groups.create`	Not idempotent	Create a group
`List(ctx, ListGroupsParams)`	`*Page[Group]`	`GET /groups` `groups.list`	Query	List groups
`All(ctx, ListGroupsParams)`	`iter.Seq2[Group, error]`	Same as `List`, auto-paging	Query	List groups
`Get(ctx, groupID)`	`*Group`	`GET /groups/{group_id}` `groups.get`	Query	Get a group
`Update(ctx, groupID, UpdateGroupParams)`	`*GroupChange`	`PATCH /groups/{group_id}` `groups.update`	Idempotent	Update a group's profile and settings
`Delete(ctx, groupID, reason)`	—	`DELETE /groups/{group_id}` `groups.delete`	Idempotent	Dissolve a group
`Blacklist(ctx, groupID, ListOptions)`	`*Page[GroupBlacklistEntry]`	`GET /groups/{group_id}/blacklist` `groups.blacklist`	Query	List the group block list
`AllBlacklist(ctx, groupID, ListOptions)`	`iter.Seq2[GroupBlacklistEntry, error]`	Same as `Blacklist`, auto-paging	Query	List the group block list
`AddToBlacklist(ctx, groupID, username, reason)`	`*GroupBlacklistChange`	`PUT /groups/{group_id}/blacklist/{username}` `groups.add_to_blacklist`	Idempotent	Add a user to the group block list
`RemoveFromBlacklist(ctx, groupID, username)`	`*GroupBlacklistChange`	`DELETE /groups/{group_id}/blacklist/{username}` `groups.remove_from_blacklist`	Idempotent	Remove a user from the group block list
`Disable(ctx, groupID, reason)`	`*GroupChange`	`POST /groups/{group_id}/disable` `groups.disable`	Idempotent	Ban a group
`Enable(ctx, groupID)`	`*GroupChange`	`POST /groups/{group_id}/enable` `groups.enable`	Idempotent	Unban a group
`Members(ctx, groupID, ListMembersParams)`	`*VersionedPage[GroupMember]`	`GET /groups/{group_id}/members` `groups.members`	Query	List group members
`AllMembers(ctx, groupID, ListMembersParams)`	`iter.Seq2[GroupMember, error]`	Same as `Members`, auto-paging	Query	List group members
`AddMembers(ctx, groupID, usernames)`	`*GroupMembersResult`	`POST /groups/{group_id}/members/batch` `groups.add_members`	Idempotent	Add group members
`RemoveMembers(ctx, groupID, usernames)`	`*GroupMembersResult`	`POST /groups/{group_id}/members/batch-delete` `groups.remove_members`	Idempotent	Remove group members
`Member(ctx, groupID, username)`	`*GroupMember`	`GET /groups/{group_id}/members/{username}` `groups.member`	Query	Get a member
`UpdateMember(ctx, groupID, username, UpdateMemberParams)`	`*GroupMemberChange`	`PATCH /groups/{group_id}/members/{username}` `groups.update_member`	Idempotent	Update a member
`MuteMember(ctx, groupID, username, durationSeconds)`	`*GroupMemberChange`	`PUT /groups/{group_id}/members/{username}/mute` `groups.mute_member`	Idempotent	Mute a member
`UnmuteMember(ctx, groupID, username)`	`*GroupMemberChange`	`DELETE /groups/{group_id}/members/{username}/mute` `groups.unmute_member`	Idempotent	Unmute a member
`SetRole(ctx, groupID, username, role)`	`*GroupMemberChange`	`PUT /groups/{group_id}/members/{username}/role` `groups.set_role`	Idempotent	Set a member's role
`SetMuteAll(ctx, groupID, on)`	`*GroupChange`	`PUT /groups/{group_id}/mute-all` `DELETE /groups/{group_id}/mute-all` `groups.mute_all`、`groups.unmute_all`	Idempotent	Turn on mute-all、Turn off mute-all
`TransferOwner(ctx, groupID, username)`	`*GroupChange`	`PUT /groups/{group_id}/owner` `groups.transfer_owner`	Idempotent	Transfer ownership
`Requests(ctx, groupID, ListGroupRequestsParams)`	`*Page[GroupRequest]`	`GET /groups/{group_id}/requests` `groups.requests`	Query	Query join requests and invitations
`AllRequests(ctx, groupID, ListGroupRequestsParams)`	`iter.Seq2[GroupRequest, error]`	Same as `Requests`, auto-paging	Query	Query join requests and invitations
`InviteSettings(ctx, username)`	`*GroupInviteSettings`	`GET /users/{username}/group-settings` `groups.invite_settings`	Query	Get a user's group settings
`SetInviteSettings(ctx, username, Field[string])`	`*GroupInviteSettings`	`PUT /users/{username}/group-settings` `groups.set_invite_settings`	Idempotent	Change a user's group settings
`OfUser(ctx, username, ListOptions)`	`*Page[UserGroup]`	`GET /users/{username}/groups` `groups.of_user`	Query	List a user's groups
`AllOfUser(ctx, username, ListOptions)`	`iter.Seq2[UserGroup, error]`	Same as `OfUser`, auto-paging	Query	List a user's groups

Messages: client.Messages

Sending, querying, exporting, recalling, editing and pinning messages.

Method	Result	API	Category	Docs
`Send(ctx, SendMessageParams)`	`*SendResult`	`POST /messages` `messages.send`	Dedup ID (not idempotent when online-only)	Send a message
`Export(ctx, ExportParams)`	`*ExportPage`	`GET /messages` `messages.export`	Query	Export the app's messages
`ExportAll(ctx, ExportParams)`	`iter.Seq2[Message, error]`	Same as `Export`, auto-paging	Query	Export the app's messages
`BatchSend(ctx, BatchSendParams)`	`*BatchSendResult`	`POST /messages/batch` `messages.batch_send`	Dedup ID	Send in batches
`BatchSendAll(ctx, BatchSendParams)`	`*BatchSendResult`	Same as `BatchSend`, split into batches of 1000, submitted in turn, results merged	Dedup ID	Send in batches
`BatchRecall(ctx, messageIDs, reason)`	`*BatchRecallResult`	`POST /messages/batch-recall` `messages.batch_recall`	Idempotent	Recall in batches
`Get(ctx, messageID)`	`*Message`	`GET /messages/{message_id}` `messages.get`	Query	Query a single message
`Edit(ctx, messageID, EditMessageParams)`	`*MessageChange`	`PATCH /messages/{message_id}` `messages.edit`	Idempotent	Edit a message
`Pin(ctx, messageID, reason)`	`*MessageChange`	`PUT /messages/{message_id}/pin` `messages.pin`	Idempotent	Pin a message
`Unpin(ctx, messageID, reason)`	`*MessageChange`	`DELETE /messages/{message_id}/pin` `messages.unpin`	Idempotent	Unpin a message
`Recall(ctx, messageID, reason)`	`*MessageChange`	`POST /messages/{message_id}/recall` `messages.recall`	Idempotent	Recall a message
`SentBy(ctx, username, SentByParams)`	`*Page[Message]`	`GET /users/{username}/sent-messages` `messages.sent_by`	Query	Query a user's sent messages
`AllSentBy(ctx, username, SentByParams)`	`iter.Seq2[Message, error]`	Same as `SentBy`, auto-paging	Query	Query a user's sent messages

Conversations: client.Conversations

Conversation info, conversation messages, and managing users' conversation state and unread counts on their behalf.

Method	Result	API	Category	Docs
`Get(ctx, conversationID)`	`*ConversationInfo`	`GET /conversations/{conversation_id}` `conversations.get`	Query	Get conversation info
`Messages(ctx, conversationID, SeqParams)`	`*SeqPage`	`GET /conversations/{conversation_id}/messages` `conversations.messages`	Query	Fetch a conversation's history
`AllMessages(ctx, conversationID, SeqParams)`	`iter.Seq2[Message, error]`	Same as `Messages`, auto-paging (no `AroundSeq`)	Query	Fetch a conversation's history
`Pins(ctx, conversationID, cursor)`	`*Page[Message]`	`GET /conversations/{conversation_id}/pins` `conversations.pins`	Query	List pinned messages in a conversation
`AllPins(ctx, conversationID)`	`iter.Seq2[Message, error]`	Same as `Pins`, auto-paging	Query	List pinned messages in a conversation
`Single(ctx, username, peer)`	`*ConversationInfo`	`GET /single-conversations/{username}/{peer}` `conversations.single`	Query	Get the one-to-one conversation between two users
`OfUser(ctx, username, ListOptions)`	`*Page[ConversationState]`	`GET /users/{username}/conversations` `conversations.of_user`	Query	List a user's conversations
`AllOfUser(ctx, username, ListOptions)`	`iter.Seq2[ConversationState, error]`	Same as `OfUser`, auto-paging	Query	List a user's conversations
`MarkAllRead(ctx, username)`	`*MarkAllReadResult`	`POST /users/{username}/conversations/read-all` `conversations.mark_all_read`	Idempotent	Mark everything as read
`StateOfUser(ctx, username, conversationID)`	`*ConversationState`	`GET /users/{username}/conversations/{conversation_id}` `conversations.state_of_user`	Query	Get one of a user's conversations
`Delete(ctx, username, conversationID, clearMessages)`	`*ConversationStateChange`	`DELETE /users/{username}/conversations/{conversation_id}` `conversations.delete`	Idempotent	Delete a conversation
`Clear(ctx, username, conversationID)`	`*ConversationStateChange`	`POST /users/{username}/conversations/{conversation_id}/clear` `conversations.clear`	Idempotent	Clear chat history
`DeleteMessages(ctx, username, conversationID, seqs)`	`*DeleteMessagesResult`	`POST /users/{username}/conversations/{conversation_id}/messages/delete` `conversations.delete_messages`	Idempotent	Delete messages
`MarkRead(ctx, username, conversationID, seq)`	`*ConversationStateChange`	`POST /users/{username}/conversations/{conversation_id}/read` `conversations.mark_read`	Idempotent	Mark a conversation as read
`UnreadCount(ctx, username)`	`*UnreadCount`	`GET /users/{username}/unread-count` `conversations.unread_count`	Query	Get a user's total unread count

Files: client.Media

Uploading, downloading, querying and deleting files. In Upload and ResumeUpload, r is an io.ReaderAt and size is the byte count; in Download, w is an io.Writer.

Method	Result	API	Category	Docs
`Upload(ctx, r, size, UploadParams)`	`*File`	Creates the upload, uploads the content and completes it; see Uploading and downloading files `media.upload`, `media.upload_part`	Not idempotent	Upload files
`ResumeUpload(ctx, fileID, r, size, UploadParams)`	`*File`	Checks uploaded parts, uploads what's missing and completes; see Resuming uploads	Idempotent	Upload files
`Download(ctx, url, w)`	`int64`	Gets a download address, then downloads; see Download `media.download`	Query	Get download addresses
`DownloadURLs(ctx, urls)`	`[]DownloadURLItem`	`POST /media/download-urls` `media.download_urls`	Query	Get download addresses
`File(ctx, fileID)`	`*File`	`GET /media/files/{file_id}` `media.file`	Query	Get a file
`DeleteFile(ctx, fileID)`	—	`DELETE /media/files/{file_id}` `media.delete_file`	Idempotent	Delete a file
`GroupFiles(ctx, groupID, ListOptions)`	`*GroupFilesPage`	`GET /media/groups/{group_id}/files` `media.group_files`	Query	List group files
`AllGroupFiles(ctx, groupID, ListOptions)`	`iter.Seq2[File, error]`	Same as `GroupFiles`, auto-paging	Query	List group files
`CreateUpload(ctx, CreateUploadParams)`	`*UploadSession`	`POST /media/uploads` `media.create_upload`	Not idempotent	Create an upload
`CancelUpload(ctx, fileID)`	—	`DELETE /media/uploads/{file_id}` `media.cancel_upload`	Idempotent	Cancel an upload
`CompleteUpload(ctx, fileID)`	`*File`	`POST /media/uploads/{file_id}/complete` `media.complete_upload`	Idempotent	Complete the upload
`PartURLs(ctx, fileID, partNumbers)`	`[]PartURL`	`POST /media/uploads/{file_id}/parts` `media.part_urls`	Query	Get part upload addresses
`UploadedParts(ctx, fileID)`	`[]UploadedPart`	`GET /media/uploads/{file_id}/parts` `media.uploaded_parts`	Query	List uploaded parts
`Usage(ctx)`	`*MediaUsage`	`GET /media/usage` `media.usage`	Query	Get storage usage

Push: client.Push

Push settings, conversation Do Not Disturb and push devices.

Method	Result	API	Category	Docs
`Devices(ctx, username)`	`[]PushDevice`	`GET /users/{username}/push-devices` `push.devices`	Query	List push devices
`UnbindDevice(ctx, username, sessionID)`	—	`DELETE /users/{username}/push-devices/{session_id}` `push.unbind_device`	Idempotent	Unbind a push device
`Settings(ctx, username)`	`*PushSettings`	`GET /users/{username}/push-settings` `push.settings`	Query	Get push settings
`UpdateSettings(ctx, username, UpdatePushSettingsParams)`	`*PushSettingsChange`	`PATCH /users/{username}/push-settings` `push.update_settings`	Idempotent	Update push settings
`Mutes(ctx, username, ListPushMutesParams)`	`*VersionedPage[ConversationMute]`	`GET /users/{username}/push-settings/conversations` `push.mutes`	Query	List conversation Do Not Disturb
`AllMutes(ctx, username, ListPushMutesParams)`	`iter.Seq2[ConversationMute, error]`	Same as `Mutes`, auto-paging	Query	List conversation Do Not Disturb
`MuteGroup(ctx, username, groupID, MuteConversationParams)`	`*ConversationMuteChange`	`PUT /users/{username}/push-settings/conversations/group/{group_id}` `push.mute_group`	Idempotent	Set conversation Do Not Disturb
`UnmuteGroup(ctx, username, groupID)`	`*ConversationUnmuteChange`	`DELETE /users/{username}/push-settings/conversations/group/{group_id}` `push.unmute_group`	Idempotent	Remove conversation Do Not Disturb
`MuteSingle(ctx, username, peer, MuteConversationParams)`	`*ConversationMuteChange`	`PUT /users/{username}/push-settings/conversations/single/{peer}` `push.mute_single`	Idempotent	Set conversation Do Not Disturb
`UnmuteSingle(ctx, username, peer)`	`*ConversationUnmuteChange`	`DELETE /users/{username}/push-settings/conversations/single/{peer}` `push.unmute_single`	Idempotent	Remove conversation Do Not Disturb

Chat rooms: client.Chatrooms

Chat rooms, members, mutes, bans, allowlists, attributes and messages.

Method	Result	API	Category	Docs
`Create(ctx, CreateChatroomParams)`	`*Chatroom`	`POST /chatrooms` `chatrooms.create`	Not idempotent	Create a chat room
`List(ctx, ListChatroomsParams)`	`*Page[Chatroom]`	`GET /chatrooms` `chatrooms.list`	Query	List chat rooms
`All(ctx, ListChatroomsParams)`	`iter.Seq2[Chatroom, error]`	Same as `List`, auto-paging	Query	List chat rooms
`OnlineCounts(ctx, roomIDs)`	`[]RoomOnlineCount`	`POST /chatrooms/online-counts` `chatrooms.online_counts`	Query	Get online counts in batches
`Get(ctx, roomID)`	`*Chatroom`	`GET /chatrooms/{room_id}` `chatrooms.get`	Query	Get a chat room
`Update(ctx, roomID, UpdateChatroomParams)`	`*ChatroomChange`	`PATCH /chatrooms/{room_id}` `chatrooms.update`	Idempotent	Update a chat room's profile
`Delete(ctx, roomID)`	—	`DELETE /chatrooms/{room_id}` `chatrooms.delete`	Idempotent	Dissolve a chat room
`SetAdmin(ctx, roomID, username)`	`*RoomAdminChange`	`PUT /chatrooms/{room_id}/admins/{username}` `chatrooms.set_admin`	Idempotent	Set an admin
`RemoveAdmin(ctx, roomID, username)`	`*RoomAdminChange`	`DELETE /chatrooms/{room_id}/admins/{username}` `chatrooms.remove_admin`	Idempotent	Remove an admin
`Allowlist(ctx, roomID, ListOptions)`	`*Page[RoomAllowlistEntry]`	`GET /chatrooms/{room_id}/allowlist` `chatrooms.allowlist`	Query	List the allowlist
`AllAllowlist(ctx, roomID, ListOptions)`	`iter.Seq2[RoomAllowlistEntry, error]`	Same as `Allowlist`, auto-paging	Query	List the allowlist
`AddToAllowlist(ctx, roomID, usernames)`	`*RoomBatchResult`	`POST /chatrooms/{room_id}/allowlist` `chatrooms.add_to_allowlist`	Idempotent	Add to the allowlist
`RemoveFromAllowlist(ctx, roomID, usernames)`	`*RoomBatchResult`	`POST /chatrooms/{room_id}/allowlist/batch-delete` `chatrooms.remove_from_allowlist`	Idempotent	Remove from the allowlist
`Attributes(ctx, roomID, keys...)`	`*RoomAttributes`	`GET /chatrooms/{room_id}/attributes` `chatrooms.attributes`	Query	Get chat room attributes
`SetAttributes(ctx, roomID, attributes)`	`*RoomAttributesChange`	`PUT /chatrooms/{room_id}/attributes` `chatrooms.set_attributes`	Idempotent	Set chat room attributes
`RemoveAttributes(ctx, roomID, keys)`	`*RoomAttributesChange`	`POST /chatrooms/{room_id}/attributes/batch-delete` `chatrooms.remove_attributes`	Idempotent	Delete chat room attributes
`Bans(ctx, roomID, ListOptions)`	`*Page[RoomBan]`	`GET /chatrooms/{room_id}/bans` `chatrooms.bans`	Query	List bans
`AllBans(ctx, roomID, ListOptions)`	`iter.Seq2[RoomBan, error]`	Same as `Bans`, auto-paging	Query	List bans
`Ban(ctx, roomID, usernames, RoomPenaltyParams)`	`*RoomBatchResult`	`POST /chatrooms/{room_id}/bans` `chatrooms.ban`	Idempotent	Ban users
`Unban(ctx, roomID, usernames)`	`*RoomBatchResult`	`POST /chatrooms/{room_id}/bans/batch-delete` `chatrooms.unban`	Idempotent	Unban users
`Disable(ctx, roomID, reason)`	`*ChatroomChange`	`POST /chatrooms/{room_id}/disable` `chatrooms.disable`	Idempotent	Ban a chat room
`Enable(ctx, roomID)`	`*ChatroomChange`	`POST /chatrooms/{room_id}/enable` `chatrooms.enable`	Idempotent	Unban a chat room
`Members(ctx, roomID, ListOptions)`	`*Page[RoomMember]`	`GET /chatrooms/{room_id}/members` `chatrooms.members`	Query	List chat room members
`AllMembers(ctx, roomID, ListOptions)`	`iter.Seq2[RoomMember, error]`	Same as `Members`, auto-paging	Query	List chat room members
`Kick(ctx, roomID, usernames)`	`*RoomBatchResult`	`POST /chatrooms/{room_id}/members/batch-delete` `chatrooms.kick`	Idempotent	Remove chat room members
`Member(ctx, roomID, username)`	`*RoomMemberState`	`GET /chatrooms/{room_id}/members/{username}` `chatrooms.member`	Query	Check whether a user is in the room
`Send(ctx, roomID, SendRoomMessageParams)`	`*RoomSendResult`	`POST /chatrooms/{room_id}/messages` `chatrooms.send`	Dedup ID (not idempotent at low priority)	Send a chat room message
`RecentMessages(ctx, roomID, limit)`	`[]RoomMessage`	`GET /chatrooms/{room_id}/messages` `chatrooms.recent_messages`	Query	Query recent messages
`Recall(ctx, roomID, messageID, reason)`	`*RoomRecallResult`	`POST /chatrooms/{room_id}/messages/{message_id}/recall` `chatrooms.recall`	Idempotent	Recall a chat room message
`SetMuteAll(ctx, roomID, on)`	`*ChatroomChange`	`PUT /chatrooms/{room_id}/mute-all` `DELETE /chatrooms/{room_id}/mute-all` `chatrooms.mute_all`、`chatrooms.unmute_all`	Idempotent	Turn on mute-all、Turn off mute-all
`Mutes(ctx, roomID, ListOptions)`	`*Page[RoomMute]`	`GET /chatrooms/{room_id}/mutes` `chatrooms.mutes`	Query	List mutes
`AllMutes(ctx, roomID, ListOptions)`	`iter.Seq2[RoomMute, error]`	Same as `Mutes`, auto-paging	Query	List mutes
`Mute(ctx, roomID, usernames, RoomPenaltyParams)`	`*RoomBatchResult`	`POST /chatrooms/{room_id}/mutes` `chatrooms.mute`	Idempotent	Mute users
`Unmute(ctx, roomID, usernames)`	`*RoomBatchResult`	`POST /chatrooms/{room_id}/mutes/batch-delete` `chatrooms.unmute`	Idempotent	Unmute users
`TransferOwner(ctx, roomID, Field[string])`	`*ChatroomChange`	`PUT /chatrooms/{room_id}/owner` `chatrooms.transfer_owner`	Idempotent	Transfer ownership

Content moderation: client.Moderation

Config, word lists, moderation items, violations and reports. handle in ProcessPending is func(ctx, ModerationItem, ItemContent) (*Decision, error).

Method	Result	API	Category	Docs
`ProcessPending(ctx, ProcessOptions, handle)`	`int`	Goes through pending moderation items, reads their content and acts on `handle`'s decision; see Process pending moderation items	Idempotent	Review items and violations
`Config(ctx)`	`*ModerationConfig`	`GET /moderation/config` `moderation.config`	Query	Get moderation config
`UpdateConfig(ctx, UpdateModerationConfigParams)`	`*ModerationConfig`	`PATCH /moderation/config` `moderation.update_config`	Idempotent	Update moderation config
`Items(ctx, ListItemsParams)`	`*Page[ModerationItem]`	`GET /moderation/items` `moderation.items`	Query	List review items
`AllItems(ctx, ListItemsParams)`	`iter.Seq2[ModerationItem, error]`	Same as `Items`, auto-paging	Query	List review items
`BatchDecide(ctx, BatchDecideParams)`	`*BatchDecideResult`	`POST /moderation/items/batch-decide` `moderation.batch_decide`	Idempotent	Batch decide
`Item(ctx, itemID)`	`*ModerationItem`	`GET /moderation/items/{item_id}` `moderation.item`	Query	Get a review item
`ItemContent(ctx, itemID)`	`*ItemContent`	`GET /moderation/items/{item_id}/content` `moderation.item_content`	Query	Read an item's content
`Decide(ctx, itemID, DecideParams)`	`*ModerationItem`	`POST /moderation/items/{item_id}/decide` `moderation.decide`	Idempotent (not idempotent with an action and no `Version`)	Decide
`Escalate(ctx, itemID, note)`	`*ModerationItem`	`POST /moderation/items/{item_id}/escalate` `moderation.escalate`	Not idempotent	Escalate to the platform
`PlatformActions(ctx, ListOptions)`	`*Page[PlatformAction]`	`GET /moderation/platform-actions` `moderation.platform_actions`	Query	List platform actions
`AllPlatformActions(ctx, ListOptions)`	`iter.Seq2[PlatformAction, error]`	Same as `PlatformActions`, auto-paging	Query	List platform actions
`Report(ctx, ReportParams)`	`*ReportResult`	`POST /moderation/reports` `moderation.report`	Idempotent	Report on a user's behalf
`Stats(ctx, ModerationStatsParams)`	`*ModerationStats`	`GET /moderation/stats` `moderation.stats`	Query	Get statistics
`CheckText(ctx, CheckTextParams)`	`*TextCheckResult`	`POST /moderation/text-check` `moderation.check_text`	Query	Check text
`Violations(ctx, username, ListOptions)`	`*ViolationsPage`	`GET /moderation/users/{username}/violations` `moderation.violations`	Query	Get a user's violations
`AllViolations(ctx, username, ListOptions)`	`iter.Seq2[Violation, error]`	Same as `Violations`, auto-paging	Query	Get a user's violations
`ClearViolations(ctx, username, reason)`	`int`	`DELETE /moderation/users/{username}/violations` `moderation.clear_violations`	Idempotent	Clear a user's violations
`WordLists(ctx)`	`[]WordList`	`GET /moderation/word-lists` `moderation.word_lists`	Query	List word lists
`CreateWordList(ctx, CreateWordListParams)`	`*WordList`	`POST /moderation/word-lists` `moderation.create_word_list`	Not idempotent	Create a word list
`WordList(ctx, listID)`	`*WordList`	`GET /moderation/word-lists/{list_id}` `moderation.word_list`	Query	Get a word list
`UpdateWordList(ctx, listID, UpdateWordListParams)`	`*WordList`	`PATCH /moderation/word-lists/{list_id}` `moderation.update_word_list`	Idempotent	Update a word list
`DeleteWordList(ctx, listID)`	—	`DELETE /moderation/word-lists/{list_id}` `moderation.delete_word_list`	Idempotent	Delete a word list
`Words(ctx, listID, ListWordsParams)`	`*Page[Word]`	`GET /moderation/word-lists/{list_id}/words` `moderation.words`	Query	List words
`AllWords(ctx, listID, ListWordsParams)`	`iter.Seq2[Word, error]`	Same as `Words`, auto-paging	Query	List words
`AddWords(ctx, listID, words)`	`*AddWordsResult`	`POST /moderation/word-lists/{list_id}/words/batch` `moderation.add_words`	Idempotent	Add words
`RemoveWords(ctx, listID, words)`	`int`	`POST /moderation/word-lists/{list_id}/words/batch-delete` `moderation.remove_words`	Idempotent	Delete words

Calls: client.Calls

Querying and ending calls, and call stats.

Method	Result	API	Category	Docs
`List(ctx, ListCallsParams)`	`*Page[Call]`	`GET /calls` `calls.list`	Query	List calls
`All(ctx, ListCallsParams)`	`iter.Seq2[Call, error]`	Same as `List`, auto-paging	Query	List calls
`Get(ctx, callID)`	`*Call`	`GET /calls/{call_id}` `calls.get`	Query	Get call details
`End(ctx, callID, reason)`	`*CallChange`	`POST /calls/{call_id}/end` `calls.end`	Idempotent	End a call
`RemoveMember(ctx, callID, username, reason)`	`*CallChange`	`POST /calls/{call_id}/members/{username}/remove` `calls.remove_member`	Idempotent	Remove a member from a call
`Stats(ctx, from, to)`	`[]CallDayStats`	`GET /rtc/stats` `calls.stats`	Query	Get call statistics
`ActiveOf(ctx, username)`	`*ActiveCalls`	`GET /users/{username}/calls/active` `calls.active_of`	Query	Get a user's ongoing calls

Presence: client.Presence

Querying users' presence.

Method	Result	API	Category	Docs
`Query(ctx, usernames)`	`[]Presence`	`POST /presence/query` `presence.query`	Query	Query presence in batches
`Get(ctx, username)`	`*Presence`	`GET /users/{username}/presence` `presence.get`	Query	Get a user's presence

Standalone RTC channels: client.Channels

This service only manages channels; it doesn't join audio and video for users. For parameters and responses, see the channel REST API. APIs in the table omit the app prefix.

Method	REST API	Parameters
`Create`	`PUT /rtc/channels/{channel_id}`	`RTCChannelCreateParams`
`List`	`GET /rtc/channels`	`RTCChannelListParams`
`Get`	`GET /rtc/channels/{channel_id}`	Path ID only
`Update`	`PATCH /rtc/channels/{channel_id}`	`RTCChannelUpdateParams`
`Close`	`POST /rtc/channels/{channel_id}/close`	`RTCChannelCloseParams`
`IssueTickets`	`POST /rtc/channels/{channel_id}/tickets`	`RTCChannelIssueTicketsParams`
`RevokeTickets`	`POST /rtc/channels/{channel_id}/tickets/revoke`	`RTCChannelRevokeTicketsParams`
`Sessions`	`GET /rtc/channels/{channel_id}/sessions`	`RTCChannelSessionsParams`
`RemoveMember`	`POST /rtc/channels/{channel_id}/members/{username}/remove`	`RTCChannelRemoveMemberParams`
`Bans`	`GET /rtc/channels/{channel_id}/bans`	`RTCChannelBansParams`
`GetBan`	`GET /rtc/channels/{channel_id}/bans/{username}`	Path ID only
`Ban`	`PUT /rtc/channels/{channel_id}/bans/{username}`	`RTCChannelBanParams`
`Unban`	`DELETE /rtc/channels/{channel_id}/bans/{username}`	`RTCChannelUnbanParams`
`Stats`	`GET /rtc/channel-stats`	`RTCChannelStatsParams`
`UsageAdjustments`	`GET /rtc/channel-usage-adjustments`	`RTCChannelUsageAdjustmentsParams`

Results are dedicated types for channels, sessions, tickets, bans, stats and usage adjustments, keeping the raw data. In the create result, created means the server returned 201 (created); in close and remove results, pending means it returned 202 (in progress). These aren't fields in the response body. next_cursor on the last page, ban when there's no ban, and expiry times that can be cleared all keep null.

Channel list methods return one page; page through with next_cursor yourself. There's no All iterator like the one for calls (Calls). expires_at distinguishes three states: not sent, null (clear) and a value. Issuing tickets isn't retried automatically; removing members and revoking tickets use a fixed operation_id.

AI conversations: client.AI

Low-level APIs for bot management and streaming replies. Replies usually start with StartStream, whose stream object handles batching, continuous writes and retries; see Calling the API. StreamStopped stops the stream in this process when ai.stream_stopped arrives (the callback handler calls it for you).

Method	REST API	API name	Docs
`CreateBot`	`POST /ai/bots`	`ai.create_bot`	Create a bot
`ListBots` / `AllBots`	`GET /ai/bots`	`ai.list_bots`	List bots
`GetBot`	`GET /ai/bots/{username}`	`ai.get_bot`	Get a bot
`UpdateBot`	`PATCH /ai/bots/{username}`	`ai.update_bot`	Update a bot
`DisableBot`	`POST /ai/bots/{username}/disable`	`ai.disable_bot`	Disable and enable
`EnableBot`	`POST /ai/bots/{username}/enable`	`ai.enable_bot`	Disable and enable
`DeleteBot`	`DELETE /ai/bots/{username}`	`ai.delete_bot`	Delete a bot
`CreateStream`	`POST /ai/streams`	`ai.create_stream`	Start a reply
`GetStream`	`GET /ai/streams/{stream_id}`	`ai.get_stream`	Get a stream
`WriteDeltas`	`POST /ai/streams/{stream_id}/deltas:batch`	`ai.write_deltas`	Batch write
`FinishStream`	`POST /ai/streams/{stream_id}/finish`	`ai.finish_stream`	Finish a reply
`FailStream`	`POST /ai/streams/{stream_id}/fail`	`ai.fail_stream`	Report a failure

Game rooms: client.Game

Create rooms, issue join tickets, start, close, remove players and query. For usage see Calling the API.

Method	Result	API	Category	Docs
`ListRegions(ctx)`	`[]GameRegion`	`GET /game/regions` `game.list_regions`	Query	List regions
`CreateRoom(ctx, roomID, CreateGameRoomParams)`	`*GameCreateRoomResult`	`PUT /game/rooms/{room_id}` `game.create_room`	Idempotent	Create a room
`IssueTickets(ctx, roomID, IssueGameTicketsParams)`	`[]GameTicket`	`POST /game/rooms/{room_id}/tickets` `game.issue_tickets`	Not idempotent	Issue join tickets
`StartRoom(ctx, roomID)`	`*GameRoom`	`POST /game/rooms/{room_id}/start` `game.start_room`	Idempotent	Start
`CloseRoom(ctx, roomID, CloseGameRoomParams)`	`*GameCloseRoomResult`	`POST /game/rooms/{room_id}/close` `game.close_room`	Idempotent	Close a room
`RemoveMember(ctx, roomID, username, RemoveGameMemberParams)`	`*GameRemoveMemberResult`	`POST /game/rooms/{room_id}/members/{username}/remove` `game.remove_member`	Dedup ID (`OperationID`)	Remove a player
`GetRoom(ctx, roomID)`	`*GameRoom`	`GET /game/rooms/{room_id}` `game.get_room`	Query	Get a room
`ListRooms(ctx, ListGameRoomsParams)`	`*Page[GameRoom]`	`GET /game/rooms` `game.list_rooms`	Query	List rooms
`AllRooms(ctx, ListGameRoomsParams)`	`iter.Seq2[GameRoom, error]`	Same as `ListRooms`, pages automatically	Query	List rooms
`ListMembers(ctx, roomID)`	`[]GameMember`	`GET /game/rooms/{room_id}/members` `game.list_members`	Query	List members

GameCreateRoomResult.Created, GameCloseRoomResult.Accepted and GameRemoveMemberResult.Removed come from the status code (true for 201 and 202); they are not fields of the response body. When OperationID is empty, RemoveMember generates one and keeps it across retries.

Services and methods ​

Users: client.Users ​

Friends: client.Friends ​

Blocklist: client.Blacklist ​

Groups: client.Groups ​

Messages: client.Messages ​

Conversations: client.Conversations ​

Files: client.Media ​

Push: client.Push ​

Chat rooms: client.Chatrooms ​

Content moderation: client.Moderation ​

Calls: client.Calls ​

Presence: client.Presence ​

Standalone RTC channels: client.Channels ​

AI conversations: client.AI ​

Game rooms: client.Game ​