Twitch MCP server for AI agents

Let Claude, ChatGPT or your own agent read and act on Twitch: 24 typed functions through one MCP server. No Twitch API key needed.

Functions
24
Sign-in
For account actions
Works with
MCP, HTTP, Node, Python

Connect

Just Twitch

An MCP server for Twitch alone, with one tool per function. Paste it into Claude, ChatGPT, Cursor or any MCP client as a remote server.

https://api.bowmark.ai/mcp/site/twitch
Every site

One MCP server for Twitch and every other site Bowmark covers. Your agent looks up what it needs and calls it.

https://api.bowmark.ai/mcp
Set it up in your client

Both need a Bowmark API key. The quickstart gets you one and a first result in a few minutes. Functions that need a login use the person's own account: how sign-in works.

Functions

Open a function to see its arguments, what it returns and how to call it.

Read 19
  • getChannelReads the signed-in streamer's channel settings: title, language and game/category, off currentUser.broadcastSettings on Twitch's own GraphQL.

    Arguments

    None.

    Returns TwitchChannelSettings

    interface TwitchChannelSettings {
      id: string;
      /** The channel title shown on the stream page. */
      title: string;
      /** ISO 639-1 language code, e.g. "en". */
      language: string;
      /** The category. Empty strings when the channel has never set one. */
      gameId: string;
      gameName: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/getChannel

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.getChannel();
  • getChannelInfoReads a public channel's profile: display name, description, game, language, profile image URL, follower count, creation date.

    Arguments

    NameTypeRequired
    loginstring
    A Twitch channel login, e.g. "ninjas2k" or a twitch.tv/<login> link.
    Yes

    Returns TwitchChannelInfo

    interface TwitchChannelInfo {
      /** Channel login handle. */
      login: string;
      /** User's display name. */
      displayName: string;
      /** Channel description/bio. */
      description: string;
      /** Category/game name. */
      gameName: string;
      /** ISO 639-1 language code. */
      language: string;
      /** Profile image URL. */
      profileImageUrl: string;
      /** Number of followers. */
      followerCount: number;
      /** When the channel was created. */
      createdAt: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/getChannelInfo

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.getChannelInfo({ login: "ninja" });
  • getChannelScheduleReads a channel's scheduled broadcast times and upcoming events (if public).

    Arguments

    NameTypeRequired
    loginstring
    A Twitch channel login, e.g. "ninja" or a twitch.tv/<login> link.
    Yes

    Returns TwitchScheduleSegment[]

    interface TwitchScheduleSegment {
      id: string;
      /** The scheduled broadcast title. Empty string when the channel left it blank. */
      title: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/getChannelSchedule

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.getChannelSchedule({ login: "shroud" });
  • getClipReads one clip by its slug, a clips.twitch.tv link or a twitch.tv/<login>/clip/<slug> link: title, creation date, view count, duration, who cut it…

    Arguments

    NameTypeRequired
    slugstring
    A Twitch clip slug, a clips.twitch.tv url, a twitch.tv/<login>/clip/<slug> url, or the slug alone.
    Yes

    Returns TwitchClip

    interface TwitchClip {
      id: string;
      title: string;
      createdAt: string;
      viewCount: number;
      durationSeconds: number;
      /** The channel the clip was cut from. */
      broadcasterLogin: string;
      /** Who cut the clip. Null when Twitch no longer has a login for that account. */
      creatorLogin: string | null;
      /** The category being played when the clip was cut. Null when Twitch has none on file. */
      gameName: string | null;
      url: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/getClip

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.getClip({ slug: "IcyBreakableDelicataTooSpicy-RnrKLybQI3W9K_AD" });
  • getCurrentUserReads which Twitch account the saved sign-in belongs to: its numeric id and login handle.

    Arguments

    None.

    Returns TwitchCurrentUser

    /** The signed-in account itself. */
    interface TwitchCurrentUser {
      id: string;
      /** The account's login handle, e.g. "ninja" (twitch.tv/<login>). */
      login: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/getCurrentUser

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.getCurrentUser();
  • getFollowStatusChecks whether the signed-in user follows a channel and when they started following.

    Arguments

    NameTypeRequired
    loginstring
    A Twitch channel login, e.g. "ninja" or a twitch.tv/<login> link.
    Yes

    Returns TwitchFollowStatus

    interface TwitchFollowStatus {
      following: boolean;
      /** ISO timestamp. Null when following is false. */
      followedAt: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/getFollowStatus

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.getFollowStatus({ login: "shroud" });
  • getStreamReads a channel's LIVE state right now: whether it is live, title, game, viewer count, and when the broadcast started. live: false and null fields…

    Arguments

    NameTypeRequired
    loginstring
    A Twitch channel login, e.g. "ninja" or a twitch.tv/<login> link.
    Yes

    Returns TwitchStream

    interface TwitchStream {
      /** Whether the channel is broadcasting right now. */
      live: boolean;
      /** Twitch's own stream id. Null while offline. */
      streamId: string | null;
      /** The broadcast title. Null while offline. */
      title: string | null;
      /** The category/game being played. Null while offline, or when live with none set. */
      gameName: string | null;
      /** Null while offline. */
      viewerCount: number | null;
      /** ISO timestamp the current broadcast started. Null while offline. */
      startedAt: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/getStream

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.getStream({ login: "ninja" });
  • getSubscriptionStatusChecks whether the signed-in user is subscribed to one named channel: id, Twitch's own tier code, platform, whether it was redeemed with Prime, when…

    Arguments

    NameTypeRequired
    loginstring
    A Twitch channel login, e.g. "ninja" or a twitch.tv/<login> link.
    Yes

    Returns TwitchSubscriptionStatus

    interface TwitchSubscriptionStatus {
      subscribed: boolean;
      /** Null when subscribed is false. */
      id: string | null;
      /** Twitch's own tier code, read the values off a result, never guess one from prose. Null when subscribed is false. */
      tier: string | null;
      platform: string | null;
      purchasedWithPrime: boolean;
      /** ISO timestamp the current paid period ends. Null when subscribed is false. */
      endsAt: string | null;
      /** ISO timestamp the subscription next renews, if it will. */
      renewsAt: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/getSubscriptionStatus

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.getSubscriptionStatus({ login: "shroud" });
  • getVideoReads one public Twitch video by id or twitch.tv/videos link: title, length in seconds, RECORDING (a live broadcast's growing archive) or RECORDED…

    Arguments

    NameTypeRequired
    vodIdstring
    A Twitch video id, or a twitch.tv/videos/<id> link.
    Yes

    Returns TwitchVideo

    interface TwitchVideo {
      id: string;
      title: string;
      /** Seconds. For a live archive this GROWS, trailing real time by a minute or two. */
      lengthSeconds: number;
      /** "RECORDING" while the broadcast is live, "RECORDED" after. */
      status: string;
      /** "ARCHIVE" (a past broadcast), "HIGHLIGHT" or "UPLOAD". */
      type: string;
      createdAt: string;
      ownerLogin: string;
      url: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/getVideo

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.getVideo({ vodId: "2292032683" });
  • listCategoriesLists Twitch games/categories, ranked by current live viewership: name, box art URL template, viewer count.

    Arguments

    NameTypeRequired
    limitnumber
    Max categories to return, 1-100.
    No

    Returns TwitchCategory[]

    interface TwitchCategory {
      id: string;
      name: string;
      /** A URL template, substitute "{width}x{height}" (e.g. "285x380") to get a real image. */
      boxArtUrlTemplate: string;
      /** Total viewers across all live streams in this category right now. */
      viewerCount: number;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/listCategories

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.listCategories({ limit: 3 });
  • listChannelClipsLists clips cut from a channel, ranked by Twitch's own default ordering: title, creation date, view count, duration, who cut it, and the category…

    Arguments

    NameTypeRequired
    loginstring
    A Twitch channel login, e.g. "ninja" or a twitch.tv/<login> link.
    Yes
    limitnumber
    Max clips to return, 1-100.
    No

    Returns TwitchClip[]

    interface TwitchClip {
      id: string;
      title: string;
      createdAt: string;
      viewCount: number;
      durationSeconds: number;
      /** The channel the clip was cut from. */
      broadcasterLogin: string;
      /** Who cut the clip. Null when Twitch no longer has a login for that account. */
      creatorLogin: string | null;
      /** The category being played when the clip was cut. Null when Twitch has none on file. */
      gameName: string | null;
      url: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/listChannelClips

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.listChannelClips({ login: "ninja" });
  • listChannelVodsLists a channel's past broadcasts/VODs, newest first: title, creation date, length in seconds, status and type (ARCHIVE, HIGHLIGHT, UPLOAD).

    Arguments

    NameTypeRequired
    loginstring
    A Twitch channel login, e.g. "ninja" or a twitch.tv/<login> link.
    Yes
    limitnumber
    Max VODs to return, 1-100.
    No

    Returns TwitchVideo[]

    interface TwitchVideo {
      id: string;
      title: string;
      /** Seconds. For a live archive this GROWS, trailing real time by a minute or two. */
      lengthSeconds: number;
      /** "RECORDING" while the broadcast is live, "RECORDED" after. */
      status: string;
      /** "ARCHIVE" (a past broadcast), "HIGHLIGHT" or "UPLOAD". */
      type: string;
      createdAt: string;
      ownerLogin: string;
      url: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/listChannelVods

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.listChannelVods({ login: "ninja" });
  • listFollowedChannelsLists channels the signed-in user follows: login, display name, game, whether live.

    Arguments

    None.

    Returns TwitchFollowedChannel[]

    interface TwitchFollowedChannel {
      id: string;
      login: string;
      displayName: string;
      followerCount: number;
      /** Only set when live. */
      gameName: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/listFollowedChannels

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.listFollowedChannels();
  • listLiveStreamsBrowses channels live right now, ranked by Twitch's own live viewer count (highest first): id, title, viewer count, broadcaster login and game.

    Arguments

    NameTypeRequired
    categorystring
    A category/game name, e.g. "Minecraft".
    No
    limitnumber
    Max streams to return, 1-100.
    No

    Returns TwitchLiveStream[]

    interface TwitchLiveStream {
      id: string;
      title: string;
      viewerCount: number;
      broadcasterLogin: string;
      /** Null only when Twitch has no category on file for this stream. */
      gameName: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/listLiveStreams

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.listLiveStreams({ limit: 3 });
  • listSubscriptionsLists the signed-in user's own active paid subscriptions: tier, platform, whether redeemed with Prime, period end/renewal, and the subscribed channel.

    Arguments

    NameTypeRequired
    limitnumber
    Max subscriptions to return, 1-100.
    No

    Returns TwitchSubscription[]

    interface TwitchSubscription {
      id: string;
      /** Twitch's own tier code, read the values off a result, never guess one from prose. */
      tier: string;
      platform: string | null;
      purchasedWithPrime: boolean;
      /** ISO timestamp the current paid period ends. */
      endsAt: string | null;
      /** ISO timestamp the subscription next renews, if it will. */
      renewsAt: string | null;
      channelLogin: string;
      channelDisplayName: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/listSubscriptions

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.listSubscriptions();
  • listWatchHistoryLists recently watched streams and VODs for the signed-in user.

    Arguments

    NameTypeRequired
    limitnumber
    Max videos to return, 1-100.
    No

    Returns TwitchVideo[]

    interface TwitchVideo {
      id: string;
      title: string;
      /** Seconds. For a live archive this GROWS, trailing real time by a minute or two. */
      lengthSeconds: number;
      /** "RECORDING" while the broadcast is live, "RECORDED" after. */
      status: string;
      /** "ARCHIVE" (a past broadcast), "HIGHLIGHT" or "UPLOAD". */
      type: string;
      createdAt: string;
      ownerLogin: string;
      url: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/listWatchHistory

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.listWatchHistory();
  • listWatchLaterLists videos the signed-in user has saved to watch later.

    Arguments

    NameTypeRequired
    limitnumber
    Max videos to return, 1-100.
    No

    Returns TwitchVideo[]

    interface TwitchVideo {
      id: string;
      title: string;
      /** Seconds. For a live archive this GROWS, trailing real time by a minute or two. */
      lengthSeconds: number;
      /** "RECORDING" while the broadcast is live, "RECORDED" after. */
      status: string;
      /** "ARCHIVE" (a past broadcast), "HIGHLIGHT" or "UPLOAD". */
      type: string;
      createdAt: string;
      ownerLogin: string;
      url: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/listWatchLater

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.listWatchLater();
  • searchChannelsSearches Twitch channels by keyword.

    Arguments

    NameTypeRequired
    querystring
    A keyword to search Twitch channels for.
    Yes

    Returns TwitchChannelSearchResult[]

    interface TwitchChannelSearchResult {
      id: string;
      login: string;
      displayName: string;
      description: string;
      profileImageUrl: string;
      followerCount: number;
      /** Whether Twitch reports the channel live right now. */
      live: boolean;
      /** Only set while live is true. */
      viewerCount: number | null;
      /** Only set while live is true. */
      gameName: string | null;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/searchChannels

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.searchChannels({ query: "speedrun" });
  • searchVideosSearches for VODs and clips: title, creator, publish date, view count, duration.

    Arguments

    NameTypeRequired
    querystring
    A keyword to search Twitch videos for.
    Yes

    Returns TwitchVideoSearchResult[]

    interface TwitchVideoSearchResult {
      id: string;
      title: string;
      /** ISO 8601 timestamp. */
      publishedAt: string;
      /** View count. */
      viewCount: number;
      /** Duration as a string like "1h7m36s". */
      duration: string;
      /** Channel that created or published the video. */
      creatorLogin: string;
      creatorDisplayName: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/searchVideos

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.searchVideos({ query: "minecraft" });
Act 5
  • createHighlightCuts a permanent Highlight from the signed-in streamer's own broadcast, including the one still live, between two offsets in seconds, with a title.

    Arguments

    NameTypeRequired
    vodIdstring
    The broadcast to cut from, an id or a twitch.tv/videos/<id> link.
    No
    startSecondsnumber
    Seconds into that video.
    Yes
    endSecondsnumberYes
    titlestringYes
    descriptionstringNo
    languagestring
    Default "en".
    No
    tagsstring[]No
    gamestring
    Category name, e.g. "Wetrix".
    No

    Returns TwitchHighlight

    interface TwitchHighlight {
      /** "created" by this call; "existing" when a highlight with this exact title
       * was already on the channel (nothing new made); "unknown" when the request
       * went out and no answer came back, check dashboardUrl before retrying. */
      status: "created" | "existing" | "unknown";
      highlightId: string | null;
      url: string | null;
      title: string;
      vodId: string;
      startSeconds: number;
      endSeconds: number;
      channel: string; // the channel LOGIN, what sendChatMessage/followChannel take as `login`
      dashboardUrl: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/createHighlight

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.createHighlight({ startSeconds: 1, endSeconds: 1, title: "<title>" });
  • followChannelMarks a channel as followed by the signed-in user.

    Arguments

    NameTypeRequired
    loginstring
    A Twitch channel login, e.g. "ninja" or a twitch.tv/<login> link.
    Yes

    Returns TwitchFollowChannelResult

    interface TwitchFollowChannelResult {
      channel: string; // the channel LOGIN, what sendChatMessage/followChannel take as `login`
      following: boolean;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/followChannel

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.followChannel({ login: "<login>" });
  • sendChatMessageSends a message to a channel's live chat.

    Arguments

    NameTypeRequired
    channelIdstring
    The channel's numeric Twitch id.
    No
    loginstring
    The channel's login, e.g. "ninja".
    No
    messagestring
    The message to send to the channel.
    Yes

    Returns TwitchChatMessage

    interface TwitchChatMessage {
      /** The message id assigned by Twitch. */
      id: string;
      /** The message text. */
      body: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/sendChatMessage

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.sendChatMessage({ message: "<message>" });
  • setChannelUpdates the signed-in streamer's channel settings: title, language and game/category, through updateBroadcastSettings on Twitch's own GraphQL.

    Arguments

    NameTypeRequired
    titlestring
    The channel title shown on the stream page.
    No
    languagestring
    ISO 639-1 language code, e.g. "en".
    No
    gamestring
    Category NAME, e.g. "Wetrix".
    No

    Returns TwitchChannelSettings

    interface TwitchChannelSettings {
      id: string;
      /** The channel title shown on the stream page. */
      title: string;
      /** ISO 639-1 language code, e.g. "en". */
      language: string;
      /** The category. Empty strings when the channel has never set one. */
      gameId: string;
      gameName: string;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/setChannel

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.setChannel({});
  • unfollowChannelRemoves a channel from the signed-in user's followed list.

    Arguments

    NameTypeRequired
    loginstring
    A Twitch channel login, e.g. "ninja" or a twitch.tv/<login> link.
    Yes

    Returns TwitchFollowChannelResult

    interface TwitchFollowChannelResult {
      channel: string; // the channel LOGIN, what sendChatMessage/followChannel take as `login`
      following: boolean;
    }

    HTTP endpoint

    POST https://api.bowmark.ai/v1/sites/twitch/unfollowChannel

    Call it

    import { bowmark } from "@bowmark/web";
    
    const result = await bowmark.providers.twitch.unfollowChannel({ login: "<login>" });

Use it from code