# Actions engine Source: https://docs.mottostreaming.com/guides/annotations/actions Automations that are triggered when annotations are tagged on a video. #### Introduction Actions are **automations**. They are the things that happen when an annotation is triggered. For example, when a goal is scored, you may want to automatically create a clip of that goal (either as an mp4 asset or a playable video). And maybe you want to automatically share that clip to social media? Actions are the way to achieve this. Motto supports a wide range of actions, all with the purpose of simplifying your workflow and automating repetitive tasks. Or, put differently, reducing the overhead needed to run a live sports OTT platform. Here is a non-exhaustive list of automated actions: * **Create a clip** of a goal in your live-stream; * **Create a highlight reel** of all goals and chances in a match; * **Share to social media** the clip of a scored goal; * **Send a notification** to all users that have favorited a team when a goal is scored; * **Write a message** in a chat room when kickoff starts; * **Send a webhook callback** to a third-party system when the match is over. These actions (and more) can be configured to suit your particular needs. The next section will guide you through the process of setting this up. ## Get Started To benefit from Motto's actions system, you must first think through your particular use-cases. What do you want to happen when a goal is scored? Or when a match is over? The following section helps you understand what is possible. To get started with actions, you must first ensure that you have followed the steps in the [annotations](/guides/annotations) guide. This is because actions are triggered by annotations. #### Action Types In order to understand what is possible through Motto, you can browse the available action types. To do so, follow these steps: Call the [List Action Types](/reference/studio-api/annotations/action-types/v1/list-action-types) endpoint. ``` curl --request GET \ --url https://api.mottostreaming.com/annotations/action_types/v1 \ --header 'Authorization: Bearer ' ``` This will return a list of available action types that you can choose to configure. #### Action Configuration Once you have determined which action types you would like to trigger when an annotation is created, you must configure your annotation type with the appropriate action configuration. To do so, follow these steps: First, call the [Get Action Type](/reference/studio-api/annotations/action-types/v1/get-action-type) endpoint to understand exactly which fields you must provide in the action configuration. ``` curl --request GET \ --url https://api.mottostreaming.com/annotations/action_types/v1/create_clip \ --header 'Authorization: Bearer ' ``` Then, call the [Set Action Configuration](/reference/studio-api/annotations/types/v1/set-action-configuration) endpoint with the correct configuration. For example, if you want your "Goal" annotations to trigger a highlight clip creation, you would call the endpoint like this: ``` curl --request POST \ --url https://api.mottostreaming.com/annotations/types/v1//action_configuration \ --header 'Authorization: Bearer ' \ --header 'Content-Type: application/json' \ --data '{ "configuration": { "create_clip": { "motto_jwt": "", "name": "Goal", "relative_end_offset": 10000, "relative_start_offset": -10000 } } }' ``` A lot is happening here, so let's break it down. 1. The `annotation_type_id` should be the annotation type for which you want to configure the action. In this example, it is assumed you have already configured a "Goal" annotation type as described in [this guide](/guides/annotations/annotations#annotation-types). 2. There is a `create_clip` key in the configuration object. This is the ID of the action type that you want to trigger. 3. There is a `motto_jwt` key in the configuration object. This is the Motto JWT token that is used to by our servers to authenticate the action calls, since actions are asynchronous in nature and actually may call Motto's Studio API (or even external APIs). You can provide your own JWT token, but it is recommended to provide credentials to an account with only the necessary permissions (in this example the permission needed to create a clip). It is not recommended to provide tokens to the action configuration in plaintext. Instead, we recommend using [action secrets](/guides/annotations/actions#action-secrets-advanced). 4. There are more input fields, like `name` and `relative_start_offset`. These are specific to the action type that you are configuring. In this example, the `name` field is used as part of the name the clip will be given, and the `relative_start_offset` and `relative_end_offset` fields are the start and end times of the clip relative to the annotation time. It is important to understand that each action has its own set of input fields that it requires, so the example above is only here for reference. Once you submit this configuration, you are done! You can verify this now by creating an annotation of the type you just configured, and see if the action triggered. Keep in mind that, depending on the kind of action(s) you have created, it may take some time for the action to complete. #### Action Secrets (advanced) As has become clear in the action configuration section, some actions require authentication credentials. While you may provide these in plaintext on the action configuration, this may expose those credentials to anyone who has access to view your action configurations, which may lead to accidental leaking of your credentials to unintended parties. The suggested alternative to providing credentials in plaintext is to use Motto's action secrets system. To do so, follow these steps: Call the [Create Action Secret](/reference/studio-api/annotations/action-secrets/v1/create-action-secret) endpoint to store a secret value. For example, if you wanted to store a Motto API token, you could call the endpoint as follows: ``` curl --request POST \ --url https://api.mottostreaming.com/annotations/action_secrets/v1 \ --header 'Authorization: Bearer ' \ --header 'Content-Type: application/json' \ --data '{ "id": "motto_jwt", "project_id": "", "description": "The JWT of a Motto account with the Editor role", "value": "" }' ``` Once your action secret is stored, you can reference it in your action configuration by using the `$secret.` syntax. For example, if you wanted to use the `motto_jwt` secret in your action configuration, you would reference it like this: ``` { "configuration": { "create_clip": { "motto_jwt": "$secret.motto_jwt", "name": "Goal", "relative_end_offset": 10000, "relative_start_offset": -10000 } } } ``` #### Action Chaining (advanced) The Motto action system is designed for both simple and complex workflow automations. Action chaining is a concept that lets you execute multiple actions in sequence, where the result of one action can be used as input for the next action. For example, you may want one action to create a clip, and then take that clip's `asset_id` (which is the "output field" of that particular action type) as input for an action that shares it to Instagram (which may require an `asset_id` as its input field). Fortunately, chaining actions is not difficult to configure. In fact, it is very similar to configuring a single action, but with the added step of providing the output of one action as input for the next action. For the example above, the configuration may look like this: ``` { "configuration": { "create_clip": { "motto_jwt": "$secret.motto_jwt", "name": "Goal", "relative_end_offset": 10000, "relative_start_offset": -10000 }, "share_to_instagram": { "instagram_api_token": "$secret.instagram_token", "social_media_post": "Have a look at this amazing goal!", "video_asset_id": "$create_clip.asset_id" } } } ``` The `$create_clip.asset_id` is a reference to the output field of the `create_clip` action. This is how you chain actions together. ## Next Steps If you are interested in using annotations to enrich your OTT platform experience, you may want to learn more about [frontend plugins](/guides/annotations/frontend-plugins). # AI agents Source: https://docs.mottostreaming.com/guides/annotations/ai-agent AI Agents for automatic highlight detection in your live streams Motto recently released an AI agent in *beta* that can fully automate the process of annotating your live-stream. The AI agent will observe your live-stream and detect interesting moments, which it will then tag as annotations. Each annotation will be assigned a confidence score, so you (or the agent) can decide which annotations to keep and which to discard. Those annotations can then be used to trigger actions, just like any other annotation! If you are interested in using this feature, please [reach out to us](mailto:info@mottostreaming.com). # Annotations Source: https://docs.mottostreaming.com/guides/annotations/annotations Points in time used to mark key moments in a stream. ## Introduction Annotations are a powerful concept in the Motto platform. In fact, we believe it is this concept that makes Motto shine when it comes to live sports OTT platforms. Annotations are representations of points in time in a video, and can be used to mark key moments in a match, like goals, fouls, or substitutions. These moments can be tagged through our visual Studio interface without any technical knowledge. Motto recently released an AI agent in beta that can fully automate the process of annotating your live-stream! By themselves, annotations are just empty containers; they do not "do" anything as such. However, they lay the fundament for two important concepts in Motto: [actions](/guides/annotations/actions) and [frontend plugins](/guides/annotations/frontend-plugins). In a nutshell, actions are automations that are triggered when an annotation is created, and frontend plugins are components that can be dropped into your OTT platform to enhance the user experience. For more information, please read our sections about [actions](/guides/annotations/actions) and [frontend plugins](/guides/annotations/frontend-plugins). ## Get Started Before you can get started with creating annotations, you must first create a few supporting objects. These are described below. #### Annotation sets An annotation set is a collection of the kinds of annotation types that you would like to create. Typically, you would create an annotation set for each sport that you are covering. For example, you might have an annotation set for football, and another for basketball. To create your annotation set, follow these steps: Call the [Create Annotation Set](/reference/studio-api/annotations/sets/v1/create-annotation-set) endpoint. In it's simplest form, this call could look like: ``` curl --request POST \ --url https://api.mottostreaming.com/annotations/sets/v1 \ --header 'Authorization: Bearer ' \ --header 'Content-Type: application/json' \ --data '{ "project_id": "", "name": "Football" }' ``` Once this set is created, please make sure to associate it with your event type by calling the [Attach Content Type](/reference/studio-api/annotations/sets/v1/attach-content-type) endpoint. This will ensure that your annotation set shows up for the correct events in the Studio interface (you would not want to accidentally tag basketball annotations on a football event!) ``` curl --request POST \ --url 'https://api.mottostreaming.com/annotations/sets/v1//attach?project_id=&content_base_type=event&content_type_id=' \ --header 'Authorization: Bearer ' ``` If you are not using a specialized event type, you should use `default` in place of the event type. #### Annotation types Once you have created an annotation set, you must create some annotation types within that set. Annotation types are the different kinds of annotations that you can create. For example, you might have an annotation type for goals, chances, corner kicks, red cards, kickoff, full-time, etc. To create your annotation types, follow these steps: Call the [Create Annotation Type](/reference/studio-api/annotations/types/v1/create-annotation-type) endpoint. In it's simplest form, this call could look like: ``` curl --request POST \ --url https://api.mottostreaming.com/annotations/types/v1 \ --header 'Authorization: Bearer ' \ --header 'Content-Type: application/json' \ --data '{ "project_id": "", "set_id": "", "name": "Goal", "priority": "1000", "group_name": "In-Game Moments", }' ``` This call will create an annotation type called "Goal" in the Football annotation set you just created. The `priority` field is used to order the annotation types in the Studio interface, and the `group_name` field is used to group the annotation types together. #### Annotations Now that you have created your annotation set and annotation types, you can start creating annotations for your video content! To create an annotation, follow these steps: Navigate to the [Video Manager](/glossary/video-manager) in the Studio, and select the event and video you would like to annotate. Click on the "Video tagging" tab. If you have created an annotation set and associated annotation types, you should see something similar to this: If you do not see the "Video tagging" tab in the Studio interface, this may mean that you have not attached your annotation set to your event type yet. Please refer to the [annotation set](/guides/annotations/annotations#annotation-sets) section above. When you click on one of the available annotation types, an annotation will be created at the current time in the video player on that page. Call the [Create Annotation](/reference/studio-api/annotations/annotations/v1/create-annotation) endpoint. In it's simplest form, this call could look like: ``` curl --request POST \ --url https://api.mottostreaming.com/annotations/annotations/v1 \ --header 'Authorization: Bearer ' \ --header 'Content-Type: application/json' \ --data '{ "project_id": "", "type_id": "", "video_id": "", "offset": "60000" }' ``` This call will create an annotation of type "Goal" that you just created, in the video of your choice. The `offset` field is the time in milliseconds where the annotation should be placed. In the example above, this would be at 60 seconds into the video. The `video_id` field represents a single video, and is not the same as the `event_id` or `live_stream_id`. ## Next Steps Now that you know how to create annotations, you may want to learn more about [actions](/guides/annotations/actions), which allows you to automate your workflows during a live-stream or VOD! # Manage images Source: https://docs.mottostreaming.com/guides/assets/images How to manage image assets in Motto ## Introduction Images are a key part of any OTT platform. Motto provides a simple way to manage images in your project, and to serve them back to your users affordably and efficiently, so that you do not need a third-party image integration. ## Uploading images You can get started using the Motto Studio, which we recommend for non-technical users. Alternatively, you may get started by using the Motto API. Image uploads in the Studio are a part of the creation of [event](/guides/cms/events), [creative works](/guides/cms/creative-works), [entities](/guides/cms/entities) or [hero banners](/guides/ott/hero-banners). When opening the creation sidebar, you can upload a thumbnail or poster for your event or creative work, or logo for your entity. If you prefer using the Studio API to interact with the Motto platform, you can follow the following steps to achieve the same result as described in the "Via the Studio" section. 1. Create an [asset upload session](/reference/studio-api/streaming/uploads/v1/create-upload) (e.g. for a .jpg file) 2. Upload your file to the `signed_url` provided in the response from step 1. 3. (Optionally) associate your asset with an event, creative work or entity by using the `reserved_asset_id` from step 2. ## Downloading images Images can be downloaded from Motto easily and affordably. When you have an asset ID of the image you want to download, you can construct a download URL for your image using the following pattern (remove the `<` and `>` characters) `https://assets.mottocdn.com/images//` You can find your `project_id` using the instructions [here](/glossary/project_id). #### Image resizing If you are interested in serving your images in different sizes, you can use the following pattern to resize your images: `https://assets.mottocdn.com/images//?w=&h=` (you may also provide only a width or height, and the image will be resized proportionally). # Introduction Source: https://docs.mottostreaming.com/guides/assets/introduction Image and video files stored in Motto. When you use Motto, you will typically encounter the concept of assets at some point. Simply put, assets are image files (like `png` or `jpeg`) or video files (like `mp4` or `flv`) that are stored in your Motto environment. Even though HLS/Dash playlists and video fragments can be considered video files, Motto does not consider those "assets" in its systems. ## How? Assets can be created in a number of different ways. Some examples: #### Videos * Recording live streams. When you live-stream to Motto, your stream can be configured to automatically record the raw input, so that you can access a full `mp4` asset after the end of the stream. * VOD uploads. When you want to serve your viewers Video on Demand content, this can be uploaded into Motto's asset service. From there, it can be transcoded into a Motto [video](/glossary/video). * Highlight clipping and stitching. When you want to create a highlight from a live stream or VOD, you can use Motto's [clipping and stitching](/guides/streaming/highlights/introduction) tools to create a new asset from the original stream. #### Images * Image uploads. When you want to serve your OTT platform users visual imagery (like team logo's or event posters), you can upload these via the Studio or the API. * Thumbnail generation. When you create a new video asset, you may want to automatically generate thumbnails (visual snapshots) of the video. These then become available as assets. In order to ensure that your asset library does not get disorganized, you can associate [labels](/glossary/label) with your assets. These labels can be used to filter and search for assets in the Studio. ## Asset Manager To make browsing your video and image files easier, the Studio contains an asset management UI. Using this interface, you can view, search, and create and delete your assets. You can also see the details of each asset, like the file size, the creation date, and the labels associated with it. The Asset Manager is currently in beta-testing and is not yet publicly available. [Reach out](mailto:info@mottostreaming.com) to us to inquire about early access. # Video asset downloads Source: https://docs.mottostreaming.com/guides/assets/video-download Downloading video assets in Motto ## Introduction Motto supports downloading video assets from its systems. A common use-case for this is to download recordings of [live streams](/guides/streaming/events/live-streaming) after a live event has ended, or to download [generated clips](/guides/streaming/highlights/introduction). ## Get Started You can get started with downloading assets through our API, using the steps below. 1. Retrieve the asset ID by querying the [asset list endpoint](/reference/studio-api/streaming/assets/v1/list-assets), optionally with a [KQL filter](/reference/deep-dive/kql-filters) applied to narrow down your results. The labels you can use in this filter depend on where the asset came from, but common system labels include `video_id` for the video ID, and `workflow_id` for the live-stream ID. 2. Use the [asset URL endpoint](/reference/studio-api/streaming/assets/v1/get-asset-url) to generate a download URL. This endpoint requires the asset ID from step 1. 3. Download the asset using the URL provided in the response from step 2. # Video asset uploads Source: https://docs.mottostreaming.com/guides/assets/video-upload Uploading video assets into Motto ## Introduction Motto supports uploading video files into its systems. A common use-case for this is to process such a video file into a format that can be used for VOD streaming. This way, end-viewers can watch this video content on-demand at their leisure. Of course, you may also wish to do this simply to have a stored copy of your video assets in the cloud. ## Get Started If you are looking to upload video assets for the purpose of VOD content creation, you can follow the instructions [here](/guides/streaming/events/vod). If you are looking to upload video assets for cloud storage, you can use [this API endpoint](/reference/studio-api/streaming/uploads/v1/create-upload). ## Supported formats * Maximum 10GB file size * Supported video formats MP4 (H.26x, MPEG-2, MPEG-4), 3GP (H.26x, MPEG-4), AVI (Divx, XviD etc), VMV, MOV/QT (MPEG-2, MPEG-4), MKV, WEBM (H.26x, MPEG-4, DivX, XviD, VP6), FLV (VP6, H.264, MPEG-4), MXF. * Supported audio codecs AAC, MP3, ALS and AC-3. # Entities Source: https://docs.mottostreaming.com/guides/cms/entities ## Introduction An entity in Motto's systems represents any organization, person or thing. Entities are useful in several ways: * They can be associated with events, and help give structure to your content. E.g. associating a competition entity with a football event. * They can be used to build up a hierarchy or taxonomy of related entities. E.g. associating a competition entity with a league or organizing body. * You can sell subscriptions around the content related to an entity. E.g. selling a subscription that grants access to every event in a competition. * You can manage video protection, like geo-restrictions or Digital Rights Management (DRM), on an entity level. E.g. applying a geo-blocking rule to all events in a specific competition. A well-structured entity system also becomes important when you want the end user of your OTT platform to be able to navigate your content structure easily. For example, if they are watching a football match, you might want to suggest similar matches from that same competition. With Motto's powerful entity system, all of this (and more) is possible. ## Heads up Before diving into entities, you must first create an [entity type](/guides/cms/content-types). This is the blueprint that defines what an entity can look like. For example, if you want to make entities for clubs like `FC Barcelona` and `Real Madrid`, you should first create the entity type `club` (or similar, the naming and structure are in your own hands)! Designing a set of entity types is a crucial but sometimes daunting task, so our support team is always available to help you get starte. ## Get Started Once you have created your entity type as hinted at above, you can get started using the Motto Studio, which we recommend for non-technical users. Alternatively, you may get started by using the Motto API. The following steps will guide you through the process of setting up an event via the Studio. #### Creating an entity First, navigate to the "Library" tab in the Studio. You will see a list of available entity types like in the image below. If you do not see any entity types like above, you must first create a [content type](/guides/cms/content-types). Click on the "New" button to start creating a new entity. A sidebar will appear that prompts you to enter the entity's details. The details that you can fill out here are fully flexible! It depends entirely on your own requirements. After pressing "Save", your entity is now created and will show up in the list of entities. If you prefer using the Studio API to interact with the Motto platform, you can follow the following steps to achieve the same result as described in the "Via the Studio" section. 1. Call the [Create Entity](/reference/studio-api/cms/entities/v1/create-entity) endpoint. For the endpoint above, you will need a `type_id`. This is the identifier of your custom type, which you must first create a [content type](/guides/cms/content-types). That's it! # Sports standings Source: https://docs.mottostreaming.com/guides/cms/standings ## Introduction Motto's Standings feature allows you to create and manage standings for your sports competitions, as well as for any other type of ranking that you may want to display on your OTT platform. ## Get Started Managing standings in Motto can currently be achieved through the Studio API. This allows easy integration with a third-party service that provides standings data (though a Studio UI is on the roadmap!) To get started, you can create a new standings object by using the [Create Standings](/reference/studio-api/cms/standings/v1/create-standing) API endpoint. There, you can associate an existing entity with the standings. Typically, this is an entity like `La Liga 2025/2026`, with an entity type such as `competition` or `league`. Then, you must provide a mode, which currently has to be `manual` (in the future Motto will also support a `computed` mode that will do automated standing calculations, based on event metadata). Then there is a standing phase ID array. These are the other type of object(s) you must create via the API, using the [Create Standing Phase](/reference/studio-api/cms/standing-phases/v1/create-standing-phase) endpoint. The standing phase is a collection of teams (or other kinds of entities, like players in a top-scorer ranking) that are part of the standings, and it can be used to represent different phases of a competition, such as group stages, knockout rounds, etc. You can create multiple standing phases for the same standings object, and you can also update the standing phase data at any time. Each phase has its own "classifications", which are the metrics that you want to display in the standings. These can be things like points, wins, losses, draws, goals scored, goals conceded, etc. It is up to you to determine what you want to keep track of, based on your sport(s) and rules. Each phase can contain one or more groups, which can be used to represent different entities (like teams) within the standings (think of the Group A - H ones in a football World Cup, for example). # Embed video player Source: https://docs.mottostreaming.com/guides/how-to/embed-our-player Share your live and VOD content on your own website using a standard HTML iframe. ## Introduction Motto's embeddable player lets you put any video, event, or creative work directly on your own website using a standard HTML ` ``` The iframe fills its container width and maintains a 16:9 aspect ratio. To control the size, wrap it in a `
` with your desired width. ### Query parameters #### All embed types | Parameter | Required | Description | | ----------- | -------- | ------------------------------------------------------------------------------------ | | `publicKey` | yes | Your Motto public key. Found in Studio under **Settings → API**. | | `autoplay` | no | Set to `1` or `true` to autoplay on load. Requires `allow="autoplay"` on the iframe. | | `ads` | no | Set to `1` or `true` to enable IMA video ads if configured on the content. | | `locale` | no | Language code for player UI strings, e.g. `en`, `es`, `fr`. Defaults to `en`. | #### Event and creative-work embeds | Parameter | Description | | -------------------- | --------------------------------------------------------------------------------------------------------------------------------- | | `backgroundImageUrl` | URL of an image to display as the background on the pre-event screen. Only used when the event has no poster image set in Studio. | #### Example with autoplay ```html theme={null} ``` ### Listening to player events The embed player can notify your page about playback events using the browser's `postMessage` API. This is optional — the player works without it. To listen for events, add a `message` event listener on your page: ```js theme={null} window.addEventListener('message', (event) => { if (event.data?.source !== 'motto-embed') return; switch (event.data.type) { case 'play': console.log('Viewer started watching'); break; case 'ended': console.log('Video finished'); break; case 'error': console.error('Player error:', event.data.payload.message); break; } }); ``` #### Available event types | Type | Payload | Description | | ----------------- | --------------------- | ------------------------------------------ | | `playerReady` | — | Player is initialised and ready | | `loadStart` | — | Video loading has begun | | `canPlay` | — | Video is ready to play | | `play` | — | Playback started | | `pause` | — | Playback paused | | `ended` | — | Video reached the end | | `videoData` | `VideoData` object | Content metadata loaded from the API | | `emptyPlaylists` | — | Content exists but has no playable streams | | `error` | `{ message: string }` | A player or API error occurred | | `adStart` | — | An ad started playing | | `adComplete` | — | An ad finished | | `adSkipped` | — | Viewer skipped an ad | | `allAdsCompleted` | — | All ads in the break completed | All events carry `{ source: 'motto-embed', type: string, payload?: object }`. ### Content Protection By default, every website is allowed to embed your videos using the approach described here. However, this means it is trivial for malicious actors to distribute your content by embedding it in their own website rather than yours. To prevent this, you can use our [Domain Pinning](/guides/streaming/video-protection/domain-pinning) feature. By doing so, only the domains that you configure will be allowed to embed your content. At a technical level, this is done via a `Content-Security-Policy: frame-ancestors ` header in the iframe page, which tells the user's browser whether to allow loading the iframe. If your website sets a `Content-Security-Policy: frame-src` header, add `frame-src https://embed.mottostreaming.com` to allow the iframe to load. ## Next Steps * [Enable video ads](/guides/monetization/ads/video-ads) and pass `ads=1` in your embed URL to monetize your embedded content. # Manage accounts Source: https://docs.mottostreaming.com/guides/iam/manage Manage existing accounts and invite new ones into your Motto organization. ## Account overview To see an overview of all existing accounts, you can navigate to your profile icon in the top-right corner of the Motto Studio and then click on [*Organization Settings*](https://studio.mottostreaming.com/organization/account-management). There, you will find a complete list of all the accounts that have at least *some* access to at least *one resource* in your organization. If you have an Motto organization with hundreds or even thousands of accounts, where many of them have access to only specific resources and not blanket access across the organization, you may want to toggle on *"Only show accounts with roles in organization"* in the top-right corner. This reduces the list to only those accounts that have an actual role at the organization level. To learn more about access control, read more about the concepts around Motto [IAM](/glossary/iam) (identity & access management). ## Invite new accounts To invite someone into your Motto organization, visit the account overview. From there, click the "Assign accounts" button. A side-panel will appear with an input field. In there, you may enter one or more email addresses (one entry per line). You are also asked to assign a [role](/console/accounts/roles) to the account(s) you are inviting. Invite accounts into your Motto organization Once you press "Continue", a welcome email will be sent to the email addresses you provided. The recipients of the invite email will have **one week** to accept the invitation and set a password. # Your sports. Your streams. Your way. Source: https://docs.mottostreaming.com/guides/introduction Create your own sports OTT platform in minutes, and start live-streaming today! Hero Light Hero Dark Welcome to the Motto documentation, where you'll find all the information you need to live-stream your video content and create a powerful, authentic and engaging OTT experience for your sports fans. In case you're unable to find what you're looking for, please don't hesitate to [get in touch with us](mailto:info@mottostreaming.com) directly. [//]: # "## How-to..." [//]: # [//]: # "" [//]: # " " [//]: # " Create and deploy your own OTT platform within minutes" [//]: # " " [//]: # " " [//]: # " Stream your live video content into Motto using OBS" [//]: # " " [//]: # " " [//]: # " Observe and improve the health of your live streams" [//]: # [//]: # " " [//]: # " " [//]: # " Understand the popularity of your live and VOD content" [//]: # " " [//]: # "" # Video ads Source: https://docs.mottostreaming.com/guides/monetization/ads/video-ads How to plan, configure, and test video ad delivery with Motto. ## Introduction Video ads let you monetize live or on-demand streams with pre-roll ads. Motto supports two ad sources: * **Sponsorship Video Ad**: Upload and control your own video directly in Motto Studio — ideal for direct sponsor deals, partner promos, or house ads. * **VAST Ad Tag**: Connect to an external ad server (e.g. Google Ad Manager, SpringServe, FreeWheel) for programmatic campaigns and dynamic targeting. Both options are configured from the **Video Ads** screen under **Monetization** → **Ads & Sponsorship** in Motto Studio. ### Prerequisites * A Motto Studio account with access to the Monetization section * If using external ad-tech: a VAST-capable ad server with tags created for your inventory ## Get Started Open Motto Studio and navigate to **Monetization** → **Ads & Sponsorship**. Ensure the **Video Ads** tab is selected. Click **Create new Video Ad** to open the configuration panel. Enter a clear, internal name that will help you identify and manage this ad later. **Example names:** * `Main Sponsor – Pre-roll (15s)` * `GAM – VAST Pre-roll` * `House Ad – Season Promo` Choose which videos this ad applies to. By default, the ad will apply to **All content**. Click **Show advanced options** to scope the ad by: * Competition * Content type * Other delivery rules Use specific targeting to ensure sponsor ads only appear on relevant content, improving both viewer experience and sponsor satisfaction. Use the **Published** toggle to control when the ad is active: * **On**: The ad is live and will be delivered to viewers based on your applicability rules. * **Off**: The ad is staged or paused and will not be shown to viewers. Keep new ads unpublished while testing, then toggle on when ready to go live. Select the source for your video ad. You have two options: #### Option A: Sponsorship Video Ad Choose **Sponsorship Video Ad** when you want to upload and control your own video. 1. Upload one or more video files (multiple qualities recommended for adaptive streaming) 2. Configure playback options: * **Skippable**: Allow viewers to skip after a set duration (optional) * **Duration**: Set the length in seconds (must match the asset length exactly) * **Clickthrough URL**: Where viewers go when they click the ad (optional) Best for: direct sponsor deals, partner/league promos, house ads, and fixed pre-roll placements where you need guaranteed visibility. #### Option B: VAST Ad Tag Choose **Ad Tag URL (VAST)** when connecting to an external ad server. 1. Paste the full VAST tag URL from your ad server 2. The tag handles ad selection, rotation, and tracking automatically **Example tag:** ``` https://pubads.g.doubleclick.net/gampad/ads?... ``` Best for: programmatic campaigns, ad rotation, dynamic targeting, and pacing controlled by your ad server. Click **Save ad** to store your configuration. If the **Published** toggle is on, the ad will immediately begin delivery following your applicability rules and ad type settings. ## Testing and validation Before going live with your video ads, verify the following: * **Pre-roll playback**: Confirm ads play correctly before both live and VOD content * **Ad ordering**: Verify ads play in the expected sequence using test tags from your ad server * **Tracking**: Confirm clickthrough URLs, quartile beacons, and companion creatives fire as expected * **Error handling**: Test on slow networks and with ad timeouts to ensure playback resumes gracefully on errors Most ad servers provide test tags specifically for validation. Use these during development to avoid affecting live campaign metrics. # Introduction Source: https://docs.mottostreaming.com/guides/monetization/introduction Overview of ways to generate revenue from your live and on-demand sports content. ## Introduction Motto includes a suite of built-in monetisation tools that help you earn revenue from your live and on-demand sports content — all without managing complex infrastructure. These tools let you create flexible business models, engage fans, and unlock new revenue streams right from the Motto platform, whether you’re launching an OTT service or streaming standalone events. ### Overview of Monetisation Options Motto supports multiple monetisation approaches out of the box: * Pay-Per-View (PPV) events or passes * Subscriptions (SVOD / bundles) * Video Advertising (AVOD) * Sponsorship and Branded Integrations Each tool can be configured via the Motto Studio or programmatically through the Motto API depending on your workflow. **Tip: create multiple offers to access the same content** You can create multiple monetisation offers for the same content in Motto, think of day pass, monthly subscription or yearly subscription. This allows fans to choose the option that best fits their needs, while maximising your revenue potential. ## PPV & Subscriptions PPV allows you to charge viewers a one-time fee for specific live events or on-demand videos. Subscriptions let fans access a catalogue of content for a recurring fee — ideal for seasonal or year-round access. ### How to Configure Via Motto Studio (Self-Service): * Go to the Monetization section in Motto Studio. * Select Offers. * Create a new offer * Attach the offer to an event, entity, or even all content. * Provide the required information choose whether it’s a one-time purchase (PPV) or recurring (subscription). * Define pricing tiers and descriptions that match your audience and content strategy. * Enable payment processing and test purchases in staging before going live. **Tip: grant free access to paid content** You can grant a specific user access to a paid event without requiring payment by creating an entitlement for them via the Motto Studio. This is useful for complimentary access, press passes, or internal testing. See [entitlement verification](/guides/streaming/video-protection/other) for more details. ### Video integrated ads Advertising monetisation allows you to generate revenue by placing ads in your video streams. Motto currently supports pre-roll ads. Advertising is commonly used for free-to-watch platforms, or as part of a hybrid model. \###How to configure advertising * Open Motto Studio * Go to Monetization * Select Ads & sponsorship * Create a new ad * The Motto platform allows you to either upload your own creative (ad) or use an Ad partner through VAST or VMAP integration. Please ensure the video player component in the OTT section has the option "**Enable ads**" enabled. # Offers Source: https://docs.mottostreaming.com/guides/monetization/offers/introduction Learn how to create and manage monetized offers to sell access to your content. ## Introduction An offer is either a bundle or single piece of content that your users can purchase. It defines how much a user pays, in which regions this offer is available, what content they get access to in return, and more. Every purchase a user makes — whether a one-time event pass or a recurring subscription — is tied to an offer you have configured. Offers give you full control over your pricing strategy. You can create multiple offers for the same content to give users flexibility. For example, a single live event could have a day pass, a monthly subscription, and a yearly subscription — each as a separate offer. users pick the option that suits them, and you maximise your revenue potential. ### Offer types Offers can be configured in various ways, with different billing intervals and access periods. * **Pay-per-view (TVOD)**: A one-time purchase that grants access to a specific piece of content or a defined set of content. Ideal for standalone events, premium replays, or tournament passes. * **Subscription (SVOD)**: A recurring payment that grants ongoing access to a content catalogue. Ideal for season-long or year-round access where fans pay weekly, monthly, or annually. * **Time pass / bundle**: A one-time purchase that grants access to a package of content, e.g. a weekend pass to an entire tournament, or season access to a competition. Subscription billing cycles are managed by a payment service provider like [Stripe](/guides/monetization/offers/stripe). Motto lets you connect your offer to a "product" you create with that provider. ## Prerequisites Before you can start monetizing your content with offers, you must first connect a payment provider. Motto currently integrates with [Stripe](/guides/monetization/offers/stripe). ## Get started You can create offers using the Motto Studio, which is recommended for most users. Alternatively, you can create offers programmatically using the Motto API. First, navigate to the [Offers](https://studio.mottostreaming.com/monetization/offers) section in the Motto Studio. Click on the "New offer" button to get started. Most of the form fields are self-explanatory, but there are a few we want to highlight here. * **Connect to external product**: check this box if you want to create a subscription. In that case, you must enter the product ID of the payment provider (e.g. Stripe). To learn how to create such products, we refer to the provider documentation. * **Access control - billing period**: this defaults to "One time", meaning the user only pays once (not recurringly). This can only be set to recurring values like "monthly" when you connect this offer to an external product. * **Access control - access period**: this defaults to "Forever", meaning the user's entitlement to this content will not expire. Other options (e.g. 48 hours) means they will lose their entitlement to this content after that the configured amount of time has passed, counting from the moment of their purchase. This only applies when "billing period" is set to "one-time"; for recurring payments, the access period is controlled by the payment provider. * **Priority**: when a user tries to access content on your OTT platform, the available offers are shown to your user in order of priority, where higher priorities are shown first. * **Concurrency limit**: this is the amount of devices that are allowed to watch content from the same account simultaneously. For more information, see [concurrency control](/guides/streaming/video-protection/concurrency-control). When you want to create a PPV offer, i.e. an offer that is for a single piece of content, it is faster to create an offer while creating the event itself. Follow the normal steps for creating an event. When arriving at the final step, you will be shown the option to "Add Offer". When doing so, you will enter a normal offer creation form (as described in the previous section), with the exception that you do not have to choose which content this applies to, as it is automatically connected to your event. You may already see other offers when creating a new event. This is because you have already created an offer that includes this content via associated metadata (e.g. a competition). Such offers can only be removed from the event by changing the content targeting of that offer. If you do not already have **Require Authentication** and **Require Entitlements** configured, this will be configurable in the Video Protection section of the event editor. See [Create Offer](/reference/studio-api/monetization/offers/v1/create-offer). ## Next steps * [Stripe integration](/guides/monetization/offers/stripe) — connect your Stripe account to process payments * [Transactions](/guides/monetization/transactions/transactions) — view and understand purchases made by your users # Stripe Source: https://docs.mottostreaming.com/guides/monetization/offers/stripe How to create and configure the Stripe payment gateway integration in Motto ## Introduction Motto offers an integration with Stripe, which makes it easy to monetize your content through subscriptions or one-time purchases. To enable this integration, you need to create and configure Stripe API keys in your Motto project. ## Where to find your Stripe API keys Motto needs two types of keys for a successful integration with Stripe: * **Publishable key**: Used for client-side operations, such as tokenizing payment information * **Secret key** (or **restricted key**): Used for server-side operations, such as creating charges and managing subscriptions ### Finding your API keys 1. Log in to your [Stripe Dashboard](https://dashboard.stripe.com/) 2. Navigate to the "Developers" section in the left-hand menu (near the bottom) 3. Click on "API keys" 4. Copy your "Publishable key". It should start with `pk_live_` for live mode or `pk_test_` for test mode. 5. For the "Secret key", choose one of the options below: This is the simplest option and provides full access to the Stripe API for your integration. Assuming a secret key does not already exist, you can create one by following these steps: 1. Click on "Create secret key" 2. Select "Building your own integration" 3. Copy the generated secret key. It should start with `sk_live_` for live mode or `sk_test_` for test mode. If you want to manage fine-grained permissions, you can create a "Restricted key" instead: 1. Click on "Create restricted key" 2. Select "Providing this key to another website" 3. Enter a name for this key and `https://mottostreaming.com` as the URL 4. Tick the box "Customise permissions for this key" 5. Leave the default permissions, and adjust by adding `write` permissions on the following APIs (if not already done): * Checkout Sessions * Invoices * Subscriptions * Webhook Endpoints * Prices * Payment Intents * Payment Methods * Charges * Customers 6. Click "Create key" and copy the generated restricted key. It should start with `rk_live_` for live mode or `rk_test_` for test mode. 7. Copy the generated restricted key. Stripe may require you to go through a verification process before you can create API keys, especially for live mode. Follow the instructions provided by Stripe to complete this process. We recommend testing your integration first before going live. To do this, you'll need to obtain keys from Stripe's test environment by enabling "Test mode" in the Stripe Dashboard (click on your organization name top-left -> Switch to sandbox -> Test mode). Follow the same steps as above to get your test keys. ## Configuring Stripe in Motto To configure Stripe in the Motto Studio, navigate to OTT -> Integrations -> Stripe. When clicking on "Connect", you will see the following form appear: If possible, provide the credentials for both the production and the test environments. If you're still in the experimental phase, at least provide the test credentials, so that you can test the integration without needing a real creditcard. Make sure to toggle on "enable" on the integration after you save the Stripe credentials. ### Caveats It is good to keep the following in mind, as you integrate Stripe with Motto. #### Test payments If you want to test payments on your OTT platform without using a real creditcard, and you've provided the Stripe test credentials as described above, you must also change your user account to a "Tester" role. Do this by navigating to Users -> Search for your user -> Edit user. After you change the role of a user account, the change will only apply once you sign out and back in again on the OTT platform. #### Webhooks in Stripe When you use the Stripe integration form in the Motto Studio, the Motto backend will call the Stripe API to configure various webhooks. This ensures that Motto is notified of any relevant activity within your Stripe account (like a new payment or subscription being created). You **must not** alter or remove these webhooks from your Stripe account, otherwise the Stripe integration will fail. # Transactions Source: https://docs.mottostreaming.com/guides/monetization/transactions/introduction Understand how transactions work and where to find an overview of all purchases. ## Introduction A transaction represents a single payment made by a viewer on your platform. Every time a viewer buys access to your content — whether through a one-time payment or a recurring subscription charge — Motto records it as a transaction. Transactions are closely tied to the [offers](/guides/monetization/offers/offers) you have configured. When a viewer selects an offer and completes payment, a transaction is created and the viewer is granted access to the associated content via an [entitlement](/guides/streaming/video-protection/other#entitlements). ## Get started While you can always view your transactions directly with the payment service provider (e.g. Stripe), it can be more convenient to view them directly in the Motto Studio. To do so, navigate to Monetization -> [Transactions](https://studio.mottostreaming.com/monetization/transactions). You will find a list of transactions on this page, along with a summary of your total revenue and transaction count. You can apply filters to these transactions using the filters icon in the top-left. These filters will apply both to the transactions list and the summarized information. While this dashboard provides a useful insight in your transactions, it is recommended to rely on the payment service provider's reporting tools for accounting purposes. ## Next steps * [Offers](/guides/monetization/offers/offers) — create and manage the offers your viewers can purchase * [Stripe integration](/guides/monetization/offers/stripe) — connect your Stripe account to process payments # Custom domain Source: https://docs.mottostreaming.com/guides/ott/custom-domain How to use a custom domain on your Motto OTT platform Every Motto project automatically gets assigned a unique subdomain that can be used to access the OTT platform. Typically, this is useful while configuring and testing your OTT platform. In your production environment, you may want to use your own domain name for your fans to see. This document explains how to configure your DNS settings to achieve this. ## Prerequisites Before you start, make sure you have the following: * A domain name that you own * Access to the DNS settings of that domain name * Patience, as DNS changes can take up to 48 hours to propagate ## Get Started ### Option 1: Use a subdomain If you want to use a subdomain of your domain name for the OTT platform (like [https://tv.mydomain.com](https://tv.mydomain.com)), you will only need to configure a `CNAME` record in your DNS settings. This record is uniquely generated for your project by Motto, and is currently not exposed via the API or Studio. Please reach out to us at [info@mottostreaming.com](mailto:info@mottostreaming.com) to obtain it. Once the Motto team has sent you the CNAME record, follow these steps: 1. Log in to your domain name registrar's website. 2. Find the DNS settings for your domain name. 3. Add a new `CNAME` record with the following settings: * **Name**: `tv` (replace `tv` with the subdomain you want to use) * **Type**: `CNAME` * **Value**: The unique CNAME value the Motto team sent you 4. Save your changes. ### Option 2: Use the root domain If you want to use the root domain of your domain name for the OTT platform (like [https://mydomain.com](https://mydomain.com)), there are two different ways to configure this: This is the easiest way to configure your root domain to point to the OTT platform, but it requires that you use the `www` subdomain. Modern web browsers do not show the `www` subdomain in the address bar, so this is often not a problem. 1. Follow the steps in the "Option 1" section above, and use `www` as the subdomain. 2. Configure your domain name registrar to redirect the root domain to the `www` subdomain. Depending on your domain name registrar, this works a little differently: * **GoDaddy**: [Redirect your domain](https://www.godaddy.com/help/forward-a-domain-12123) * **Namecheap**: [Redirect your domain](https://www.namecheap.com/support/knowledgebase/article.aspx/385/77/how-can-i-set-up-a-url-redirect-for-my-domain) * **Squarespace**: [Redirect your domain](https://support.squarespace.com/hc/en-us/articles/214767107-Forwarding-a-Squarespace-domain) * **Other registrars**: Please refer to your registrar's documentation. This option comes at an additional cost of roughly 25 EUR per month. If you want to use the root domain without the `www` subdomain, you will need to change the nameservers of your domain name. Reach out to the Motto team to obtain the correct nameservers. Please include for which Motto project this is, and for which domain you are requesting the nameservers. Once you have obtained the nameservers, follow these steps: 1. Log in to your domain name registrar's website. 2. Find the domain nameservers settings for your domain name. 3. Replace the existing nameservers with the ones provided by the Motto team. Typically, this will be two nameservers. 4. Reach out to the Motto team to confirm that the nameservers have been set up correctly. Once the team confirms this, your domain name will be correctly configured. A consequence of this approach is that Motto controls all DNS records on this domain, which it does via Cloudflare, a trusted cloud and web security provider. # Hero banners Source: https://docs.mottostreaming.com/guides/ott/hero-banners ## Introduction Hero banners are a powerful way to showcase your most important content on your OTT platform. They can be used to highlight new releases, special events, or any other content that you want to draw attention to. You can display hero banners at the top of your OTT pages on the web and in the apps, but you can also place them in other parts of your page structure, like in the middle as a visual separator between two sections. This can also be a good way to showcase sponsorships and partners on your platform. ## Get Started You can get started using the Motto Studio, which we recommend for non-technical users. Alternatively, you may get started by using the Motto API. The following steps will guide you through the process of setting up one or more hero banners via the Studio. #### Creating banner(S) First, navigate to the "OTT" tab in the Studio. You will see a section titled Banners. Click on the "New" button to start creating a new banner collection. A banner collection allows you to group multiple banners together, which then lets you display them in a carousel on your OTT platform. A new page will open that prompts you to enter some basic properties for your banner collection. First, the ID field. If this banner collection is for the homepage, you might give it the ID `homepage`. If it is for a specific entity page, like `FC Barcelona`, you might give it the same ID as that entity (which is typically a string of 21 characters). In fact, this is required if you want to display the banner collection on that entity page, as Motto will automatically look for a banner collection with the same ID as the entity. The name should be something descriptive, like "Homepage banners" or "FC Barcelona banners". This is only used for your own reference and is not seen by users on the OTT platform. Next, click on "Add new banner". A sidebar will appear that allows you to enter the details for your banner, like: * the name (for internal use only). * the destination URL (where the user will be taken when they click on the banner); can be left empty if you do not want the banner to be clickable. * the text(s) that should appear on the banner. You can add multiple texts, and they will be displayed from top to bottom, with the first text being the most prominent. * the image that should be displayed on the banner. You can upload one or more images, for different breakpoints (e.g. mobile, tablet, desktop). Press "Save" to create the banner. Then press "Save" again to create the banner collection. If you prefer using the Studio API to interact with the Motto platform, you can follow the following steps to achieve the same result as described in the "Via the Studio" section. 1. Call the [Create Banner](/reference/studio-api/cms/banners/v1/create-banner) endpoint. 2. If you need to upload a new image for your banner, you can do so by creating an [asset upload session](/reference/studio-api/streaming/uploads/v1/create-upload) and uploading the image to the `signed_url` provided in the response. For more information, [see here](/guides/assets/images). 3. Once you have created one or more banners, you must create a new banner collection to group them together. You can do this by calling the [Create Banner Collection](/reference/studio-api/cms/banner-collections/v1/create-banner-collection) endpoint. # Introduction Source: https://docs.mottostreaming.com/guides/ott/introduction Create your own OTT platform with Motto in minutes! Motto is built for sports organizations that are interested in a turnkey solution to create their own OTT platform. With Motto, you can create your own OTT platform in minutes and start streaming your content to your audience. The goals of Motto's OTT platform are to: * Be easy to use, so that even the most non-technical users can use our services; * Be cost-effective, so your financial resources can instead be directed towards building an audience; * Offer a white-label solution so your brand can shine; * Be fully focused on sports streaming, because that is what we know best; * Be scalable, so you can grow your audience without worrying about infrastructure. * Be fast to market, so you can start streaming as soon as possible. * Focus on reducing the technical and operational complexity of professional OTT delivery. ## How it works Once you sign up with Motto, you will be given access to your own OTT platform immediately. You will be able to customize your platform with your own styling and branding. Then, after just a few clicks, you can start uploading your VOD content, or start scheduling your upcoming sports live streams. There's nothing more to it! ## Get Started A guide for this will follow soon, but in the mean time please [reach out](mailto:info@mottostreaming.com) to us for more information. # Channels Source: https://docs.mottostreaming.com/guides/streaming/channels Providing a static RTMP/SRT ingest endpoint for a collection of live streams. ## Introduction When you use Motto to live-stream a sports match, typically you create a single event with a single live-stream attached to it. Motto then automatically generates a dedicated [stream key](/glossary/stream-key) along with an RTMP or SRT [ingest URL](/glossary/ingest), which you can plug into your streaming software or hardware. Sometimes, however, you may want to choose an existing stream key that your live-stream should attach to. For this purpose, Motto has introduced the concept of a "channel". There is a variety of scenarios where a channel may be useful, but the most common case is when it is slow or difficult to change the stream key in your streaming software or hardware, and you want to avoid having to reconfigure it frequently on that side. Examples of this are: * When you are broadcasting a tournament with rapid consecutive matches, and the (automated) camera takes a while to reconnect; * When you have a fixed camera on the side of a pitch that you want to use throughout a season without having to update it; * When you have a dedicated hardware encoder that is not easily reconfigurable; * When communications with a third-party broadcaster are slow, and it is not feasible to change the stream key on short notice. ## Get Started You can get started using the Motto Studio, which we recommend for non-technical users. Alternatively, you may get started by using the Motto API. The following steps will guide you through the process of configuring channels via the Studio. #### Step 1. Creating an ingest First, navigate to the "Settings" tab in the Studio. You will see a section titled Channels. Click on the "New" button to start creating a new ingest. A sidebar will appear that prompts you to enter a name. The name would typically be something that can uniquely identify a camera or broadcasting hardware, like "Camp Nou - pitch-side camera". After pressing "Save", a new ingest was created and should show up in the list. #### Step 2. Connecting a live-stream to the ingest The next step is to connect your live-stream to this ingest. You can do this while creating a new event, under the "advanced" options in the Streaming Settings section. Here you can select the ingest you just created. It is currently not possible to change the ingest of an existing event. If you need to do this, you will need to create a new event and associate the ingest with it. #### Step 3. Streaming to Motto When you are ready to start streaming to the channel, the Motto [video manager](/glossary/video-manager) should show that your signal is connected. **However, it will not start processing the signal until you "Activate" the channel for this stream.** This is necessary, because you may have connected many events to a single channel (e.g. a whole season of matches), and only one of those matches should actually use the signal at any time. By pressing "Activate", you will tell Motto that this event should start using the signal. At the end of the match, when pressing "End Live", the signal will no longer be used by the event. In theory you may have several events processing a signal from the same ingest concurrently. This is typically not desirable, except in niche cases like when you want the interlude between two tournament matches to be streamed to both events. If you prefer using the Studio API to interact with the Motto platform, you can follow the following steps to achieve the same result as described in the "Via the Studio" section. 1. Call the [Create ingest](/reference/studio-api/streaming/ingests/v2/create-ingest) endpoint. 2. Pass the `ingest_id` from step 1 to the [Create Live Stream](/reference/studio-api/streaming/live-streams/v2/create-live-stream) endpoint. Leave `accept_input` to false. 3. When streaming to the ingest server, call [Update Live Stream](/reference/studio-api/streaming/live-streams/v2/update-live-stream) with `accept_input` set to true. 4. When you are done streaming, call [Update Live Stream](/reference/studio-api/streaming/live-streams/v2/update-live-stream) with `accept_input` set to false, to prevent this ingest from affecting this video in the future. ## Next steps It may be cumbersome to manually "activate" and "deactivate" the channel for each stream separately. To solve this, Motto offers a way to automate these steps. In short, Motto can automatically turn on and off a stream listening on a channel from *x* amount of minutes before the start of an event, until *x* amount of minutes after the signal stops. To learn more, [reach out](mailto:info@mottostreaming.com) to Motto's support team. # Introduction Source: https://docs.mottostreaming.com/guides/streaming/configurations/introduction Powerful streaming configurability options ## Introduction At Motto we believe that you should have full control over your streams, even after they enter our platform. Depending on the content you are streaming, you may have different requirements for how your streams are processed and delivered. You may want to: * Deliver your stream to your audience in specific qualities (like 1080p or 4k); * Apply custom (sponsorship) overlays to your streams; * Configure an AI agent to look along with your stream and tag interesting moments. Our tools empower you to configure your streams as it suits your needs. ## Get Started Navigate to the individual section in the sidebar to learn more about the specific configuration options available to you. # Transcoder settings Source: https://docs.mottostreaming.com/guides/streaming/configurations/transcoder-settings Configure your streams to be processed at specific qualities, frame rates, etc. ## Introduction Transcoder settings allow you to configure how your streams are processed by Motto before they are delivered to your viewers. You may want to stream your most beautiful content in 4K quality for an optimal viewing experience, while wanting to stream free-to-watch content only in 480p as a low-cost solution. Or you may wish to configure your streams so that they are processed at custom bitrates, key-frame intervals, etc. It's all up to you. ## Get Started Currently, transcoder settings are available through the API; the Studio will be updated soon to support this feature. To customize your transcoder settings, you need to follow these steps: 1. [Create a transcoder configuration](/reference/studio-api/streaming/configurations/v1/create-configuration). Select the `CONFIGURATION_TYPE_TRANSCODER_STREAMS` type, and populate the `transcoder_streams` data field with your desired settings. Make sure to provide all the necessary data, otherwise the configuration may behave unexpectedly. 2. [Attach a live-stream](/reference/studio-api/streaming/configurations/v1/attach-workflow) to the configuration object you created in step 1. You can attach as many live-streams (also called workflows) as you'd like to a single configuration, so you do not have to create a new configuration for each one. You are now ready to start streaming with your custom transcoder settings! You may change these settings at any time, but those changes will not apply to streams that have already started. # Introduction Source: https://docs.mottostreaming.com/guides/streaming/events/introduction Motto was built with live-streaming sports in mind, as our founding team comes from sports OTTs like [MyCujoo](https://en.wikipedia.org/wiki/MyCujoo), [Eleven Sports](https://en.wikipedia.org/wiki/Eleven_Sports) and [DAZN](https://en.wikipedia.org/wiki/DAZN). We aim to simplify live-streaming for any rights-holder or broadcaster of sports video content, by reducing technical and operational complexity of professional OTT delivery. Events are a central concept in any sports organization, because "match day" is what we all work towards! An event in Motto's systems represents a single sports match, press conference, scrimmage session, or anything else that has a start and end time in the real world. Events can be associated with one or more [live streams](/guides/streaming/events/live-streaming) and/or [VODs](/guides/streaming/events/vod). ## Get Started You can get started using the Motto Studio, which we recommend for non-technical users. Alternatively, you may get started by using the Motto API. The following steps will guide you through the process of setting up an event via the Studio. #### Creating an event First, navigate to the "Content" tab in the Studio. You will see a section titled Live & Upcoming. Click on the "New" button to start creating a new event. A sidebar will appear that prompts you to enter the event's details. Now enter the information for your event. You can leave the "Event" tab selected. Currently, only the event's title is required information, the rest can be left empty if desired. It is recommended to enter as much information as possible, as this information will show up on your OTT platform and can help with discoverability. For your stream configuration, what to configure depends on your use-case: * If you want to live-stream your event with a single camera angle, then the default configuration is sufficient. If you wish to live-stream with multiple camera angles, you an add more Stream entries using the plus icon. Go [here](/guides/streaming/events/live-streaming) for more details. * If you want to upload a finished video, you can do so by selecting the "Video Upload" option. Go [here](/guides/streaming/vod) for more details. You can also associate thumbnail with your event. This will be used if you also use Motto's OTT platform, as it will show up in the carousel component. After pressing "Save", your event is now created! If you prefer using the Studio API to interact with the Motto platform, you can follow the following steps to achieve the same result as described in the "Via the Studio" section. 1. Call the [Create Event](/reference/studio-api/cms/events/v1/create-event) endpoint. 2. (Optionally) if you have already created a video previously, you can associate your `video_id` with the event in the `video_ids` array. ## Next Steps You have now created a basic event, which is useful when you are just starting on your Motto journey, but in most real scenarios you will want to associate more metadata with your events. For example, you may wish to associate team or competition information with the event, for improved discoverability on your OTT platform, and so that this information can be displayed in your OTT platform's UI. In Motto, this work by creating [Custom Types](/guides/cms/content-types). Our support team can also help you with this, so don't hesitate to reach out to us! # Live streaming Source: https://docs.mottostreaming.com/guides/streaming/events/live-streaming Learn how to live stream to Motto. ## Introduction Motto operates a bespoke streaming platform that was built from the ground up to meet the demands of modern sports streaming. It has been built with **vertical integration** of all Motto services in mind, like our state-of-the-art [video protection](/guides/streaming/video-protection/introduction) capabilities, our highly configurable [OTT platforms](/guides/ott/introduction), and of course our **monetization** services like paywalls, ads & sponsorship, and data syndication. The Motto streaming platform has been built to be: * Optimized for live-streaming sports at low latency; * Supportive of a wide range of video sources, signals and profiles; * Allow simulcasting (live syndication) to betting brokers and other data partners; * Tolerant of unstable networks (e.g. 4G connections in a busy stadium); * Highly configurable (e.g. custom output qualities, video protection options, etc.); * Easily integrated into OTT platforms (including [our own](/guides/how-to/create-an-ott)); * Highly scalable and tolerant of sudden spikes in viewership. ## Get Started You can get started using the Motto Studio, which we recommend for non-technical users. Alternatively, you may get started by using the Motto API. The following steps will guide you through the process of setting up a live stream via the Studio. #### Creating a live stream When you wish to stream live content, you will need to create a live stream object first. This object will contain all the information needed to stream to Motto. When using the [Studio](https://studio.mottostreaming.com), live stream creation is a part of the process of creating a new [event](/guides/cms/events) or [creative work](/guides/cms/creative-works). When doing so, you will be asked to create one or more "streams". Each individual stream that you create receives its own RTMP/SRT ingest URL and stream key, and can thus be streamed to separately. This means you can associate more than one stream to a single event or creative work, which may be desirable when you want to stream e.g. multiple camera angles for the viewer to choose from. You are also presented with the option to create a "backup stream". For more information on this, read about our [failover solution](/guides/streaming/failover). By default, you can leave this toggle turned off. #### Streaming to Motto Once you have created a live stream object, you can use the RTMP/SRT ingest URL and stream key to stream to Motto. The stream key should be shared only with trusted parties, as it allows anyone with access to it to stream to your environment. You can find these details in the Studio's [Video Manager](/glossary/video-manager) page. Look for the "Video Settings" tab to find the information you need. For more information on how to use streaming software to send a live stream signal to our platform, see an example on [streaming via OBS](/guides/how-to/live-stream). #### Publishing the stream Once you have started streaming to Motto's servers, this stream is not yet available to be watched by your viewers. You will first need to publish the stream, which can be done by clicking the green "Go Live" button in the top bar, or by setting the visibility to "published" in the Video Settings tab. Now, your viewers can watch the stream at their leisure on your Motto-based [OTT platform](/guides/how-to/create-an-ott), or on your own website using our [embeddable player](/guides/how-to/embed-our-player). #### After the stream When you are done streaming, you can stop the stream by clicking the red "End Live" button, and simply disconnect the RTMP/SRT signal. The live-stream will automatically become available as a VOD stream for your viewers. By default, a recording of your entire live-stream will also be made available via the Studio. This allows you to download the asset and use it for any other purpose you may have for it, or simply to keep as an offline backup. You can find the downloadable asset in the Events & Creative Works list page, by clicking on the vertical ellipsis. You can also find an overview of all of your downloadable assets in the [Asset Manager](/guides/assets/introduction). If you prefer using the Studio API to interact with the Motto platform, you can follow the following steps to achieve the same result as described in the "Via the Studio" section. 1. [Create a live-stream object](/reference/studio-api/streaming/live-streams/v2/create-live-stream). Store the `video_id` and `ingest_id` 2. [Find an ingest server](/reference/studio-api/streaming/ingest-servers/v2/list-ingest-servers) 3. [Retrieve the ingest object](/reference/studio-api/streaming/ingests/v2/get-ingest) using the `ingest_id` from step 1 4. Start streaming, e.g. [via OBS](/guides/how-to/live-stream) 5. [Retrieve the video](/reference/studio-api/streaming/videos/v1/get-video) using the `video_id` from step 1. 6. [Publish the playlist](/reference/studio-api/streaming/playlists/v1/update-playlist) by setting the `visibility` to `published` on the video's `playlist_id` from step 5. Your stream is now live and available to be watched by end users! However, unlike in the Studio guide above, we have not yet associated your video to a Motto [event](/guides/cms/events). This is helpful if you: * want to contextualize your video by associating metadata (like the teams playing in your match, or the competition it belongs to). * want to use the Motto OTT platform or its component library for easy integration into your own OTT platform integration. You can read more about [creating an event](/guides/cms/events). From there, simply update the `video_ids` array on your newly created event with the `video_id` you retrieved in step 5 above. #### More information For more technical details about live streams, go [here](/glossary/live-stream). ## Next Steps From here, you may want to look into [creating highlights](/guides/streaming/highlights/introduction) from your live-stream. Separately, you may look into [our OTT platform](/guides/how-to/create-an-ott) and [component library](/guides/ott/component-library/introduction) to figure out how to show your new Motto video content to your fans. # VOD Source: https://docs.mottostreaming.com/guides/streaming/events/vod Learn how to upload Video-On-Demand (VOD) content to Motto. ## Introduction Once a Motto live-stream ends, it automatically becomes a Video-On-Demand (VOD) stream. This means that your users can watch the stream after it has ended at their leisure. However, you may also want to upload VOD content that was not streamed live. This guide will show you how to do that. ## Get Started #### Uploading When using the [Studio](https://studio.mottostreaming.com), VOD creation is a part of the process of creating a new [event](/guides/cms/events) or [creative work](/guides/cms/creative-works). When doing so, you will be asked to create one or more "streams", after which you can select "Video Upload". If you are uploading a large file (like a full sports match), this may take a while, and it is important to keep your browser window open during the upload. You can associate more than one upload to a single event or creative work, which may be desirable when you want to upload e.g. multiple camera angles for the viewer to choose from. #### Processing Once your file is uploaded, our systems will take some time to process your file(s). This may take a while, depending on the size of the file. #### Publishing Once your video file is fully processed, you can press the "Save" button in the event/creative work creation sidebar. You can then navigate to the Studio's [Video Manager](/glossary/video-manager) and see your video appear there. However, it is not yet available to be watched by your viewers. You will first need to publish the video, which can be done by setting the visibility to "published" in the Video Settings tab in the Video Manager. If you prefer using the Studio API to interact with the Motto platform, you can follow the following steps to achieve the same result as described in the "Via the Studio" section. 1. Create an [asset upload session](/reference/studio-api/streaming/uploads/v1/create-upload) (e.g. mp4 file) 2. Upload your file to the `signed_url` provided in the response from step 1. 3. [Create a VOD object](/reference/studio-api/streaming/vods/v1/create-vod) with the `reserved_asset_id` from step 1. 4. [Start processing](/reference/studio-api/streaming/vods/v1/process-vod) the VOD object from step 3. 5. [Retrieve the video](/reference/studio-api/streaming/videos/v1/get-video) using the `video_id` from step 4. 6. [Publish the playlist](/reference/studio-api/streaming/playlists/v1/update-playlist) by setting the `visibility` to `published` on the video's `playlist_id` from step 5. Your stream is now live and available to be watched by end users! However, unlike in the Studio guide above, we have not yet associated your video to a Motto [event](/guides/cms/events). This is helpful if you: * want to contextualize your video by associating metadata (like the teams playing in your match, or the competition it belongs to). * want to use the Motto OTT platform or its component library for easy integration into your own OTT platform integration. You can read more about [creating an event](/guides/cms/events). From there, simply update the `video_ids` array on your newly created event with the `video_id` you retrieved in step 5 above. ## Next Steps From here, you may want to look into [creating highlights](/guides/streaming/highlights/introduction) from your VOD. # Highlight clipping Source: https://docs.mottostreaming.com/guides/streaming/highlights/clipping ## Introduction Highlight clips are short video assets that were generated based on a longer video. Clips can be generated from any Motto live-stream or VOD, or from any externally hosted video content that has a valid HLS or Dash [playlist](/glossary/playlist). The clipping feature can generate a new video [asset](/guides/assets/introduction) from any *start* and *end* points of the original video, such that you are able to download an mp4 file. Optionally, it can also generate a new [video](/glossary/video) and [playlist](/glossary/playlist) for you, so that it can be played by your viewers in any video player. Highlight clips also work in tandem with the [stitching](/guides/streaming/highlights/stitching) feature, which allows you to create a a single video from a collection of clips. ## Get Started Motto offers highlight clipping and stitching in various ways: To generate a highlight clip using the Studio API, follow these steps: #### 1. Determine your playlist URL If you are using Motto for your live-streams and VODs, then this is the `public_url` on the [playlist](/reference/studio-api/streaming/playlists/v1/get-playlist) (and the playlist ID can be retrieved from the [video](/reference/studio-api/streaming/videos/v1/get-video). Alternatively, you can find it in the [Video Manager](/glossary/video-manager): If you are using an external source, this can be any valid and accessible HLS playlist. #### 2. Create a clip Call the [create clip](/reference/studio-api/streaming/clips/v1/create-clip) endpoint with your playlist URL from step 1. #### 3. Retrieve the asset With the `reserved_asset_id` in the response from the previous step, you can [retrieve the asset](/reference/studio-api/streaming/assets/v1/get-asset-url) for the clip once the clip reaches `STATE_READY`. This may take a bit of time, depending on the length and complexity of the clip. Generating a highlight clip via the Studio's Video Manager is an indirect operation. Rather than indicating which exact parameters should be used for creating a clip, you simply *annotate* (or: *tag*) your video by indicating what happens at certain points in your video, and let the system figure out what kind of clip should be generated based on this information. For example, if you indicate that a "Goal" just happened, the system may be pre-configured to generate a clip that starts 20 seconds before the goal and ends 20 seconds after the goal. This approach is generally recommended, as these video tags can be used in other contexts as well (e.g. to draw a goal inlay in your stream, or trigger a webhook call to your OTT website/app to update the UI accordingly). #### How to annotate 1. Go to the [Video Manager](/glossary/video-manager) and select the video you want to annotate. 2. Switch to the "Video tagging" tab. 3. Click any of the tag buttons to add a tag to the video at the current time of the video player. The kinds of tags that are available are fully configurable; they are not bound to the kinds shown below. Please [reach out](mailto:info@mottostreaming.com) for help with setting up different kinds of tags. This feature is currently available to a select few customers, but if you are interested in using this feature, please [contact us](mailto:info@mottostreaming.com) ## Next Steps Now that you have generated one or more highlight clips, Motto recommends looking into the [stitching](/guides/streaming/highlights/stitching) feature. For most organizations that live-stream sports, the ability to auto-generate highlight reels for fans to watch right after the match is done is a powerful value addition. # Introduction Source: https://docs.mottostreaming.com/guides/streaming/highlights/introduction Automated clipping and stitching of highlights in your live and VOD streams Motto recently released an AI agent in beta that can fully automate the process of detecting highlights in your live-stream, create clips, stitch them together and show them on your OTT platform! A common requirement in sports streaming is to generate highlight clips based on interesting moments (like goals), for example to share to social media. Another common one is to "stitch" certain highlight clips back together into a single reel, so fans can watch a condensed version of the game. Motto aims to make your video workflows easier when it comes to these common operations. We offer highlight clipping and stitching in various ways: 1. Via our [API](/reference/studio-api/streaming/clips/v1/create-clip), against any video content (including content not hosted within Motto). This is great for integration into external video pipelines. 2. Via our [Video Manager](/glossary/video-manager), easily and fully automated when clicking buttons like "Goal" or "Corner Kick"! 3. **\[New]** Via our AI agents, which can automatically detect interesting moments in your video content and generate clips for you. Please reach out for more information. You can find more information here on [clipping](/guides/streaming/highlights/clipping) and [stitching](/guides/streaming/highlights/stitching). # Stitching clips Source: https://docs.mottostreaming.com/guides/streaming/highlights/stitching ## Introduction This guide is coming soon! Please [reach out to us](mailto:info@mottostreaming.com) for further information if you are interested in this feature. # Simulcasting Source: https://docs.mottostreaming.com/guides/streaming/simulcasting Also called re-streaming, multicasting, live syndication, and stream forwarding. ## Introduction Sometimes, live-streams should not only be shown on [your own OTT platform](/guides/how-to/create-an-ott), but must also be delivered to other destinations. For example, you may want to: * Stream to YouTube, Facebook, or other social media platforms. * Syndicate your content to betting partners. * Deliver your content to an external video-processing pipeline. For this purpose, Motto supports simulcasting, which means that you can broadcast your RTMP or SRT signal to Motto, and from there it will be sent out to all of your configured destinations. This way, you don't have to juggle all of these signals yourself! ## Get started You can get started using the Motto Studio, which we recommend for non-technical users. Alternatively, you may get started by using the Motto API. The following steps will guide you through the process of setting up a simulcast via the Studio. #### Adding a simulcast To add a simulcast, visit the the Studio's [Video Manager](/glossary/video-manager) page. Look for the "Simulcasting" tab, and click on the "Add new simulcast" button. From there, you will be prompted to add a name and URL. The name can be anything you'd like it to be, and serves only as a visual identifier. The URL should be the destination where you want to send the stream to, and can be obtained from the target provider. If you are simulcasting TO the Motto platform, the URL would look like e.g.: `rtmp://ingest-rtmp.eu.mottostreaming.com/live/f3d397f02fao94685600ab8a6adggfa` #### Removing a simulcast Removing a simulcast is as simple as clicking on the trash icon next to the simulcast you want to remove. This can be done at any time. If the stream is currently live, the stream will immediately stop being simulcast to the destination. The following steps will guide you through the process of setting up a simulcast via the API. 1. Ensure that you have already [created a live-stream](/guides/streaming/events/live-streaming) 2. Add a [simulcast target](/reference/studio-api/streaming/simulcasts/v1/create-simulcast) to your live stream 3. [Start streaming](/guides/how-to/live-stream) to Motto That's it! Your simulcast target should start receiving the signal. If you add a simulcast target to a live-stream that has already started, you must make sure to call the [start simulcast](/reference/studio-api/streaming/simulcasts/v1/start-simulcast) endpoint. # Spiideo Source: https://docs.mottostreaming.com/guides/streaming/spiideo/integration Automatically connect your Spiideo AI-cameras with Motto's streaming platform and CMS ## Introduction One of Motto's driving principles is to make it as easy as possible to get started with sports streaming. We believe that Spiideo, a sports-focused provider of AI-camera technology, shares this mission. By automating the production of sports broadcasts, especially at large volumes, opportunities are being unlocked for sports organizations that did not exist before. But even with AI-produced broadcasts, there is still a lot of work to be done to get the content scheduled, connected and published. A common complaint from sports organizations is that they have to perform a lot of duplicate work between Motto and Spiideo when it comes to scheduling events, managing teams and other metadata, and then connecting the two systems by copying RTMP/SRT details. This is especially inconvenient near game-time, when some last minute changes may occur and deadlines are tight. This is where the integration between Motto and Spiideo comes in. This integration allows you to automatically synchronize all of your Motto events with your Spiideo environment, create and manage the teams in Spiideo, and assign the correct "scenes" (Spiideo cameras) to the broadcasts. All based on what you've already scheduled in Motto. Simple. ## How it works The first step is to ensure that you know how to schedule events in Motto. If you are not familiar with this, please read the [introduction on events](/guides/streaming/events/introduction) first. For a successful integration, we must connect Motto to Spiideo. For this, a number of steps are required. We will go over each step here. This guide uses the Motto Studio API. Note that these steps are only required once, and then the integration will work automatically for all future events. Even so, a Studio interface is on our roadmap. ### Step 1 For Motto to be able to communicate with Spiideo, you must first create a "Spiideo integration" object. This will contain the necessary credentials to connect to your Spiideo environment. You must collect the following information from your Spiideo account: * **Account ID** * **User ID** * **Client ID** * **Client Secret** Once you have collected these, you must call the [create Spiideo integration](/reference/studio-api/integration/spiideo/v1/create-spiideo-integration) API endpoint. Have a good look at the other parameters on that endpoint, as they are important to how your Spiideo integration will behave in production. ### Step 2 Typically, a sports event in Motto will have references to a location "entity" like a `stadium`, `arena` or `field`. We must relate such Motto entities to Spiideo "scenes", to allow the integration to automatically select the correct Spiideo cameras for the event. You can do this by calling the [create entity mapping](/reference/studio-api/integration/spiideo/v1/create-entity-mapping) API endpoint. You must provide the entity ID and entity type of the Motto entity, and the `scene_id` of the Spiideo scene (which you can find in the Spiideo web interface). Do this for every Spiideo scene you operate. If you choose to skip some scenes, no Spiideo broadcasts will be scheduled for those. You can assign a description for your convenience to help remind you of which entity mapping this is, later on, but it is not required. If you create a Spiideo scene mapping after you have already scheduled Motto events, no problem! Motto will synchronize any scheduled (future) event into Spiideo within minutes. ### Step 3 Next, we must ensure that the integration understands your Motto event structure. After all, Motto's CMS allows for a lot of flexibility in how you structure your metadata, but this also means the system cannot predict where to find the information it needs to schedule the broadcasts in Spiideo. To help it along, you must create an "event type mapping" for each event type that you use in Motto. You can do this by calling the [create event type mapping](/reference/studio-api/integration/spiideo/v1/create-event-type-mapping) API endpoint. ### Step 4 (Optional) In the previous step, you configured the sport that the event type is associated with (though you may have left it empty, which is allowed if you configure the sport on the team type mapping in step 6 instead). If you configured a sport field to reference an entity, you must help Motto understand which sport this is in Spiideo. You can do this by calling the [create entity mapping](/reference/studio-api/integration/spiideo/v1/create-entity-mapping) API endpoint. ### Step 5 (Optional) By default, if you allow Motto to create teams in Spiideo, it will generate a team abbreviation based on the team name. However, you might already have a specific abbreviation for each team on your existing Motto events, which you would like to use in Spiideo as well. You can also configure the sport of the team, if it deviates from the default value configured in step 1. You can do this by calling the [create team type mapping](/reference/studio-api/integration/spiideo/v1/create-team-type-mapping) API endpoint. ### Step 6 (Optional) If you stream multiple sports and you want each sport to have a different broadcast duration, you cannot simply rely on the default values that we configured in step 1. Instead, you must configure a sports-specific broadcast duration for each sport that you stream. You can do this by calling the [create sport configuration](/reference/studio-api/integration/spiideo/v1/create-sport-config) API endpoint. ### Step 7 (Optional) If you chose to set `sync_teams` to `false` in step 1, this means Motto will not automatically create new teams in Spiideo if they do not exist yet. While we do not recommend doing so, you can still create teams manually in Spiideo, and then map them to the teams in Motto. You can do this by calling the [create entity mapping](/reference/studio-api/integration/spiideo/v1/create-entity-mapping) API endpoint. Similar to the entity mapping in step 2, you must provide the entity ID and entity type of the Motto team entity, and the `team_id` of the Spiideo team (which you can find in the Spiideo web interface). # Concurrency control Source: https://docs.mottostreaming.com/guides/streaming/video-protection/concurrency-control Limit the number of simultaneous devices that can stream from a single account. ## Introduction Concurrency control allows you to limit how many devices can simultaneously stream content from a single viewer account. This is a common requirement from rights holders who want to prevent credential sharing on paid content. Concurrency control only works in combination with [entitlement verification](/guides/streaming/video-protection/other). The allowed number of concurrent devices is defined on the **offer** that a viewer buys. ## Get Started You can get started using the Motto Studio, which we recommend for non-technical users. Alternatively, you may get started by using the Studio API. 1. Navigate to **Monetization** → **Offers** in the Motto Studio. 2. Create a new offer or edit an existing one. 3. In the offer configuration, set the **concurrency limit** to the desired number of simultaneous streams per account. 4. Make sure concurrency control is **enabled** on your video protection ruleset. 1. [Create or update an offer](/reference/studio-api/monetization/offers/v1/create-offer) and set the concurrency limit field to the desired number of simultaneous streams. 2. Enable concurrency control on your [video protection ruleset](/reference/studio-api/streaming/video-protection/v1/create-ruleset). Concurrency control can be toggled on or off on the ruleset at any time. The actual limit is always determined by the offer the viewer has purchased. ## Next Steps * [Entitlement verification](/guides/streaming/video-protection/other) — control which users can access paid content * [Target selection](/guides/streaming/video-protection/target-selection) — scope your rulesets to the right content # Domain pinning Source: https://docs.mottostreaming.com/guides/streaming/video-protection/domain-pinning Limit the domain names that video can be played from ## Introduction Motto offers the ability to enhance your video protection by limiting the web domains that your video can be played from. This means that unauthorized websites will not be able to play your video content, thus preventing your content from leaking and costs increasing unnecessarily. This feature only works on web browsers and is not supported on mobile apps that attempt to play your video content. ## Get Started You can get started using the Motto Studio, which we recommend for non-technical users. Alternatively, you may get started by using the Motto API. To enable domain pinning, first navigate to the "Settings" section in the Motto Studio, and select the "Video protection" tab. Here you can create a new ruleset by clicking the "New ruleset" button, or edit an existing ruleset if you are already applying other protection measures to the same content. In the creation form, you can check the option to enable domain pinning. In the textarea that appears, enter one domain per line that you wish to allow playback from. Each item should take the format of `example.com`, `subdomain.example.com` or `*.example.com` (for wildcard matching). To enable domain pinning, you must [create a video protection ruleset](/reference/studio-api/streaming/video-protection/v1/create-ruleset) with the `allowed_domains` array containing the domains you wish to allow playback from. Each item should take the format of `example.com`, `subdomain.example.com` or `*.example.com` (for wildcard matching). Make sure to apply the ruleset to the content you wish to protect by selecting the appropriate target(s). For more information, see [selecting a target](/guides/streaming/video-protection/target-selection). The ruleset should apply within one minute of saving it. You can also update the ruleset at any time, and the changes will similarly apply within roughly one minute. Domain pinning relies on the `referrer` and `origin` headers, which are not commonly used in mobile/TV apps, are not always reliable on web. These headers can be spoofed by the client, so this should not be used as the only security measure. ## Next Steps Have a look at any of the other rights protection features that Motto offers: * [Geo-blocking](/guides/streaming/video-protection/geo-blocking) * [VPN blocking](/guides/streaming/video-protection/vpn-blocking) * [hotlink prevention](/guides/streaming/video-protection/hotlink-prevention) * [registration walls](/guides/streaming/video-protection/registration-walls) * [entitlement verification](/guides/streaming/video-protection/other) * [DRM](/guides/streaming/video-protection/other) # DRM Source: https://docs.mottostreaming.com/guides/streaming/video-protection/drm Digital Rights Management ## Introduction Motto offers digital rights management rules as a way to protect your content from unauthorized access and redistribution. To do this this, we use industry-standard encryption using DRM systems like Widevine, FairPlay, and PlayReady. ## Prerequisites Unlike most features in Motto, DRM must first be enabled on your by Motto's support team. This is needed because a successful DRM configuration requires some set-up work that cannot be done via the Studio or API. Specifically, you must provide an Apple Fairplay certificate, which you must [acquire](https://developer.apple.com/streaming/fps/) via Apple's Developer Program (look for "Deployment credentials"). ## Get Started You can get started using the Motto Studio, which we recommend for non-technical users. Alternatively, you may get started by using the Motto API. To enable DRM, first navigate to the "Settings" section in the Motto Studio, and select the "Video protection" tab. Here you can create a new ruleset by clicking the "New ruleset" button, or edit an existing ruleset if you are already applying other protection measures to the same content. In the creation form, you can check the option to enable DRM. In most cases, you can leave the "Hardware-based robustness" setting to "Standard". If you are streaming more premium content that requires an even higher level of protection (Widevine L1 or PlayReady SL 3000) for higher video qualities (e.g. 1080p and up), you can indicate this by selecting which qualities require this. Keep in mind that these qualities will not be playable by browsers like Chrome and Firefox, as they do not support these levels of protection. To enable DRM, you must [create a video protection ruleset](/reference/studio-api/streaming/video-protection/v1/create-ruleset) with the `drm.enabled` property set to `true`. Make sure to apply the ruleset to the content you wish to protect by selecting the appropriate target(s). For more information, see [selecting a target](/guides/streaming/video-protection/target-selection). ### Impact Once DRM has been turned on, the devices that your end users use to view your content will need to decrypt the content using a "DRM license". Motto will automatically generate these licenses for your users and your content, and the Motto video player will handle the decryption process. You may change these settings at any time. However, once you have started your live stream or upload, DRM keys will be provisioned. From that moment on you can no longer turn off DRM for this video. Reach out to us if you have doubts or have a more complex flow in mind. In order to support Apple devices, which require FairPlay, you must have a valid Apple Developer account and request a Fairplay certificate with them. Without this, playback will fail on Safari browsers, iOS & tvOS apps and Airplay when DRM is enabled. ## Next Steps Have a look at any of the other rights protection features that Motto offers: * [Geo-blocking](/guides/streaming/video-protection/geo-blocking) * [VPN blocking](/guides/streaming/video-protection/vpn-blocking) * [hotlink prevention](/guides/streaming/video-protection/hotlink-prevention) * [domain pinning](/guides/streaming/video-protection/domain-pinning) * [registration walls](/guides/streaming/video-protection/registration-walls) * [entitlement verification](/guides/streaming/video-protection/other) # Geo-blocking Source: https://docs.mottostreaming.com/guides/streaming/video-protection/geo-blocking Video protection on streams through geo-blocking. ## Introduction Motto offers geo-blocking protection rules as a way to prevent your end-users from viewing your content from regions where you may not have the rights to publish it. ## Get Started You can get started using the Motto Studio, which we recommend for non-technical users. Alternatively, you may get started by using the Motto API. To enable geo-blocking, first navigate to the "Settings" section in the Motto Studio, and select the "Video protection" tab. Here you can create a new ruleset by clicking the "New ruleset" button, or edit an existing ruleset if you are already applying other protection measures to the same content. In the creation form, you can check the option to enable geo-restrictions. You can then select a list of countries that you wish to allow or disallow playback from. To enable geo-blocking, you must [create a video protection ruleset](/reference/studio-api/streaming/video-protection/v1/create-ruleset) with the `geo_restrictions_allow` or `geo_restrictions_disallow` array populated (not both). Each element should contain a two-character country code following the [ISO 3316-1 alpha-2](https://en.wikipedia.org/wiki/List_of_ISO_3166_country_codes) standard, e.g. `US` or `FR`. These country codes represent where a viewer is (or is not) allowed to watch from, respectively. Make sure to apply the ruleset to the content you wish to protect by selecting the appropriate target(s). For more information, see [selecting a target](/guides/streaming/video-protection/target-selection). You may change these settings at any time, even while a stream is already live. New rules will take roughly one minute to lodge. However, users already viewing your stream may not be affected until they reload the page or app. ### Impact Once geo-blocking has been turned on, your end-users in disallowed countries will no longer be able to view your [playlist](/glossary/playlist) when attempting to play it. Instead, the stream resource will throw a 4xx HTTP status code. The Content Delivery API also performs a geo-blocking check, and will return an error upon trying to retrieve a playlist URL for playback. If the Motto video player is being used, a visual error will also appear to clarify the issue to your end-users. ## EU portability laws Motto's geo-blocking feature is in compliance with the portability laws set forth by the European Union. Under the EU’s Portability Regulation (EU) 2017/1128, if you legally subscribe to or purchase digital video content in one EU country, you must be able to access and use that content temporarily while present in another EU country under the same conditions (e.g. catalog, quality, and functionality) as at home. Motto solves this by keeping track of the origin country of the purchase as a part of the entitlement (which is the object that grants a user access to video content based on their purchase). This origin country is then evaluated along with the IP-based location of the user, when that user tries to view that purchased piece of content. More information can be provided upon request, as needed. ## Next Steps Have a look at any of the other rights protection features that Motto offers: * [VPN blocking](/guides/streaming/video-protection/vpn-blocking) * [hotlink prevention](/guides/streaming/video-protection/hotlink-prevention) * [domain pinning](/guides/streaming/video-protection/domain-pinning) * [registration walls](/guides/streaming/video-protection/registration-walls) * [entitlement verification](/guides/streaming/video-protection/other) * [DRM](/guides/streaming/video-protection/drm) # Hotlink prevention Source: https://docs.mottostreaming.com/guides/streaming/video-protection/hotlink-prevention Video protection on streams through IP address binding ## Introduction When streaming into Motto without any additional video protection rules configured, your stream will be exposed over the internet via a static URL, e.g. `https://example.com/master.m3u8`. Such a static URL is convenient when wanting to distribute your stream to a large audience easily, but it also has clear downsides. What if your content is only meant for a specific group of end-users, e.g. ones that have paid for access? While we offer a feature for entitlement checking, you may also want to disallow end-users to share the stream URLs with others, beyond the confines of your platform (i.e. hotlinking). To prevent abuse, the *hotlink prevention* feature generates a unique stream URL for each individual end-user based on their IP address. When they share this with others on a different network, the stream will simply not play. ## Get Started You can get started using the Motto Studio, which we recommend for non-technical users. Alternatively, you may get started by using the Motto API. To enable hotlink prevention, first navigate to the "Settings" section in the Motto Studio, and select the "Video protection" tab. Here you can create a new ruleset by clicking the "New ruleset" button, or edit an existing ruleset if you are already applying other protection measures to the same content. In the creation form, you can check the option to enable hotlink prevention. To enable hotlink prevention, you must [create a video protection ruleset](/reference/studio-api/streaming/video-protection/v1/create-ruleset) with the `disallow_hotlinking` property set to `true`. Make sure to apply the ruleset to the content you wish to protect by selecting the appropriate target(s). For more information, see [selecting a target](/guides/streaming/video-protection/target-selection). You may change these settings at any time, even while a stream is already live. New rules will take roughly one minute to lodge. However, users already viewing your stream may not be affected until they reload the page or app. ### Impact Once this feature has been turned on, end users switching between IP addresses will may no longer be able to load your stream when attempting to play it. Instead, the stream resource will throw a 4xx HTTP status code. This method of hotlink prevention may cause issues for some users, e.g. ones on corporate networks, as those may internally rotate IP addresses within a single viewing session. ## Next Steps Have a look at any of the other rights protection features that Motto offers: * [Geo-blocking](/guides/streaming/video-protection/geo-blocking) * [VPN blocking](/guides/streaming/video-protection/vpn-blocking) * [domain pinning](/guides/streaming/video-protection/domain-pinning) * [registration walls](/guides/streaming/video-protection/registration-walls) * [entitlement verification](/guides/streaming/video-protection/other) * [DRM](/guides/streaming/video-protection/drm) # Video Protection Source: https://docs.mottostreaming.com/guides/streaming/video-protection/introduction Protect your streams with geo-blocking, VPN blocking, DRM, and more. ## Introduction Your streams are valuable, and Motto gives you the tools to control who can watch them. You can restrict access to your content using any combination of the following protection features: * [Geo-blocking](/guides/streaming/video-protection/geo-blocking) — block or allow playback by country * [VPN blocking](/guides/streaming/video-protection/vpn-blocking) — prevent viewers from bypassing geo-restrictions via VPNs * [Hotlink prevention](/guides/streaming/video-protection/hotlink-prevention) — stop unauthorized sites from embedding your streams * [Domain pinning](/guides/streaming/video-protection/domain-pinning) — restrict playback to specific domains * [Registration walls](/guides/streaming/video-protection/registration-walls) — require viewers to be signed in * [Entitlement verification](/guides/streaming/video-protection/other) — verify that viewers have purchased access * [Concurrency control](/guides/streaming/video-protection/concurrency-control) — limit simultaneous streams per account * [DRM](/guides/streaming/video-protection/drm) — apply hardware-level content encryption ## Concepts Each of these protection features is referred to as a **rule**. A rule is a single protection measure — for example, a geo-restriction that blocks playback outside of France, or a domain pin that limits playback to your website. Rules are grouped into **rulesets**. A ruleset can contain any combination of rules and is applied to one or more pieces of content. For example, you could create a ruleset that combines geo-blocking with domain pinning, and apply it to an entire competition. You can apply multiple rulesets to the same content. When you do, Motto merges them field by field based on priority. For each rule type, the value from the highest-priority ruleset wins. Rule types that only appear in one ruleset are unaffected — they apply as-is regardless of priority. This means your rulesets stay modular. For example, you could create a platform-wide ruleset that enforces a registration wall for all content, and then create a separate ruleset that geo-blocks a specific competition to the countries where you hold the broadcasting rights. Both rulesets apply together, and neither needs to know about the other's rules. Rulesets are reusable and can target anything from a single video to all of your content at once. For more information on how to scope your rulesets, see [target selection](/guides/streaming/video-protection/target-selection). ## Get Started Refer to the individual sections in the sidebar for an in-depth explanation of each protection feature and how to configure it. # Other Source: https://docs.mottostreaming.com/guides/streaming/video-protection/other Other kinds of video protection, including entitlement verification. ## Introduction There are other kinds of rights protection that are not specifically mentioned in the previous sections. ### Entitlements Motto supports entitlement verification, meaning you can control which end-users are allowed to access your content. This is primarily used in the context of PPV and subscription services. Entitlements can be granted via the Motto Studio, which is useful for giving a specific user access to a paid event without requiring them to go through the payment flow. For more information, see the [entitlements API](/reference/studio-api/monetization/entitlements/v1/upsert-entitlement) or [reach out](mailto:info@mottostreaming.com). You can also enforce a limit on the number of simultaneous devices that can stream from a single account. For more information, see [concurrency control](/guides/streaming/video-protection/concurrency-control). # Registration walls Source: https://docs.mottostreaming.com/guides/streaming/video-protection/registration-walls Require users to sign in before they can access your content. ## Introduction Motto offers the ability to enhance your video protection by requiring users to sign in before they can access your content. This feature is known as a registration wall. ## Get Started You can get started using the Motto Studio, which we recommend for non-technical users. Alternatively, you may get started by using the Motto API. To enable a registration wall, first navigate to the "Settings" section in the Motto Studio, and select the "Video protection" tab. Here you can create a new ruleset by clicking the "New ruleset" button, or edit an existing ruleset if you are already applying other protection measures to the same content. In the creation form, you can check the option to enable "require authentication" To enable a registration wall, you must [create a video protection ruleset](/reference/studio-api/streaming/video-protection/v1/create-ruleset) with the `require_authentication` property set to `true`. When using the Motto OTT platform, turning on this feature will prompt users to sign in before they can access the content. If you are using the Motto streaming platform in standalone mode, you will have to handle the authentication flow yourself. Make sure to apply the ruleset to the content you wish to protect by selecting the appropriate target(s). For more information, see [selecting a target](/guides/streaming/video-protection/target-selection). The ruleset should apply within one minute of saving it. You can also update the ruleset at any time, and the changes will similarly apply within roughly one minute. Before enabling a registration wall, ensure that you have a way to authenticate users. This can be done through a third-party service, or by using Motto's user management features. ## Next Steps Have a look at any of the other rights protection features that Motto offers: * [Geo-blocking](/guides/streaming/video-protection/geo-blocking) * [VPN blocking](/guides/streaming/video-protection/vpn-blocking) * [hotlink prevention](/guides/streaming/video-protection/hotlink-prevention) * [domain pinning](/guides/streaming/video-protection/domain-pinning) * [entitlement verification](/guides/streaming/video-protection/other) * [DRM](/guides/streaming/video-protection/drm) # VPN blocking Source: https://docs.mottostreaming.com/guides/streaming/video-protection/vpn-blocking Video protection on streams through VPN blocking. ## Introduction In the streaming industry, it is all-too-common for end-users to try and bypass content restrictions. As you may have read in a related section, Motto offers a feature to enable [geo-blocking](/guides/streaming/video-protection/geo-blocking) protection on your streams. However, users may attempt to avoid those restrictions by using a Virtual Private Network (VPN), as it can be used to hide the end-user's country of residence. VPN blocking, as the name suggests, is a protective measure Motto offers to prevent end-users from viewing your streams while on a VPN. ## Get Started Guide coming soon. Please reach out to us for instructions in the meantime! ## Next Steps Have a look at any of the other rights protection features that Motto offers: * [Geo-blocking](/guides/streaming/video-protection/geo-blocking) * [hotlink prevention](/guides/streaming/video-protection/hotlink-prevention) * [domain pinning](/guides/streaming/video-protection/domain-pinning) * [registration walls](/guides/streaming/video-protection/registration-walls) * [entitlement verification](/guides/streaming/video-protection/other) * [DRM](/guides/streaming/video-protection/drm) # API Reference Source: https://docs.mottostreaming.com/reference/content-delivery-api/api-reference Where to find the full API documentation for Motto's Content Delivery API The Content Delivery API uses a protocol called [Connect](/reference/deep-dive/connect-protocol) to communicate with clients. As a consequence, the documentation is hosted in a separate environment specifically designed for this protocol, which you can find on the pages below: A highly scalable API for end-users to access Motto resources SDKs for TypeScript, Go, Swift, Kotlin, Java, Rust and Python To understand how to use this API, please follow the [Get Started](/reference/content-delivery-api/introduction) section. # Authentication Source: https://docs.mottostreaming.com/reference/content-delivery-api/authentication How to authenticate user requests when using Motto's Content Delivery API When using Motto's Content Delivery API, you will need to authenticate any requests the client makes. This document explains how to do that. ## Public key To authenticate with Motto's Content Delivery API, you should always provide a standard `Authorization: Bearer ` HTTP header. The `PUBLIC_KEY` is required and is connected to your Motto project. It allows your end-users to retrieve any public resource inside of that particular project. To retrieve the `PUBLIC_KEY` of your project, sign in to the Motto Studio and then visit [this page](https://studio.mottostreaming.com/organization/api-credentials). ## User authentication The public key as it is described above only authenticates a client to access resources within a project; it does not authenticate a user individually. To authenticate a user with Motto's Content Delivery API, you should provide a non-standard `X-Motto-Token: ` HTTP header. The `JWT` is a JSON Web Token that should be generated after the user signs in to a Motto-powered OTT platform application. ### Generating a JWT A user may sign into a Motto-powered OTT platform application using a variety of methods, depending on the platform setup, and each of these methods has a different way of generating the `JWT`. If the OTT platform application is configured to use Motto's own user management service, a JWT can be generated directly when the user signs up or signs in. The [sign up](https://buf.build/motto/cda/docs/main:motto.cda.iam.auth.v1#motto.cda.iam.auth.v1.AuthService.CreateUser) and [sign in](https://buf.build/motto/cda/docs/main:motto.cda.iam.auth.v1#motto.cda.iam.auth.v1.AuthService.SignInUser) endpoints of the Content Delivery API can be used to create and retrieve a JWT. If the OTT platform application is configured to use a third-party identity management integration supported by Motto, like Auth0, Userfront or Kinde, such an integration will generate a token for you. *This token must then be exchanged for a Motto-based JWT*. To exchange a third-party token for a Motto-based JWT, use the [exchange token](https://buf.build/motto/cda/docs/main:motto.cda.iam.auth.v1#motto.cda.iam.auth.v1.AuthService.ExchangeToken) endpoint of the Content Delivery API. In situations where the Motto platform is only partially used (e.g. only for video delivery and protection), you may have your own user management system. In that case, you can generate a JWT for a user that you have authenticated through a trusted environment controlled by you. This would let you still use user-specific features of the Content Delivery API, like entitlement checking before letting the user watch a paid event. . To generate a JWT for a user that you have authenticated through a trusted environment controlled by you, use the [create user token](/reference/studio-api/iam/users/v1/create-user-token) endpoint of the Studio API. If the OTT platform application is a TV app like Apple TV, Android TV, Samsung or LG, it is not typical to sign in directly on the TV. Instead, it is preferable to show the user a code that they can enter on a website or mobile app to link their account. This requires three steps: 1. *(TV)* The TV app shows a code to the user. Such a code can be obtained using the [create TV code](https://buf.build/motto/cda/docs/main:motto.cda.iam.auth.v1#motto.cda.iam.auth.v1.AuthService.CreateTVCode) endpoint. 2. *(Web / Mobile)* The user visits the OTT platform's website or mobile app, and enters the code there; this connects the signed in user to the code in the database. The web or mobile app must the call [exchange TV code](https://buf.build/motto/cda/docs/main:motto.cda.iam.auth.v1#motto.cda.iam.auth.v1.AuthService.ConnectTVCode) endpoint. 3. *(TV)* Meanwhile, TV app can poll the status of the connection using the [check TV code](https://buf.build/motto/cda/docs/main:motto.cda.iam.auth.v1#motto.cda.iam.auth.v1.AuthService.CheckTVCode) endpoint. This will return a JWT of the user if the connection was successful. # Introduction Source: https://docs.mottostreaming.com/reference/content-delivery-api/introduction A highly scalable API for end-users to access Motto resources ## What for? The Content Delivery API is the API that allows your website or app to show content to end-users. It is (mostly) a read-only API built for high scalability, though it does support various write operations. If you are looking for an API to integrate into your management tooling, have a look at our [Studio API](/reference/studio-api/introduction). ## Get Started Unlike the Studio API, the Content Delivery API does not offer a REST interface in the traditional sense, as it uses a protocol called [Connect](/reference/deep-dive/connect-protocol). But do not worry! The API still works with standard `GET` and `POST` requests, and will return standard JSON. The primary difference with REST is that the API routes look a little different than you may be used to. If you would like to use a code-generated client in the language of your choice, please have a look at our [SDKs](https://buf.build/motto/cda/sdks). We believe it's great time-saver (after a bit of initial setup effort)! ### GET requests To understand how to use Motto's Content Delivery API using standard HTTP `GET` requests for read-only operations, please follow along with a basic example. Let's say we want to get a list of all events in the project, you would send a `GET` request to the following URL: `https://cda.mottostreaming.com/motto.cda.cms.event.v1.EventService/ListEvents?encoding=json&message=%7B%22pageSize%22%3A%2225%22%7D` This URL is broken down as follows: 1. `https://cda.mottostreaming.com` -> This is the base URL of the API. Should look familiar, so far! 2. `motto.cda.cms.event.v1.EventService` -> This is the "package" and "service" of the API. It tells Motto servers which part of the API you are trying to access. You can find all available packages [here](https://buf.build/motto/cda). 3. `ListEvents` -> This is the "method" of the API. It tells the API which specific operation you are trying to perform. You can find all available methods on page linked in step (2), after selecting a package. 4. `?encoding=json&message=%7B%22pageSize%22%3A%2225%22%7D` -> This is the query string of the API. It tells the API which parameters you are trying to pass to the method. In this case, we are passing a JSON object with a `pageSize` of 25, since that's what this example endpoint requires. Please note that the JSON should always be *URL-encoded*, and should be included in the `message` parameter (you should not change the `encoding` parameter)! To know which parameters are needed for each method, you can click into a method's `Request`, e.g. for [list events](https://buf.build/motto/cda/docs/main:motto.cda.cms.event.v1#motto.cda.cms.event.v1.ListEventsRequest). Putting this together, such a request would look like this using `curl`: ```bash theme={null} curl -X GET 'https://cda.mottostreaming.com/motto.cda.cms.event.v1.EventService/ListEvents?encoding=json&message=%7B%22pageSize%22%3A%2225%22%7D' \ -H 'Authorization: Bearer ' ``` To understand more about the `Authorization` header, please see the [authentication](/reference/content-delivery-api/authentication) section. You now know how to perform `GET` requests to the Content Delivery API. However, some operations require `POST` requests, which we will cover in the next section. ### POST requests To understand how to use Motto's Content Delivery API using standard HTTP `POST` requests for write operations, please follow along with a basic example. Let's say we want to obtain a Motto JWT for a user that has signed in using Userfront (a third party user management service). From the above section, we know how to navigate to the necessary API endpoint, which in this case can be found [here](https://buf.build/motto/cda/docs/main:motto.cda.iam.auth.v1#motto.cda.iam.auth.v1.AuthService.ExchangeToken). As we can see in the documentation for this endpoint, this is not marked with `NO_SIDE_EFFECTS`, which means it is not a cacheable request. Therefore, we need to use a `POST` request. Such a request would look like this using `curl`: ```bash theme={null} curl -X POST 'https://cda.mottostreaming.com/motto.cda.iam.auth.v1.AuthService/ExchangeToken' \ -H 'authorization: Bearer ' \ -H 'connect-protocol-version: 1' \ -H 'content-type: application/json' \ --data-raw '{"userfrontIdToken":"eyJhb....nEa-V8"}' ``` Note that now, as with normal REST `POST` requests, the parameters are no longer included in the URL, but in the body of the request. The body should always be a JSON object. Do not forget the `connect-protocol-version: 1` header, as this is required for all POST requests! If you still have questions about how to use the Content Delivery API, please do not hesitate to [contact us](mailto:info@mottostreaming.com). ## Full API documentation For a full list of all available methods and services, please visit our [API documentation](https://buf.build/motto/cda/docs/main). If you are unsure about how to use this API documentation, please follow the examples above. # Connect (protocol) Source: https://docs.mottostreaming.com/reference/deep-dive/connect-protocol Protobuf RPC that works. ## Introduction Some Motto APIs support the [Connect protocol](https://connectrpc.com/). Connect is a family of libraries for building browser and gRPC-compatible APIs. If you're tired of handwritten boilerplate and turned off by massive frameworks, Connect is for you. It is important to note that, as part of the Connect protocol, regular HTTP POST and GET requests are all also supported, which returns standard JSON responses. The primary difference is that the API routes look a little different. Our Connect-compatible APIs currently do not support direct gRPC calls, but we intend to add support for this when feasible. ## Methods ### Remote packages Remote packages are auto-generated code based on our API definitions that allows you to develop products without having to write exhaustive boilerplate code. This should shorten development cycles, and generally lead to a better developer experience. You can find these remote packages and installation instructions for our Studio API Content Delivery API [here](https://buf.build/motto/api/assets/main) and for our Content Delivery API [here](https://buf.build/motto/cda/assets/main). ### Regular HTTPS If you are interested in doing a regular HTTPS call to our Connect API instead of using the remote packages, you can do so. For the Studio API, a full REST interface is available, and you can read more about how to do that in our [Studio API documentation](/reference/studio-api/introduction). For the Content Delivery API, you can read more about how to do that in our [Content Delivery API documentation](/reference/content-delivery-api/introduction#get-started). # KQL Filters Source: https://docs.mottostreaming.com/reference/deep-dive/kql-filters Filtering API result-sets with KQL (Kibana Query Language) queries. ## Introduction At Motto we realized that our APIs expose a number of endpoints that need support for filters of varying complexity. For example, in our content-delivery API you may wish to retrieve all events between two dates, where the event status is either *scheduled* or *started*, where the event is a football match with at least 500 views, and where the home-team has at least two Spanish players on the team. To support such advanced filtering, we decided that many (though not all) of our list endpoints should expose a `filter` parameter, which expects a KQL query. The following section details how to construct such a query. Each Motto service determines which subset of the KQL specification it needs to support, and which fields you are allowed to query on. We recommend reading the docstrings of the API carefully, and validating that the result-sets match your expectations. ## KQL implementation The Kibana Query Language was developed with Elastic Search in mind, and while we do not use this directly in combination with Elastic Search, we still believe this DSL is intuitive and easy to write for most technical users. ### Basic queries Most of the Studio API endpoints support only the "basic" types of queries detailed in this section. To query a single field and match against an exact term, use the following syntax: ``` email:john@example.com ``` To query two fields and match both against exact terms, you can separate the conditions by a space. ``` first_name:John last_name:Doe ``` If your term itself contains a space, you may use quotation marks. If you prefer using `AND` explicitly, that is supported, too. ``` first_name:"John Allen" AND last_name:Doe ``` If the `filter` is passed a URL parameter, make sure to URL-encode queries like the one above. If you want to query on a range, use any of the four range operators (`<`, `<=`, `>`, `>=`): ``` age>=21 ``` In the case of closed ranges, a single field may be queried twice: ``` date>=2023-06-01T22:00:00.00Z AND date<2024-07-02T23:10:20.00Z ``` ### Advanced queries Besides the operators and functionality listed in the section above, some services may support more advanced filters. To query two fields where only a single match is needed, use the following syntax: ``` user_id:42 OR username:john ``` To query a single field where multiple terms are matchable: ``` status:(paid OR processing) ``` To query a nested structure on multiple properties: ``` team:{name:"FC Barcelona" color:"#FFFF00"} ``` Some services support wildcards in query terms. This is typically on specific fields, and typically only as prefix-matches (meaning that the wildcard `*` needs to be the trailing character): ``` email:john@example.c* ``` The following characters must be escaped if they are part of the actual query term: `\` `(` `)` `:` `<` `>` `"` `*` To query a field with negation: ``` NOT user_id:42 ``` To query with more complex and/or nested conditions: ``` ( competition_id:123 AND (season:fall OR start_date=2023-08-01) AND team_id:456 ) OR status:finished ``` # API Reference Source: https://docs.mottostreaming.com/reference/overview What would you like to learn more about? ## APIs An authenticated API for managing Motto resources A highly scalable API for end-users to access Motto resources ## SDKs & Components Integrate the video player into your React website A generated gRPC-compatible API client for TypeScript, Go, Swift, Kotlin, Java or Python A generated gRPC-compatible API client for TypeScript, Go, Swift, Kotlin, Java or Python # Get activity Source: https://docs.mottostreaming.com/reference/studio-api/analytics/activities/v1/get-activity get /analytics/activities/v1/{activity_id} # List activities Source: https://docs.mottostreaming.com/reference/studio-api/analytics/activities/v1/list-activities get /analytics/activities/v1 # Create action secret Source: https://docs.mottostreaming.com/reference/studio-api/annotations/action-secrets/v1/create-action-secret post /annotations/action_secrets/v1 CreateActionSecret Creates new annotation. # Delete action secret Source: https://docs.mottostreaming.com/reference/studio-api/annotations/action-secrets/v1/delete-action-secret delete /annotations/action_secrets/v1/{secret_id} DeleteActionSecret Deletes an existing annotation. # Get action secret Source: https://docs.mottostreaming.com/reference/studio-api/annotations/action-secrets/v1/get-action-secret get /annotations/action_secrets/v1/{secret_id} GetActionSecret Returns an action type # List action secrets Source: https://docs.mottostreaming.com/reference/studio-api/annotations/action-secrets/v1/list-action-secrets get /annotations/action_secrets/v1 ListActionSecrets Returns list of action types # Update action secret Source: https://docs.mottostreaming.com/reference/studio-api/annotations/action-secrets/v1/update-action-secret patch /annotations/action_secrets/v1/{secret_id} UpdateActionSecret Updates an existing annotation. # Get action type Source: https://docs.mottostreaming.com/reference/studio-api/annotations/action-types/v1/get-action-type get /annotations/action_types/v1/{action_type_id} GetActionType Returns an action type # List action types Source: https://docs.mottostreaming.com/reference/studio-api/annotations/action-types/v1/list-action-types get /annotations/action_types/v1 ListActionTypes Returns list of action types # Create annotation Source: https://docs.mottostreaming.com/reference/studio-api/annotations/annotations/v1/create-annotation post /annotations/annotations/v1 CreateAnnotation Creates new annotation. # Delete annotation Source: https://docs.mottostreaming.com/reference/studio-api/annotations/annotations/v1/delete-annotation delete /annotations/annotations/v1/{annotation_id} DeleteAnnotation Deletes an existing annotation. # Get annotation Source: https://docs.mottostreaming.com/reference/studio-api/annotations/annotations/v1/get-annotation get /annotations/annotations/v1/{annotation_id} GetAnnotation Returns annotation information by annotation ID. # List annotations Source: https://docs.mottostreaming.com/reference/studio-api/annotations/annotations/v1/list-annotations get /annotations/annotations/v1 ListAnnotations Returns list of annotations. # Update annotation Source: https://docs.mottostreaming.com/reference/studio-api/annotations/annotations/v1/update-annotation patch /annotations/annotations/v1/{annotation_id} UpdateAnnotation Updates an existing annotation. # Attach content type Source: https://docs.mottostreaming.com/reference/studio-api/annotations/sets/v1/attach-content-type post /annotations/sets/v1/{set_id}/attach AttachContentType Attaches an annotation set to a CMS content type. Any previously assigned annotation set will be replaced. `content_base_type` should be either `event` or `creative_work`. `content_type_id` should be the ID of the content type as defined in the CMS service. # Create annotation set Source: https://docs.mottostreaming.com/reference/studio-api/annotations/sets/v1/create-annotation-set post /annotations/sets/v1 CreateAnnotationSet Creates a new type. # Delete annotation set Source: https://docs.mottostreaming.com/reference/studio-api/annotations/sets/v1/delete-annotation-set delete /annotations/sets/v1/{set_id} DeleteAnnotationSet Updates type # Detach content type Source: https://docs.mottostreaming.com/reference/studio-api/annotations/sets/v1/detach-content-type post /annotations/sets/v1/{set_id}/detach DetachContentType Detaches (removes) the currently attached set_id from a CMS content type. # Get annotation set Source: https://docs.mottostreaming.com/reference/studio-api/annotations/sets/v1/get-annotation-set get /annotations/sets/v1/{set_id} Returns an annotation type # List annotation sets Source: https://docs.mottostreaming.com/reference/studio-api/annotations/sets/v1/list-annotation-sets get /annotations/sets/v1 ListAnnotations Returns list of groups of annotation sets. # Update annotation set Source: https://docs.mottostreaming.com/reference/studio-api/annotations/sets/v1/update-annotation-set patch /annotations/sets/v1/{set_id} UpdateAnnotationSet Updates type # Create annotation type Source: https://docs.mottostreaming.com/reference/studio-api/annotations/types/v1/create-annotation-type post /annotations/types/v1 CreateAnnotationType Creates a new type. # Delete annotation type Source: https://docs.mottostreaming.com/reference/studio-api/annotations/types/v1/delete-annotation-type delete /annotations/types/v1/{type_id} DeleteAnnotationType Updates type # Get action configuration Source: https://docs.mottostreaming.com/reference/studio-api/annotations/types/v1/get-action-configuration get /annotations/types/v1/{annotation_type_id}/action_configuration GetActionConfiguration Associates a number of action types with an annotation type. This means that when an annotation is created, it will trigger the associated actions to be executed. # Get annotation type Source: https://docs.mottostreaming.com/reference/studio-api/annotations/types/v1/get-annotation-type get /annotations/types/v1/{type_id} GetAnnotationType Returns an annotation type # List annotation types Source: https://docs.mottostreaming.com/reference/studio-api/annotations/types/v1/list-annotation-types get /annotations/types/v1 ListAnnotations Returns list of groups of annotation types. # Set action configuration Source: https://docs.mottostreaming.com/reference/studio-api/annotations/types/v1/set-action-configuration post /annotations/types/v1/{annotation_type_id}/action_configuration SetActionConfiguration Associates a number of action types with an annotation type. This means that when an annotation is created, it will trigger the associated actions to be executed. Note: To update action types on an annotation type, all action type IDs and the configuration must be re-submitted. To help with this, you can retrieve the current action type IDs and configuration via the GET call. # Update annotation type Source: https://docs.mottostreaming.com/reference/studio-api/annotations/types/v1/update-annotation-type patch /annotations/types/v1/{type_id} UpdateAnnotationType Updates type # Create banner collection Source: https://docs.mottostreaming.com/reference/studio-api/cms/banner-collections/v3/create-banner-collection post /cms/banner_collections/v3 CreateBannerCollection Creates a new banner collection. # Delete banner collection Source: https://docs.mottostreaming.com/reference/studio-api/cms/banner-collections/v3/delete-banner-collection delete /cms/banner_collections/v3/{banner_collection_id} DeleteBannerCollection Deletes an existing banner collection. # Get banner collection Source: https://docs.mottostreaming.com/reference/studio-api/cms/banner-collections/v3/get-banner-collection get /cms/banner_collections/v3/{banner_collection_id} GetBannerCollection Returns banner collection information by collection ID. # List banner collections Source: https://docs.mottostreaming.com/reference/studio-api/cms/banner-collections/v3/list-banner-collections get /cms/banner_collections/v3 ListBannerCollections Returns list of banner collections. # Update banner collection Source: https://docs.mottostreaming.com/reference/studio-api/cms/banner-collections/v3/update-banner-collection patch /cms/banner_collections/v3/{banner_collection_id} UpdateBannerCollection Updates an existing banner collection. # Batch get banners Source: https://docs.mottostreaming.com/reference/studio-api/cms/banners/v3/batch-get-banners get /cms/banners/v3/batch BatchGetBanners Returns banner information by banner IDs. # Create banner Source: https://docs.mottostreaming.com/reference/studio-api/cms/banners/v3/create-banner post /cms/banners/v3 CreateBanner Creates new banner. # Delete banner Source: https://docs.mottostreaming.com/reference/studio-api/cms/banners/v3/delete-banner delete /cms/banners/v3/{banner_id} DeleteBanner Deletes an existing banner. # Get banner Source: https://docs.mottostreaming.com/reference/studio-api/cms/banners/v3/get-banner get /cms/banners/v3/{banner_id} GetBanner Returns banner information by banner ID. # List banners Source: https://docs.mottostreaming.com/reference/studio-api/cms/banners/v3/list-banners get /cms/banners/v3 ListBanners Returns list of banners. # Update banner Source: https://docs.mottostreaming.com/reference/studio-api/cms/banners/v3/update-banner patch /cms/banners/v3/{banner_id} UpdateBanner Updates an existing banner. # Create creative work Source: https://docs.mottostreaming.com/reference/studio-api/cms/creative-works/v1/create-creative-work post /cms/creative_works/v1 CreateCreativeWork Creates new creative work. # Delete creative work Source: https://docs.mottostreaming.com/reference/studio-api/cms/creative-works/v1/delete-creative-work delete /cms/creative_works/v1/{creative_work_id} DeleteCreativeWork Deletes existing creative work. # Get creative work Source: https://docs.mottostreaming.com/reference/studio-api/cms/creative-works/v1/get-creative-work get /cms/creative_works/v1/{creative_work_id} GetCreativeWork Returns creative work information by creative work ID. # List creative works Source: https://docs.mottostreaming.com/reference/studio-api/cms/creative-works/v1/list-creative-works get /cms/creative_works/v1 ListCreativeWorks Returns list of creative works based on specified parameters. # Update creative work Source: https://docs.mottostreaming.com/reference/studio-api/cms/creative-works/v1/update-creative-work patch /cms/creative_works/v1/{creative_work_id} UpdateCreativeWork Updates existing creative work. # Create entity Source: https://docs.mottostreaming.com/reference/studio-api/cms/entities/v1/create-entity post /cms/entities/v1 CreateEntity Creates new entity. # Delete entity Source: https://docs.mottostreaming.com/reference/studio-api/cms/entities/v1/delete-entity delete /cms/entities/v1/{entity_id} DeleteEntity Deletes existing entity. # Get entity Source: https://docs.mottostreaming.com/reference/studio-api/cms/entities/v1/get-entity get /cms/entities/v1/{entity_id} GetEntity Returns entity information by entity ID. # List entities Source: https://docs.mottostreaming.com/reference/studio-api/cms/entities/v1/list-entities get /cms/entities/v1 ListEntities Returns list of entities based on specified parameters. # Update entity Source: https://docs.mottostreaming.com/reference/studio-api/cms/entities/v1/update-entity patch /cms/entities/v1/{entity_id} UpdateEntity Updates existing entity. # Create event Source: https://docs.mottostreaming.com/reference/studio-api/cms/events/v1/create-event post /cms/events/v1 CreateEvent Creates new event. # Delete event Source: https://docs.mottostreaming.com/reference/studio-api/cms/events/v1/delete-event delete /cms/events/v1/{event_id} DeleteEvent Deletes existing event. # Duplicate event Source: https://docs.mottostreaming.com/reference/studio-api/cms/events/v1/duplicate-event post /cms/events/v1/{event_id}/duplicate DuplicateEvent Duplicates an existing event, optionally with modifications. By providing an `event` in the request body, you can indicate which fields should be updated in the duplicated event. For those fields that should be modified, also provide a field mask. For any string field, if you want to include the original value in the duplicate but with some modifications, you may use `%@` as a placeholder. For example, if the original event title is `FC Barcelona vs Real Madrid`, and you want to duplicate that event for the purpose of highlights, you may provide a new title like `Highlights of %@` which will result in `Highlights of FC Barcelona vs Real Madrid`. # Get event Source: https://docs.mottostreaming.com/reference/studio-api/cms/events/v1/get-event get /cms/events/v1/{event_id} GetEvent Returns event information by event ID. # List events Source: https://docs.mottostreaming.com/reference/studio-api/cms/events/v1/list-events get /cms/events/v1 ListEvents Returns list of events based on specified parameters. # Update event Source: https://docs.mottostreaming.com/reference/studio-api/cms/events/v1/update-event patch /cms/events/v1/{event_id} UpdateEvent Updates existing event. # Batch get standing phases Source: https://docs.mottostreaming.com/reference/studio-api/cms/standing-phases/v1/batch-get-standing-phases get /cms/standing_phases/v1/batch BatchGetStandingPhases Returns standing phases information by standing phase IDs. # Create standing phase Source: https://docs.mottostreaming.com/reference/studio-api/cms/standing-phases/v1/create-standing-phase post /cms/standing_phases/v1 CreateStandingPhase Creates new standing phase. # Delete standing phase Source: https://docs.mottostreaming.com/reference/studio-api/cms/standing-phases/v1/delete-standing-phase delete /cms/standing_phases/v1/{standing_phase_id} DeleteStandingPhase Deletes existing standing phase. # Get standing phase Source: https://docs.mottostreaming.com/reference/studio-api/cms/standing-phases/v1/get-standing-phase get /cms/standing_phases/v1/{standing_phase_id} GetStandingPhase Returns standing phase information by standing phase ID. # Update standing phase Source: https://docs.mottostreaming.com/reference/studio-api/cms/standing-phases/v1/update-standing-phase patch /cms/standing_phases/v1/{standing_phase_id} UpdateStandingPhase Updates existing standing phase. # Create standing Source: https://docs.mottostreaming.com/reference/studio-api/cms/standings/v1/create-standing post /cms/standings/v1 CreateStanding Creates new standing. # Delete standing Source: https://docs.mottostreaming.com/reference/studio-api/cms/standings/v1/delete-standing delete /cms/standings/v1/{standing_id} DeleteStanding Deletes existing standing. # Get standing Source: https://docs.mottostreaming.com/reference/studio-api/cms/standings/v1/get-standing get /cms/standings/v1/{standing_id} GetStanding Returns standing information by standing ID. # List standings Source: https://docs.mottostreaming.com/reference/studio-api/cms/standings/v1/list-standings get /cms/standings/v1 ListStandings Returns list of standings based on specified parameters. # Update standing Source: https://docs.mottostreaming.com/reference/studio-api/cms/standings/v1/update-standing patch /cms/standings/v1/{standing_id} UpdateStanding Updates existing standing. # Create type Source: https://docs.mottostreaming.com/reference/studio-api/cms/types/v1/create-type post /cms/types/v1 # Delete type Source: https://docs.mottostreaming.com/reference/studio-api/cms/types/v1/delete-type delete /cms/types/v1/{type_id} # Get type Source: https://docs.mottostreaming.com/reference/studio-api/cms/types/v1/get-type get /cms/types/v1/{type_id} # List types Source: https://docs.mottostreaming.com/reference/studio-api/cms/types/v1/list-types get /cms/types/v1 # Update type Source: https://docs.mottostreaming.com/reference/studio-api/cms/types/v1/update-type patch /cms/types/v1 # Introduction Source: https://docs.mottostreaming.com/reference/studio-api/iam/accounts/introduction Accounts in Motto Accounts represent a person or machine that can log in to the Motto Studio (API) and perform actions that require some level of elevated access. For example, signing into an account with the correct permissions allows you to start a live stream or create a highlight clip. Accounts should not be confused with with **users**, which represent viewers or end users of your OTT service. # Batch get accounts Source: https://docs.mottostreaming.com/reference/studio-api/iam/accounts/v1/batch-get-accounts get /iam/accounts/v1/batch BatchGetAccounts Returns account information by account IDs or by email addresses # Change password Source: https://docs.mottostreaming.com/reference/studio-api/iam/accounts/v1/change-password post /iam/accounts/v1/password_change ChangePassword Changes account password using old password and new password. # Check password reset Source: https://docs.mottostreaming.com/reference/studio-api/iam/accounts/v1/check-password-reset get /iam/accounts/v1/password_reset/check/{reset_code} CheckPasswordReset It will check that reset code is still valid and we can proceed with changing password. # Create account Source: https://docs.mottostreaming.com/reference/studio-api/iam/accounts/v1/create-account post /iam/accounts/v1 CreateAccount Creates an account in Motto platform. # Get account Source: https://docs.mottostreaming.com/reference/studio-api/iam/accounts/v1/get-account get /iam/accounts/v1/{account_id} GetAccount Returns account information by account ID. # Get my account Source: https://docs.mottostreaming.com/reference/studio-api/iam/accounts/v1/get-my-account get /iam/accounts/v1/me GetMyAccount Returns account information for currently authenticated account. # Invite accounts Source: https://docs.mottostreaming.com/reference/studio-api/iam/accounts/v1/invite-accounts post /iam/accounts/v1/invite BatchInviteAccounts Invites one or more new or existing accounts to the Motto platform for a particular resource. Important: this does not grant the provided accounts any permissions to that resource; please use iam.auth.v1.SetIamPolicy for that. # List accounts Source: https://docs.mottostreaming.com/reference/studio-api/iam/accounts/v1/list-accounts get /iam/accounts/v1 ListAccounts Returns a list of accounts. # Resend email verification Source: https://docs.mottostreaming.com/reference/studio-api/iam/accounts/v1/resend-email-verification post /iam/accounts/v1/verify/send ResendVerificationEmail Resends the verification email to the email address associated with the account from the authentication token. # Reset password Source: https://docs.mottostreaming.com/reference/studio-api/iam/accounts/v1/reset-password post /iam/accounts/v1/password_reset ResetPassword Changes account password without old password from forgot your password page UI. # Send password reset Source: https://docs.mottostreaming.com/reference/studio-api/iam/accounts/v1/send-password-reset post /iam/accounts/v1/password_reset/send SendPasswordReset Requests password change. It sends an email with a special link if associated account exists. # Update account Source: https://docs.mottostreaming.com/reference/studio-api/iam/accounts/v1/update-account patch /iam/accounts/v1/{account_id} UpdateAccount Updates the account profile data. # Verify email Source: https://docs.mottostreaming.com/reference/studio-api/iam/accounts/v1/verify-email post /iam/accounts/v1/verify VerifyAccount Verifies the account's email with the provided token. # Create token Source: https://docs.mottostreaming.com/reference/studio-api/iam/auth/v1/create-token post /iam/auth/v1/tokens CreateToken Creates a new token for the authenticated account. This can be used in various scenarios: 1. Creating short-lived tokens with an existing long-lived token for improved security. 2. Creating a token that is scoped to a subset of resources that are normally accessible to the account. This is useful for temporary tokens that are used in specific contexts (e.g. CI/CD systems or AI tooling). # Get iam policy Source: https://docs.mottostreaming.com/reference/studio-api/iam/auth/v1/get-iam-policy get /iam/auth/v1/policies/{resource_key} GetIamPolicy Returns current IAM policy for the resource. Use returned policy and etag to update policy. # Get role Source: https://docs.mottostreaming.com/reference/studio-api/iam/auth/v1/get-role get /iam/auth/v1/roles/{role_id} GetRole Returns a Role with permissions assigned to that role. # Login Source: https://docs.mottostreaming.com/reference/studio-api/iam/auth/v1/login post /iam/auth/v1/login Login This method performs login into platform account. # Set iam policy Source: https://docs.mottostreaming.com/reference/studio-api/iam/auth/v1/set-iam-policy put /iam/auth/v1/policies/{resource_key} SetIamPolicy Set IAM policy for a resource. This method replaces all existing policy bindings for the resource. To prevent overwriting existing policy bindings that were written concurrently, use the etag field to perform a read-modify-write operation. For example: Making a new account to become a resource owner would require reading IAM Policy for the resource, add new binding or update existing binding with role_id: owner, and then set the new policy with etag returned by GetIamPolicy. # Test account permissions Source: https://docs.mottostreaming.com/reference/studio-api/iam/auth/v1/test-account-permissions get /iam/auth/v1/policies/{resource_key}/test_permissions TestResourceIamPermissions Test the access of the authenticated account on a specific combination of resource and a set of permissions. This method will return a subset of the permissions passed into the method, indicating the ones the account has access to. If the account has no access to any of the permissions, an empty list will be returned. # Get organization Source: https://docs.mottostreaming.com/reference/studio-api/iam/organizations/v1/get-organization get /iam/organizations/v1/{org_id} GetOrganization Will return information about the organization. # List organizations Source: https://docs.mottostreaming.com/reference/studio-api/iam/organizations/v1/list-organizations get /iam/organizations/v1 ListOrganizations Return list of organizations that the authenticated account has access to. # Get project Source: https://docs.mottostreaming.com/reference/studio-api/iam/projects/v1/get-project get /iam/projects/v1/{project_id} GetProject Returns information about the project. # List projects Source: https://docs.mottostreaming.com/reference/studio-api/iam/projects/v1/list-projects get /iam/projects/v1 ListProjects Return list of projects that the authenticated account has access to. # Update project Source: https://docs.mottostreaming.com/reference/studio-api/iam/projects/v1/update-project patch /iam/projects/v1/{project_id} UpdateProject Updates project's basic fields (i.e. name) # Introduction Source: https://docs.mottostreaming.com/reference/studio-api/iam/users/introduction Users in Motto Users in Motto are the people that interact with your content via the Motto technology, for example to view your live streams on your OTT platform. Users should not be confused with with **accounts**, which represent people or machines with elevated access inside the Motto Studio (API). # Create apple sign in integration Source: https://docs.mottostreaming.com/reference/studio-api/iam/users/v1/create-apple-sign-in-integration post /iam/users/v1/apple Apple Sign In related methods # Create google sign in integration Source: https://docs.mottostreaming.com/reference/studio-api/iam/users/v1/create-google-sign-in-integration post /iam/users/v1/google CreateGoogleSignInIntegration Creates new integration. # Create user token Source: https://docs.mottostreaming.com/reference/studio-api/iam/users/v1/create-user-token post /iam/users/v1/{user_id}/token CreateUserToken Returns a Motto-signed JWT for the user. This token can be used to authenticate the user in the Motto content-delivery API. Note: this endpoint can be used even without a configured identity platform, nor does CreateUser need to be called. Passing a user_id that is not known to Motto will work just as well. This is useful in situations where an external identity platform is used, and you only wish to use the user_id in combination with e.g. Motto's entitlement service. # Delete apple sign in integration Source: https://docs.mottostreaming.com/reference/studio-api/iam/users/v1/delete-apple-sign-in-integration delete /iam/users/v1/apple/{project_id} # Delete google sign in integration Source: https://docs.mottostreaming.com/reference/studio-api/iam/users/v1/delete-google-sign-in-integration delete /iam/users/v1/google/{project_id} DeleteGoogleSignInIntegration Deletes existing google sign in integration. # Delete user Source: https://docs.mottostreaming.com/reference/studio-api/iam/users/v1/delete-user delete /iam/users/v1/{user_id} DeleteUser Deletes an existing user. This will also cancel active subscriptions for the user (asynchronously, not immediately). Important: if the user is registered via OIDC, this does NOT delete the user in the identity provider. # Get apple sign in integration Source: https://docs.mottostreaming.com/reference/studio-api/iam/users/v1/get-apple-sign-in-integration get /iam/users/v1/apple/{project_id} # Get google sign in integration Source: https://docs.mottostreaming.com/reference/studio-api/iam/users/v1/get-google-sign-in-integration get /iam/users/v1/google/{project_id} GetGoogleSignInIntegration Returns integration information by integration ID. # Get user Source: https://docs.mottostreaming.com/reference/studio-api/iam/users/v1/get-user get /iam/users/v1/{user_id} GetUser Returns user information by user ID. # List users Source: https://docs.mottostreaming.com/reference/studio-api/iam/users/v1/list-users get /iam/users/v1 ListUsers Returns a list of users. # Update apple sign in integration Source: https://docs.mottostreaming.com/reference/studio-api/iam/users/v1/update-apple-sign-in-integration patch /iam/users/v1/apple/{project_id} # Update google sign in integration Source: https://docs.mottostreaming.com/reference/studio-api/iam/users/v1/update-google-sign-in-integration patch /iam/users/v1/google/{project_id} UpdateGoogleSignInIntegration Updates existing google sign in integration. # Update user Source: https://docs.mottostreaming.com/reference/studio-api/iam/users/v1/update-user patch /iam/users/v1/{user_id} UpdateUser Updates the user object. Important: if the user is registered via OIDC, this can only be used to update the role. # Batch get event mappings Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/batch-get-event-mappings get /integration/spiideo/v1/event_mappings/batch BatchGetSpiideoEventMappings Returns the Spiideo game IDs for the given event IDs or the event IDs for the given Spiideo game IDs. # Create entity mapping Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/create-entity-mapping post /integration/spiideo/v1/entity_mappings Creates a new entity mapping. # Create event type mapping Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/create-event-type-mapping post /integration/spiideo/v1/event_type_mappings Creates a new event type mapping. # Create player type mapping Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/create-player-type-mapping post /integration/spiideo/v1/player_type_mappings Creates a new player type mapping. # Create spiideo integration Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/create-spiideo-integration post /integration/spiideo/v1/integrations CreateSpiideoIntegration Creates new integration. # Create sport config Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/create-sport-config post /integration/spiideo/v1/sport_configurations Creates a new sport configuration. # Create team type mapping Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/create-team-type-mapping post /integration/spiideo/v1/team_type_mappings Creates a new team type mapping. # Delete entity mapping Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/delete-entity-mapping delete /integration/spiideo/v1/entity_mappings/{entity_id} Deletes a specific entity mapping. # Delete event type mapping Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/delete-event-type-mapping delete /integration/spiideo/v1/event_type_mappings/{event_type} Deletes a specific event type mapping. # Delete player type mapping Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/delete-player-type-mapping delete /integration/spiideo/v1/player_type_mappings/{motto_entity_type} Deletes a specific player type mapping. # Delete spiideo integration Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/delete-spiideo-integration delete /integration/spiideo/v1/integrations/{project_id} DeleteSpiideoIntegration Deletes existing spiideo integration. # Delete sport config Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/delete-sport-config delete /integration/spiideo/v1/sport_configurations/{spiideo_sport} Deletes a specific sport configuration. # Delete team type mapping Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/delete-team-type-mapping delete /integration/spiideo/v1/team_type_mappings/{motto_entity_type} Deletes a specific team type mapping. # Get spiideo integration Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/get-spiideo-integration get /integration/spiideo/v1/integrations/{project_id} GetSpiideoIntegration Returns integration information by integration ID. # List entity mappings Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/list-entity-mappings get /integration/spiideo/v1/entity_mappings Lists all entity mappings for a project. # List event type mappings Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/list-event-type-mappings get /integration/spiideo/v1/event_type_mappings Lists all event type mappings for a project. # List player type mappings Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/list-player-type-mappings get /integration/spiideo/v1/player_type_mappings Lists all player type mappings for a project. # List sport configs Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/list-sport-configs get /integration/spiideo/v1/sport_configurations Lists all sport configurations for a project. # List team type mappings Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/list-team-type-mappings get /integration/spiideo/v1/team_type_mappings Lists all team type mappings for a project. # Update spiideo integration Source: https://docs.mottostreaming.com/reference/studio-api/integration/spiideo/v1/update-spiideo-integration patch /integration/spiideo/v1/integrations/{project_id} UpdateSpiideoIntegration Updates existing spiideo integration. # Create subscription Source: https://docs.mottostreaming.com/reference/studio-api/integration/subscriptions/v1/create-subscription post /integration/subscriptions/v1 CreateSubscription Creates new subscription. # Delete subscription Source: https://docs.mottostreaming.com/reference/studio-api/integration/subscriptions/v1/delete-subscription delete /integration/subscriptions/v1/{subscription_id} DeleteSubscription Deletes existing subscription. # Get subscription Source: https://docs.mottostreaming.com/reference/studio-api/integration/subscriptions/v1/get-subscription get /integration/subscriptions/v1/{subscription_id} GetSubscription Returns subscription information by subscription ID. # List subscriptions Source: https://docs.mottostreaming.com/reference/studio-api/integration/subscriptions/v1/list-subscriptions get /integration/subscriptions/v1 ListSubscriptions Returns list of subscriptions based on specified parameters. # Update subscription Source: https://docs.mottostreaming.com/reference/studio-api/integration/subscriptions/v1/update-subscription patch /integration/subscriptions/v1/{subscription_id} UpdateSubscription Updates existing subscription. # List topics Source: https://docs.mottostreaming.com/reference/studio-api/integration/topics/v1/list-topics get /integration/topics/v1 ListTopics Returns list of topics that are available to subscribe to. # Introduction Source: https://docs.mottostreaming.com/reference/studio-api/introduction An authenticated API for managing Motto resources ## What for? The Motto Studio API is the API that allows Creating, Reading, Updating and Deleting resources in Motto. It is meant to be accessed only by trusted users or machines as it enables potentially destructive operations. If you are looking for an API to integrate into your end-user facing products, have a look at our [Content Delivery API](/reference/content-delivery-api/introduction). If you prefer using gPRC over REST, we support the gRPC-compatible [Connect protocol](https://connectrpc.com/). That API reference can be found [here](https://buf.build/motto/api). ## Authentication To authenticate with our Studio API, please use a standard `Authorization: Bearer XYZ` HTTP header. To retrieve your actual Bearer token (which is a Java Web Token), sign in to the Motto Studio and then visit [this page](https://studio.mottostreaming.com/organization/api-credentials). There, you will find the secret API token belonging to the account that you are signed in to. Currently, service accounts aren't supported, but they are being considered for development. ## Access control Our Studio API works with a fine-grained access control system inspired by the IAM system of Google Cloud Platform. For more details, please continue reading [here](/glossary/iam). ## Rate limits Our Studio API enforces rate-limits on a per-endpoint, per-service and global basis. If you are worried that these rate limits may be too restrictive for your use-case, please [reach out](mailto:info@mottostreaming.com), so we can discuss increasing the rate limits for your particular situation. # Create sponsorship collection Source: https://docs.mottostreaming.com/reference/studio-api/monetization/ads/v1/create-sponsorship-collection post /monetization/ads/v1/sponsorship_collections CreateSponsorshipCollection Creates new sponsorship_collection. # Create video ad Source: https://docs.mottostreaming.com/reference/studio-api/monetization/ads/v1/create-video-ad post /monetization/ads/v1/video_ads CreateVideoAd Creates new video_ad. # Delete sponsorship collection Source: https://docs.mottostreaming.com/reference/studio-api/monetization/ads/v1/delete-sponsorship-collection delete /monetization/ads/v1/sponsorship_collections/{sponsorship_collection_id} DeleteSponsorshipCollection Deletes existing sponsorship_collection. # Delete video ad Source: https://docs.mottostreaming.com/reference/studio-api/monetization/ads/v1/delete-video-ad delete /monetization/ads/v1/video_ads/{video_ad_id} DeleteVideoAd Deletes existing video_ad. Can only be done when there are no more videos attached to it. # Get sponsorship collection Source: https://docs.mottostreaming.com/reference/studio-api/monetization/ads/v1/get-sponsorship-collection get /monetization/ads/v1/sponsorship_collections/{sponsorship_collection_id} GetSponsorshipCollection Returns information about the sponsorship_collection. # Get video ad Source: https://docs.mottostreaming.com/reference/studio-api/monetization/ads/v1/get-video-ad get /monetization/ads/v1/video_ads/{video_ad_id} GetVideoAd Returns information about the video_ad. # List sponsorship collections Source: https://docs.mottostreaming.com/reference/studio-api/monetization/ads/v1/list-sponsorship-collections get /monetization/ads/v1/sponsorship_collections ListSponsorshipCollections Return list of sponsorship_collections. # List video ads Source: https://docs.mottostreaming.com/reference/studio-api/monetization/ads/v1/list-video-ads get /monetization/ads/v1/video_ads ListVideoAds Return list of video_ads. # Update sponsorship collection Source: https://docs.mottostreaming.com/reference/studio-api/monetization/ads/v1/update-sponsorship-collection patch /monetization/ads/v1/sponsorship_collections/{sponsorship_collection_id} UpdateSponsorshipCollection Updates a sponsorship_collection. # Update video ad Source: https://docs.mottostreaming.com/reference/studio-api/monetization/ads/v1/update-video-ad patch /monetization/ads/v1/video_ads/{video_ad_id} UpdateVideoAd Updates a video_ad. When updating a video_ad that is already attached to one or more videos, this change will apply to all of those videos (including past ones). These changes apply asynchronously and may take a bit of time to propagate. # List entitlements Source: https://docs.mottostreaming.com/reference/studio-api/monetization/entitlements/v1/list-entitlements get /monetization/entitlements/v1 ListEntitlements Returns list of entitlements based on specified parameters. # Upsert entitlement Source: https://docs.mottostreaming.com/reference/studio-api/monetization/entitlements/v1/upsert-entitlement post /monetization/entitlements/v1 UpsertEntitlement Upserts a new entitlement or updates an existing entitlement. Note: If you wish to invalidate an existing entitlement, set the `expires_at` field to any moment in the past. # Create cleeng integration Source: https://docs.mottostreaming.com/reference/studio-api/monetization/integrations/v1/create-cleeng-integration post /monetization/integrations/v1/cleeng CreateCleengIntegration Creates new integration. # Create stripe integration Source: https://docs.mottostreaming.com/reference/studio-api/monetization/integrations/v1/create-stripe-integration post /monetization/integrations/v1/stripe CreateStripeIntegration Creates new integration. # Delete cleeng integration Source: https://docs.mottostreaming.com/reference/studio-api/monetization/integrations/v1/delete-cleeng-integration delete /monetization/integrations/v1/cleeng/{integration_id} DeleteCleengIntegration Deletes existing cleeng integration. # Delete stripe integration Source: https://docs.mottostreaming.com/reference/studio-api/monetization/integrations/v1/delete-stripe-integration delete /monetization/integrations/v1/stripe/{project_id} DeleteStripeIntegration Deletes existing stripe integration. # Get cleeng integration Source: https://docs.mottostreaming.com/reference/studio-api/monetization/integrations/v1/get-cleeng-integration get /monetization/integrations/v1/cleeng/{integration_id} GetCleengIntegration Returns integration information by integration ID. # Get stripe integration Source: https://docs.mottostreaming.com/reference/studio-api/monetization/integrations/v1/get-stripe-integration get /monetization/integrations/v1/stripe/{project_id} GetStripeIntegration Returns integration information by integration ID. # List cleeng integrations Source: https://docs.mottostreaming.com/reference/studio-api/monetization/integrations/v1/list-cleeng-integrations get /monetization/integrations/v1/cleeng ListCleengIntegrations Returns list of cleeng integrations based on specified parameters. # Update stripe integration Source: https://docs.mottostreaming.com/reference/studio-api/monetization/integrations/v1/update-stripe-integration patch /monetization/integrations/v1/stripe/{project_id} UpdateStripeIntegration Updates existing stripe integration. # Create offer Source: https://docs.mottostreaming.com/reference/studio-api/monetization/offers/v1/create-offer post /monetization/offers/v1 CreateOffer Creates new offer. # Delete offer Source: https://docs.mottostreaming.com/reference/studio-api/monetization/offers/v1/delete-offer delete /monetization/offers/v1/{offer_id} DeleteOffer Deletes existing offer. # Get offer Source: https://docs.mottostreaming.com/reference/studio-api/monetization/offers/v1/get-offer get /monetization/offers/v1/{offer_id} GetOffer Returns offer information by offer ID. # List offers Source: https://docs.mottostreaming.com/reference/studio-api/monetization/offers/v1/list-offers get /monetization/offers/v1 ListOffers Returns list of offers based on specified parameters. # Update offer Source: https://docs.mottostreaming.com/reference/studio-api/monetization/offers/v1/update-offer patch /monetization/offers/v1/{offer_id} UpdateOffer Updates existing offer. # List payment methods Source: https://docs.mottostreaming.com/reference/studio-api/monetization/payment-methods/v1/list-payment-methods get /monetization/payment_methods/v1/batch BatchGetPaymentMethods Returns a list of payment methods by payment method IDs. # Get transaction Source: https://docs.mottostreaming.com/reference/studio-api/monetization/transactions/v1/get-transaction get /monetization/transactions/v1/{transaction_id} GetTransaction Returns transaction information by transaction ID. # List transactions Source: https://docs.mottostreaming.com/reference/studio-api/monetization/transactions/v1/list-transactions get /monetization/transactions/v1 ListTransactions Returns list of transactions based on specified parameters. # Batch get file kinds Source: https://docs.mottostreaming.com/reference/studio-api/ott/file-kinds/v1/batch-get-file-kinds get /ott/file_kinds/v1/batch BatchGetFileKinds Returns kinds of files by file_kind IDs. # List file kinds Source: https://docs.mottostreaming.com/reference/studio-api/ott/file-kinds/v1/list-file-kinds get /ott/file_kinds/v1 ListFileKinds Returns list of kinds of files that can be uploaded. # Create file Source: https://docs.mottostreaming.com/reference/studio-api/ott/files/v1/create-file post /ott/files/v1 CreateFile Creates new file. # Delete file Source: https://docs.mottostreaming.com/reference/studio-api/ott/files/v1/delete-file delete /ott/files/v1/{file_id} DeleteFile Deletes existing file. # Get file Source: https://docs.mottostreaming.com/reference/studio-api/ott/files/v1/get-file get /ott/files/v1/{file_id} GetFile Returns file information by file ID. # List files Source: https://docs.mottostreaming.com/reference/studio-api/ott/files/v1/list-files get /ott/files/v1 ListFiles Returns list of files based on specified parameters. # Batch get page components Source: https://docs.mottostreaming.com/reference/studio-api/ott/page-components/v2/batch-get-page-components get /ott/page_components/v2/batch BatchGetPageComponents Returns page_component information by page_component IDs. # Create page component Source: https://docs.mottostreaming.com/reference/studio-api/ott/page-components/v2/create-page-component post /ott/page_components/v2 CreatePageComponent Creates new page_component. # Delete page component Source: https://docs.mottostreaming.com/reference/studio-api/ott/page-components/v2/delete-page-component delete /ott/page_components/v2/{page_component_id} DeletePageComponent Deletes an existing page_component. # Get page component Source: https://docs.mottostreaming.com/reference/studio-api/ott/page-components/v2/get-page-component get /ott/page_components/v2/{page_component_id} GetPageComponent Returns page_component information by page_component ID. # Update page component Source: https://docs.mottostreaming.com/reference/studio-api/ott/page-components/v2/update-page-component patch /ott/page_components/v2/{page_component_id} UpdatePageComponent Updates an existing page_component. # Create page Source: https://docs.mottostreaming.com/reference/studio-api/ott/pages/v2/create-page post /ott/pages/v2 CreatePage Creates new page. # Delete page Source: https://docs.mottostreaming.com/reference/studio-api/ott/pages/v2/delete-page delete /ott/pages/v2/{page_id} DeletePage Deletes existing page. # Get page Source: https://docs.mottostreaming.com/reference/studio-api/ott/pages/v2/get-page get /ott/pages/v2/{page_id} GetPage Returns page information by page ID. # List pages Source: https://docs.mottostreaming.com/reference/studio-api/ott/pages/v2/list-pages get /ott/pages/v2 ListPages Returns list of pages based on specified parameters. # Update page Source: https://docs.mottostreaming.com/reference/studio-api/ott/pages/v2/update-page patch /ott/pages/v2/{page_id} UpdatePage Updates existing page. # Create platform Source: https://docs.mottostreaming.com/reference/studio-api/ott/platforms/v1/create-platform post /ott/platforms/v1 CreatePlatform Creates new platform. # Delete platform Source: https://docs.mottostreaming.com/reference/studio-api/ott/platforms/v1/delete-platform delete /ott/platforms/v1/{platform_id} DeletePlatform Deletes existing platform. # Get platform Source: https://docs.mottostreaming.com/reference/studio-api/ott/platforms/v1/get-platform get /ott/platforms/v1/{platform_id} GetPlatform Returns platform information by platform ID. # List platforms Source: https://docs.mottostreaming.com/reference/studio-api/ott/platforms/v1/list-platforms get /ott/platforms/v1 ListPlatforms Returns list of platforms based on specified parameters. # Update platform Source: https://docs.mottostreaming.com/reference/studio-api/ott/platforms/v1/update-platform patch /ott/platforms/v1/{platform_id} UpdatePlatform Updates existing platform. # Create slug Source: https://docs.mottostreaming.com/reference/studio-api/ott/slugs/v1/create-slug post /ott/slugs/v1 CreateSlug Creates new slug. # Delete slug Source: https://docs.mottostreaming.com/reference/studio-api/ott/slugs/v1/delete-slug delete /ott/slugs/v1/{slug} DeleteSlug Deletes existing slug. # Get slug Source: https://docs.mottostreaming.com/reference/studio-api/ott/slugs/v1/get-slug get /ott/slugs/v1/{slug} GetSlug Returns slug information by slug ID. # List slugs Source: https://docs.mottostreaming.com/reference/studio-api/ott/slugs/v1/list-slugs get /ott/slugs/v1 ListSlugs Returns list of slugs based on specified parameters. # Delete asset Source: https://docs.mottostreaming.com/reference/studio-api/streaming/assets/v1/delete-asset delete /streaming/assets/v1/{asset_id} DeleteAsset Deletes the asset. # Get asset Source: https://docs.mottostreaming.com/reference/studio-api/streaming/assets/v1/get-asset get /streaming/assets/v1/{asset_id} GetAsset Returns information about the asset. # Get asset url Source: https://docs.mottostreaming.com/reference/studio-api/streaming/assets/v1/get-asset-url get /streaming/assets/v1/{asset_id}/url GetAssetURL Returns a signed or public URL for downloading or reading an asset. # List assets Source: https://docs.mottostreaming.com/reference/studio-api/streaming/assets/v1/list-assets get /streaming/assets/v1 ListAssets Returns a list of assets. # Set asset labels Source: https://docs.mottostreaming.com/reference/studio-api/streaming/assets/v1/set-asset-labels post /streaming/assets/v1/{asset_id}/labels SetLabels Sets labels on the asset. # Create clip Source: https://docs.mottostreaming.com/reference/studio-api/streaming/clips/v1/create-clip post /streaming/clips/v1 CreateClip Creates a new clip from the provided input. The clip will be available for downloading once the process is complete. The clip will be stored in the project's storage and the length of the clip will be determined by the `trim_in` and `trim_out` fields. The length of the clip cannot be neither longer than the source nor longer than 2 minutes. The request happens asynchronously and the response will contain the clip's ID. The client can use the ID to query the clip's status by calling the GetClip method. # Get clip Source: https://docs.mottostreaming.com/reference/studio-api/streaming/clips/v1/get-clip get /streaming/clips/v1/{clip_id} GetClip Returns information about the requested clip. # Attach workflow Source: https://docs.mottostreaming.com/reference/studio-api/streaming/configurations/v1/attach-workflow post /streaming/configurations/v1/{configuration_id}/attach/{workflow_id} AttachConfiguration Attaches a configuration to a workflow. Multiple configurations can be attached to a workflow, but only one of each kind. # Create configuration Source: https://docs.mottostreaming.com/reference/studio-api/streaming/configurations/v1/create-configuration post /streaming/configurations/v1 CreateConfiguration Creates a new configuration. # Delete configuration Source: https://docs.mottostreaming.com/reference/studio-api/streaming/configurations/v1/delete-configuration delete /streaming/configurations/v1/{configuration_id} DeleteConfiguration Deletes the configuration. This will detach the configuration from all workflows. # Detach workflow Source: https://docs.mottostreaming.com/reference/studio-api/streaming/configurations/v1/detach-workflow post /streaming/configurations/v1/{configuration_id}/detach/{workflow_id} DetachConfiguration Detaches (removes) a configuration from a workflow. # Get configuration Source: https://docs.mottostreaming.com/reference/studio-api/streaming/configurations/v1/get-configuration get /streaming/configurations/v1/{configuration_id} GetConfiguration Returns information about the configuration. # List configurations Source: https://docs.mottostreaming.com/reference/studio-api/streaming/configurations/v1/list-configurations get /streaming/configurations/v1 ListConfigurations Return list of configurations. # Update configuration Source: https://docs.mottostreaming.com/reference/studio-api/streaming/configurations/v1/update-configuration patch /streaming/configurations/v1/{configuration_id} UpdateConfiguration Updates a configuration. # List ingest servers Source: https://docs.mottostreaming.com/reference/studio-api/streaming/ingest-servers/v2/list-ingest-servers get /streaming/ingest_servers/v2 ListServers Returns a list of ingest servers. # Create ingest Source: https://docs.mottostreaming.com/reference/studio-api/streaming/ingests/v2/create-ingest post /streaming/ingests/v2 # Delete ingest Source: https://docs.mottostreaming.com/reference/studio-api/streaming/ingests/v2/delete-ingest delete /streaming/ingests/v2/{ingest_id} # Disconnect Source: https://docs.mottostreaming.com/reference/studio-api/streaming/ingests/v2/disconnect post /streaming/ingests/v2/{ingest_id}/disconnect # Get ingest Source: https://docs.mottostreaming.com/reference/studio-api/streaming/ingests/v2/get-ingest get /streaming/ingests/v2/{ingest_id} # List ingests Source: https://docs.mottostreaming.com/reference/studio-api/streaming/ingests/v2/list-ingests get /streaming/ingests/v2 # Start pull Source: https://docs.mottostreaming.com/reference/studio-api/streaming/ingests/v2/start-pull post /streaming/ingests/v2/{ingest_id}/pull # Update ingest Source: https://docs.mottostreaming.com/reference/studio-api/streaming/ingests/v2/update-ingest patch /streaming/ingests/v2/{ingest_id} # Create live stream Source: https://docs.mottostreaming.com/reference/studio-api/streaming/live-streams/v2/create-live-stream post /streaming/live_streams/v2 CreateLiveStream Creates a new live stream. # Delete live stream Source: https://docs.mottostreaming.com/reference/studio-api/streaming/live-streams/v2/delete-live-stream delete /streaming/live_streams/v2/{live_stream_id} DeleteLiveStream Deletes the live stream and all resources within that live stream. # Get live stream Source: https://docs.mottostreaming.com/reference/studio-api/streaming/live-streams/v2/get-live-stream get /streaming/live_streams/v2/{live_stream_id} GetLiveStream Returns information about the live stream. # List live streams Source: https://docs.mottostreaming.com/reference/studio-api/streaming/live-streams/v2/list-live-streams get /streaming/live_streams/v2 ListLiveStreams Return list of live streams. # Update live stream Source: https://docs.mottostreaming.com/reference/studio-api/streaming/live-streams/v2/update-live-stream patch /streaming/live_streams/v2/{live_stream_id} UpdateLiveStream Updates live stream's basic fields (i.e. name) # Get playlist Source: https://docs.mottostreaming.com/reference/studio-api/streaming/playlists/v1/get-playlist get /streaming/playlists/v1/{playlist_id} GetPlaylist Returns playlist object. # Update playlist Source: https://docs.mottostreaming.com/reference/studio-api/streaming/playlists/v1/update-playlist patch /streaming/playlists/v1/{playlist_id} UpdatePlaylist Updates playlist. # Create simulcast Source: https://docs.mottostreaming.com/reference/studio-api/streaming/simulcasts/v1/create-simulcast post /streaming/simulcasts/v1 CreateSimulcast Creates a new simulcast. # Delete simulcast Source: https://docs.mottostreaming.com/reference/studio-api/streaming/simulcasts/v1/delete-simulcast delete /streaming/simulcasts/v1/{simulcast_id} DeleteSimulcast Deletes the simulcast. # Get simulcast Source: https://docs.mottostreaming.com/reference/studio-api/streaming/simulcasts/v1/get-simulcast get /streaming/simulcasts/v1/{simulcast_id} GetSimulcast Returns information about the simulcast. # Start simulcast Source: https://docs.mottostreaming.com/reference/studio-api/streaming/simulcasts/v1/start-simulcast post /streaming/simulcasts/v1/{simulcast_id}/start StartSimulcast Simulcast starts automatically. This method should be used when it was manually stopped or simulcast has FAILED status and connection should be retried. # Stop simulcast Source: https://docs.mottostreaming.com/reference/studio-api/streaming/simulcasts/v1/stop-simulcast post /streaming/simulcasts/v1/{simulcast_id}/stop StopSimulcast Use this method to stop active simulcasting. # Update simulcast Source: https://docs.mottostreaming.com/reference/studio-api/streaming/simulcasts/v1/update-simulcast patch /streaming/simulcasts/v1/{simulcast_id} UpdateSimulcast Updates simulcast's name and/or target. It's only available for simulcast with IDLE status. # Create stitcher Source: https://docs.mottostreaming.com/reference/studio-api/streaming/stitchers/v1/create-stitcher post /streaming/stitchers/v1 CreateStitcher Creates a new stitcher instance. The stitcher instance is used to stitch inputs into a single output. # Get stitcher Source: https://docs.mottostreaming.com/reference/studio-api/streaming/stitchers/v1/get-stitcher get /streaming/stitchers/v1/{stitcher_id} GetStitcher Returns information about the requested stitcher instance. # Create subtitle track Source: https://docs.mottostreaming.com/reference/studio-api/streaming/subtitle-tracks/v1/create-subtitle-track post /streaming/subtitle_tracks/v1 CreateTrack Creates a new track and starts asynchronously segmenting it for inclusion in the video (playlist). The track will be available for streaming once the process is complete. # Delete subtitle track Source: https://docs.mottostreaming.com/reference/studio-api/streaming/subtitle-tracks/v1/delete-subtitle-track delete /streaming/subtitle_tracks/v1/{track_id} DeleteTrack Deletes the track and all resources within that track. # List subtitle tracks Source: https://docs.mottostreaming.com/reference/studio-api/streaming/subtitle-tracks/v1/list-subtitle-tracks get /streaming/subtitle_tracks/v1 ListTracks Return list of tracks. This should always be filtered by `playlist_id`, and will return all results (unpaginated). # Create upload Source: https://docs.mottostreaming.com/reference/studio-api/streaming/uploads/v1/create-upload post /streaming/uploads/v1 CreateUploadSession Creates a new upload session. # Create ruleset Source: https://docs.mottostreaming.com/reference/studio-api/streaming/video-protection/v2/create-ruleset post /streaming/video_protection/v2/rulesets CreateVideoProtectionRuleset Creates new ruleset. # Delete ruleset Source: https://docs.mottostreaming.com/reference/studio-api/streaming/video-protection/v2/delete-ruleset delete /streaming/video_protection/v2/rulesets/{video_protection_ruleset_id} DeleteVideoProtectionRuleset Deletes existing ruleset. Can only be done when there are no more videos attached to it. # Get ruleset Source: https://docs.mottostreaming.com/reference/studio-api/streaming/video-protection/v2/get-ruleset get /streaming/video_protection/v2/rulesets/{video_protection_ruleset_id} GetVideoProtection Returns information about the video_protection. # List rulesets Source: https://docs.mottostreaming.com/reference/studio-api/streaming/video-protection/v2/list-rulesets get /streaming/video_protection/v2/rulesets ListVideoProtectionRulesets Return list of video_protections. # Update ruleset Source: https://docs.mottostreaming.com/reference/studio-api/streaming/video-protection/v2/update-ruleset patch /streaming/video_protection/v2/rulesets/{video_protection_ruleset_id} UpdateVideoProtectionRuleset Updates a video_protection_ruleset. When updating a ruleset that is already attached to one or more videos, this change will apply to all of those videos (including past ones). These changes apply asynchronously and may take a bit of time to propagate. # Delete video Source: https://docs.mottostreaming.com/reference/studio-api/streaming/videos/v1/delete-video delete /streaming/videos/v1/{video_id} DeleteVideo Deletes the video (including the associated playlists and segment files in storage). # Get video Source: https://docs.mottostreaming.com/reference/studio-api/streaming/videos/v1/get-video get /streaming/videos/v1/{video_id} GetVideo Returns information about the video. # List videos Source: https://docs.mottostreaming.com/reference/studio-api/streaming/videos/v1/list-videos get /streaming/videos/v1 ListVideos Return list of videos. # Update video Source: https://docs.mottostreaming.com/reference/studio-api/streaming/videos/v1/update-video patch /streaming/videos/v1/{video_id} UpdateVideo Updates video settings. # Create vod Source: https://docs.mottostreaming.com/reference/studio-api/streaming/vods/v2/create-vod post /streaming/vods/v2 CreateVideo Creates a new video and starts the process. The video will be available for streaming once the process is complete. # Delete vod Source: https://docs.mottostreaming.com/reference/studio-api/streaming/vods/v2/delete-vod delete /streaming/vods/v2/{vod_id} DeleteVideo Deletes the video and all resources within that video. # Get vod Source: https://docs.mottostreaming.com/reference/studio-api/streaming/vods/v2/get-vod get /streaming/vods/v2/{vod_id} GetVideo Returns information about the video. # List vods Source: https://docs.mottostreaming.com/reference/studio-api/streaming/vods/v2/list-vods get /streaming/vods/v2 ListVideos Return list of videos. # Process vod Source: https://docs.mottostreaming.com/reference/studio-api/streaming/vods/v2/process-vod post /streaming/vods/v2/{vod_id}/start_processing StartVideoProcess Starts the video process. The video will be available for streaming once the process is complete. # Update vod Source: https://docs.mottostreaming.com/reference/studio-api/streaming/vods/v2/update-vod patch /streaming/vods/v2/{vod_id} UpdateVideo Updates video's basic fields (i.e. name)