Extend the Videos API via a "metadata" endpoint, that provides additional data about the video.

Including but not limited to

• Category changes during the video
• Offsets are relative to the source video that the video is from. So for a highlight it would report the video it was cut from and include where in the origin file the highlight is cut from.

For Example: https://api.twitch.tv/helix/videos/metadata?id=1234
Metadata would support up to 100 (or 50) id's at once like Get Videos

Returns examples

A video of type archive
{
"data": [
{
"id": "1234",
"duration": 18000,
"chapters": [
{
"offset": 0,
"gameid": "200"
},
{
"offset": 500,
"gameid": "220"
}
],
parent: null
}
]
}

A video of type highlight
{
"data": [
{
"id": "1235",
"duration": 600,
"chapters": [
{
"offset": 300,
"game_id": "200"
}
],
"parent": {
"offset": 200,
"id": 4321
}
}
]
}

Use cases:

• if we present a highlight on a third party website, when the video is complete, we can present a easy way to go to the next Highlight in the series (where highlights are cut sequentially) or easily link to the original stream archive for continued watching.

This is an expansion of https://twitch.uservoice.com/forums/310213-developers/suggestions/38155990-return-tags-and-game-id-in-get-videos-in-helix

I have embedded my Twitch channel on my website as a non-interactive iframe in my side panel.

Example:
https://imgur.com/a/v1wc8ri

However, there is so much text there which clutters the UI.

By having my stream title there from when I was online does not add any value. It certainly does not promote my channel.

I would much more prefer if I could just have the bare minimum there and I can show my own offline-image.

Example:
https://imgur.com/a/v1wc8ri

It would be nice if we had a new query parameter option for embedding channels, which could remove any promotion texts or videos / aka make it more minimalistic, to only show the Twitch button and the channel's offline image.

Pagination on some Helix endpoints, such as Get Streams, is just bad, and can lead to endless looping. So here are some suggestions.

The goal of any solution would be for any dev paging through any Helix endpoint to have a clear and reliable indication of "there are no more results, you can stop pagination". And if for whatever reason that can't be indicated, the endpoint should safely return an empty data array rather than looping the user back to the start.

Currently, the final page of the Streams endpoint still contains a cursor (for use in before) so simply relying on the lack of a cursor can't work.

One solution may be for Twitch to validate the cursor on their end, so for example if that final cursor is used as the after value, rather than returning to page 1 (like what would happen with any request lacking or having a bad after value) there could be a check and if that cursor isn't appropriate for paging forwards then there could be a response with just an empty data array, and a cursor that allows paging backwards still with before but the same after object in the cursor so any repeated use will just return to the same final/empty page rather than the start.

Another suggestions that has come up would be for the inclusion of an additional pagination value in addition to the already existing cursor that the endpoint returns that can be a simple flag to indicate if there are more results (this could also be used to indicate if you're on Page 1, so unable to use the before param).

A final suggestion would be is if it's possible to encode metadata related to the pagination state in the cursor, so Base64 decoding it could give a dev details such as if they're on the final page, their current page, etc... I don't think this would be the most user friendly option though, as ideally devs shouldn't need to touch with the Decoding of a cursor.

All of these ideas should be non-breaking, as they don't change has cursors function, from the dev side of things and I think the first option, of the final cursor returning a page with an empty data array could be best as this could stop any endless loops in existing implementations, where as additional flags wouldn't help until the dev integrates that into their apps.

The old semi-unofficial API endpoint to allow/deny messages held by AutoMod used to cause an event in the PubSub "chat moderator actions" topic, which made sense because other moderators should be informed of this mod action. I think at some point it also happened when allowing/denying through the website.

Now allowing/denying through the website and the new endpoint (I think) does not provide this information to other mods. The only thing that is sometimes triggered is a channel terms action event, which is good, but it doesn't provide a direct connection to which message was affected (and it doesn't seem to always happen).

It would be quite useful if the "chat moderator actions" topic would send an event when a message is allowed/denied so other mods can see it.

I'd like to see an API endpoint that gives me information about the level of support for a given channel/streamer and user/viewer combination.

On one hand, I as a viewer want to have a way of getting my total numbers raised in support of a given streamer (that is, user BhaaLseN on $channel).

On the other hand, I as a streamer want to have a way of getting total numbers raised by a particular viewer of mine (that is, user $viewer on BhaaLseN).

The former is meant for viewers and addons like FFZ/BTTV that display numbers: amount of subs gifted (which is already shown in the "Gift a Sub" popup), amount of bits cheered (which is somewhat reflected in the Cheer popup and the bit badge, but doesn't appear as an actual number I think), plus perhaps even a culmination of the Wallet subpage (that could equate the number of subs/bits into actual money spent).
This should be available to the user themselves, regardless of channel, and only return their own level of support (or value if you like).
It could look like a simple GET request to /helix/channel_support/$channel to retrieve my own data for $channel.

The latter is meant for both streamers and perhaps their editors/moderators (but at least channel bots) to allow them to get data on their loyal viewers that provide support over extended periods of time, and might be eligible for a little extra. Many streamers reward milestones with special giveaways and other personal goodies for those particular individuals. Most go by gift count (which can be viewed when gifting or using the gift badge), amount bits cheered (which is again from the cheer badge) or any combination thereof.
This obviously shouldn't be available to just anyone except for the streamer, and maybe even to a trusted group of individuals per channel (editors, moderators and/or bots) to keep track of how much viewers spend on their channel, and also verify that what they claim is true.
It could look like a simple GET request to /helix/channel_support/$channel/$viewer to retrieve data for $viewer on $channel, assuming that the current user has a minimum access level on $channel (such as moderator or editor). In case this remains limited to the channel owner themselves, the endpoint could obviously drop the $channel segment, but I'm also considering scenarios where roles other than the broadcaster may want (or need) access to this.

The data should be there (after all, the former is somewhat available for viewers already using the Wallet page for both subscriptions and bits), it's just that there is no API available for it (aside from GQL I suppose, which developers may not use).

Please provide an API that provides

• what program is being watched
• What season/episode it is
• Episode/program title
• Cast information
• When started
• Link to the program on amazon (it's ASIN/whatever)

Information should be provide by broadcaster_id filter as a API
Sent out as a webhook (watchparty started, watchparty ended)
Provided as a PubSub event (started/ended/progress events?)

PubSub and webhook should also provide information about a Watch party about to start

The watch party player does a countdown to show start, so that should be replicatable.

People whom are not amazon prime members, or do not have that program available to them in their region will watch the program via another medium, and streamers are showing episode information and timers on screen. They are generating this manually.

It would be nice to do this automatically using an API from Twitch.

And the additional meta data will let us developers provide more tooling/information to the viewers. Such as looking up the program on other API's to get show/episode/cast information etc