Skip to main content

Chat

FunctionReturns
onMessagevoid
getChattersPromise<PaginatedResultWithTotal<ChatChatter>>
getGlobalBadgesPromise<Array<ChatBadgeSet>>
getChannelBadgesPromise<Array<ChatBadgeSet>>
getGlobalEmotesPromise<Array<Emote>>
getChannelEmotesPromise<Array<ChannelEmote>>
getEmotesFromSetsPromise<Array<EmoteFromSet>>
getSettingsPromise<ChatSettings>
getSettingsPrivilegedPromise<PrivilegedChatSettings>
updateSettingsPromise<PrivilegedChatSettings>
sendChatMessagePromise<SentChatMessage>
sendChatMessageAsAppPromise<SentChatMessage>
sendAnnouncementPromise<void>
getColorsForUsersPromise<Record<string, string | null>>
getColorForUserPromise<string | undefined | null>
setColorForUserPromise<void>
shoutoutUserPromise<void>
getSharedChatSessionPromise<SharedChatSession | null>
getUserEmotesPromise<PaginatedResult<UserEmote>>

Functions​

onMessage​

twitch.chat.onMessage(callback: (user: string, text: string, data: ChatMessage) => void): void

getChatters​

twitch.chat.getChatters(pagination?: ForwardPagination): Promise<PaginatedResultWithTotal<ChatChatter>>

getGlobalBadges​

twitch.chat.getGlobalBadges(): Promise<Array<ChatBadgeSet>>

getChannelBadges​

twitch.chat.getChannelBadges(): Promise<Array<ChatBadgeSet>>

getGlobalEmotes​

twitch.chat.getGlobalEmotes(): Promise<Array<Emote>>

getChannelEmotes​

twitch.chat.getChannelEmotes(): Promise<Array<ChannelEmote>>

getEmotesFromSets​

twitch.chat.getEmotesFromSets(setIds: Array<string>): Promise<Array<EmoteFromSet>>

getSettings​

twitch.chat.getSettings(): Promise<ChatSettings>

getSettingsPrivileged​

twitch.chat.getSettingsPrivileged(): Promise<PrivilegedChatSettings>

updateSettings​

twitch.chat.updateSettings(settings: UpdateChatSettingsParams): Promise<PrivilegedChatSettings>

sendChatMessage​

twitch.chat.sendChatMessage(message: string, params?: SendChatMessageParams): Promise<SentChatMessage>

sendChatMessageAsApp​

twitch.chat.sendChatMessageAsApp(userId: UserIdResolvable, message: string, params?: SendChatMessageParams): Promise<SentChatMessage>

sendAnnouncement​

twitch.chat.sendAnnouncement(announcement: SendChatAnnouncementParams): Promise<void>

getColorsForUsers​

twitch.chat.getColorsForUsers(users: Array<UserIdResolvable>): Promise<Record<string, string | null>>

getColorForUser​

twitch.chat.getColorForUser(userId: UserIdResolvable): Promise<string | undefined | null>

setColorForUser​

twitch.chat.setColorForUser(userId: UserIdResolvable, color: ChatUserColor): Promise<void>

shoutoutUser​

twitch.chat.shoutoutUser(userId: UserIdResolvable): Promise<void>

getSharedChatSession​

twitch.chat.getSharedChatSession(): Promise<SharedChatSession | null>

getUserEmotes​

twitch.chat.getUserEmotes(filter?: UserEmotesFilter): Promise<PaginatedResult<UserEmote>>

Types​

ChannelEmote​

type ChannelEmote = {
	tier: "" | "1000" | "2000" | "3000"
	emoteType: string
	emoteSetId: string
	images: EmoteImage
	id: string
	name: string
	format: Array<EmoteFormat>
	scale: Array<EmoteScale>
	themeMode: Array<EmoteThemeMode>
}

ChatAnnouncementColor​

type ChatAnnouncementColor = "blue" | "green" | "orange" | "purple" | "primary"

ChatBadgeSet​

type ChatBadgeSet = {
	setId: string
	versions: Array<ChatBadgeVersion>
}

ChatBadgeVersion​

type ChatBadgeVersion = {
	id: string
	imageUrl1X: string
	imageUrl2X: string
	imageUrl4X: string
	title: string
	description: string
	clickAction: string | null
	clickUrl: string | null
}

ChatChatter​

type ChatChatter = {
	userId: string
	userLogin: string
	userName: string
}

ChatMessage​

type ChatMessage = {
	id: string
	date: Date
	bits: number
	text: string
	parts: Array<ChatMessagePart>
	rewardId: string | null
	emotes: any
	badges: any
	isFirst: boolean
	isCheer: boolean
	isRedemption: boolean
	isReturningChatter: boolean
	isHighlight: boolean
	isReply: boolean
	isHypeChat: boolean
	parentMessageId: string | null
	parentMessageText: string | null
	parentMessageUserId: string | null
	parentMessageUserName: string | null
	parentMessageUserDisplayName: string | null
	threadMessageId: string | null
	threadMessageUserId: string | null
	hypeChatLevel: number | null
	hypeChatAmount: number | null
	hypeChatCurrency: string | null
	hypeChatDecimalPlaces: number | null
	hypeChatLocalizedAmount: number | null
	hypeChatIsSystemMessage: boolean | null
	user: ChatMessageUser
}

ChatMessageCheerPart​

type ChatMessageCheerPart = {
	type: 'cheer'
	name: string
	amount: number
	length: number
	position: number
}

ChatMessageEmotePart​

type ChatMessageEmotePart = {
	id: string
	type: 'emote'
	name: string
	length: number
	position: number
}

ChatMessagePart​

type ChatMessagePart = ChatMessageTextPart | ChatMessageCheerPart | ChatMessageEmotePart

ChatMessageTextPart​

type ChatMessageTextPart = {
	type: 'text'
	text: string
	length: number
	position: number
}

ChatMessageUser​

type ChatMessageUser = {
	id: string
	type: string
	name: string
	displayName: string
	color: string
	badge: Dictionary<string>
	isArtist: boolean
	isFounder: boolean
	isSubscriber: boolean
	isBroadcaster: boolean
	isMod: boolean
	isVip: boolean
}

ChatSettings​

type ChatSettings = {
	broadcasterId: string
	slowMode: boolean
	slowModeWaitTime: number | null
	followerMode: boolean
	followerModeDuration: number | null
	subscriberMode: boolean
	emoteMode: boolean
	uniqueChatMode: boolean
}

ChatUserColor​

type ChatUserColor = "blue" | "green" | "blue_violet" | "cadet_blue" | "chocolate" | "coral" | "dodger_blue" | "firebrick" | "golden_rod" | "hot_pink" | "orange_red" | "red" | "sea_green" | "spring_green" | "yellow_green" | `#${string}`

Emote​

type Emote = {
	images: EmoteImage
	id: string
	name: string
	format: Array<EmoteFormat>
	scale: Array<EmoteScale>
	themeMode: Array<EmoteThemeMode>
}

EmoteFormat​

type EmoteFormat = "animated" | "static"

EmoteFromSet​

type EmoteFromSet = {
	emoteType: string
	emoteSetId: string
	ownerId: string
	images: EmoteImage
	id: string
	name: string
	format: Array<EmoteFormat>
	scale: Array<EmoteScale>
	themeMode: Array<EmoteThemeMode>
}

EmoteImage​

type EmoteImage = {
	url1X: string
	url2X: string
	url4X: string
}

EmoteScale​

type EmoteScale = "1.0" | "2.0" | "3.0"

EmoteThemeMode​

type EmoteThemeMode = "dark" | "light"

ForwardPagination​

type ForwardPagination = {
	limit?: number
	after?: string
}

PaginatedResult​

type PaginatedResult<T> = {
	data: Array<T>
	cursor?: string
}

PaginatedResultWithTotal​

type PaginatedResultWithTotal<T> = {
	data: Array<T>
	cursor: string
	total: number
}

PrivilegedChatSettings​

type PrivilegedChatSettings = {
	moderatorId: string
	nonModeratorChatDelay: boolean
	nonModeratorChatDelayDuration: number | null
	broadcasterId: string
	slowMode: boolean
	slowModeWaitTime: number | null
	followerMode: boolean
	followerModeDuration: number | null
	subscriberMode: boolean
	emoteMode: boolean
	uniqueChatMode: boolean
}

SendChatAnnouncementParams​

type SendChatAnnouncementParams = {
	message: string
	color?: ChatAnnouncementColor
}

SendChatMessageParams​

type SendChatMessageParams = {
	replyParentMessageId?: string
}

SentChatMessage​

type SentChatMessage = {
	messageId: string
	isSent: boolean
	dropReason?: {
		code: string
		message: string
	}
}

SharedChatSession​

type SharedChatSession = {
	sessionId: string
	hostBroadcasterId: string
	participants: Array<SharedChatSessionParticipant>
	createdAt: string
	updatedAt: string
}

SharedChatSessionParticipant​

type SharedChatSessionParticipant = {
	broadcasterId: string
}

UpdateChatSettingsParams​

type UpdateChatSettingsParams = {
	slowModeEnabled?: boolean
	slowModeDelay?: number
	followerOnlyModeEnabled?: boolean
	followerOnlyModeDelay?: number
	subscriberOnlyModeEnabled?: boolean
	emoteOnlyModeEnabled?: boolean
	uniqueChatModeEnabled?: boolean
	nonModeratorChatDelayEnabled?: boolean
	nonModeratorChatDelay?: number
}

UserEmote​

type UserEmote = {
	emoteType: string
	emoteSetId: string
	ownerId: string
	id: string
	name: string
	format: Array<EmoteFormat>
	scale: Array<EmoteScale>
	themeMode: Array<EmoteThemeMode>
}

UserEmotesFilter​

type UserEmotesFilter = {
	broadcaster?: UserIdResolvable
	limit?: number
	after?: string
}

UserIdResolvable​

type UserIdResolvable = string | UserIdResolvableType

UserIdResolvableType​

type UserIdResolvableType = {
	id: string
}