JW Player Platform

https://docs.jwplayer.com/platform/docs
Admin
The JW Player Platform provides comprehensive tools and documentation for managing, hosting,...
Tokens:44,620
Snippets:224
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### JW Player Setup with DASH and HLS Streams (JavaScript)

Source: https://docs.jwplayer.com/platform/docs/protection-studio-drm-jwp-web-player-integration

Example JavaScript code demonstrating how to set up a JW Player with a playlist containing both DASH and HLS streams for the same content. This configuration prepares the player to handle adaptive bitrate streaming across different protocols.

```javascript
jwplayer('myElement').setup({
    "playlist": [{
        "sources": [{
            "file": "MPD-URL.mpd",
            "type": "application/dash+xml"
        }, {
            "file": "M3U8-URL.m3u8"
            "type": "application/vnd.apple.mpegurl"
        }]
    }]
});
```

--------------------------------

### Initialize and Setup JW Player with JavaScript

Source: https://docs.jwplayer.com/platform/docs/vpaid-20-interactive-ads-reference

This snippet shows how to initialize a JW Player instance on an HTML element and configure it with video file, image, and advertising tag. It requires the JW Player library to be loaded.

```javascript
var playerInstance = jwplayer("myElement");
playerInstance.setup({
    file: '//cdn.jwplayer.com/videos/bkaovAYt-640.mp4',
    image: '//support-static.jwplayer.com/images/VPAID2.png',
    advertising: {
        client: 'vast',
        tag: '//support-static.jwplayer.com/content/advertising/vpaid-2-test.xml'
    }
});
```

--------------------------------

### JW Player Setup with DRM Configuration (JavaScript)

Source: https://docs.jwplayer.com/platform/docs/protection-studio-drm-jwp-web-player-integration

This JavaScript example shows how to configure the JW Player setup with DRM-specific source objects. It includes Widevine and PlayReady configurations for DASH streams and FairPlay configurations for HLS streams, along with caption tracks.

```javascript
jwplayer('myElement').setup({
  "playlist": [
    {
      "sources": [
        {
          "drm": {
            "widevine": {
              "url": "Widevine LAURL"
            },
            "playready": {
              "url": "Playready LAURL"
            }
          },
          "file": "MPD-URL.mpd",
          "type": "application/dash+xml"
        },
        {
          "drm": {
            "fairplay": {
              "processSpcUrl": "FairPlay LAURL",
              "certificateUrl": "FairPlay Certificate URL"
            }
          },
          "file": "M3U8-URL.m3u8",
          "type": "application/vnd.apple.mpegurl"
        }
      ],
      "tracks": [
        {
          "kind": "captions",
          "file": "https://www.yourdomain.com/caption-file_en.vtt",
          "label": "English"
        },
        {
          "kind": "captions",
          "file": "https://www.yourdomain.com/caption-file_sp.vtt",
          "label": "Español"
        }
      ]
    }
  ] 
});
```

--------------------------------

### Offline Playback Setup

Source: https://docs.jwplayer.com/platform/docs/protection-studio-drm-exoplayer-integration

This section explains how to create a list of media items with associated DRM configuration and assign them to a DownloadTracker and DownloadRequest for offline playback.

```APIDOC
## Offline Playback Configuration

### Description
This API enables offline playback by allowing you to create a list of `MediaItem` objects, configure them with DRM details, and manage their download status using `DownloadTracker` and `DownloadRequest`.

### Method
N/A (Code examples for client-side implementation)

### Endpoint
N/A

### Parameters
N/A

### Request Example
```java
// Example of creating media items for offline playback
private static List<MediaItem> createMediaItems(Intent intent, DownloadTracker downloadTracker) {
    List<MediaItem> mediaItems = new ArrayList<>();
    for (MediaItem item : IntentUtil.createMediaItemsFromIntent(intent)) {
        mediaItems.add(
                maybeSetDownloadProperties(
                        item, downloadTracker.getDownloadRequest(item.localConfiguration.uri)));
    }
    return mediaItems;
}

// Helper method to set download properties on a MediaItem
private static MediaItem maybeSetDownloadProperties(
        MediaItem item, @Nullable DownloadRequest downloadRequest) {
    if (downloadRequest == null) {
        return item;
    }
    MediaItem.Builder builder = item.buildUpon();
    builder
            .setMediaId(downloadRequest.id)
            .setUri(downloadRequest.uri)
            .setCustomCacheKey(downloadRequest.customCacheKey)
            .setMimeType(downloadRequest.mimeType)
            .setStreamKeys(downloadRequest.streamKeys);
    @Nullable
    MediaItem.DrmConfiguration drmConfiguration = item.localConfiguration.drmConfiguration;
    if (drmConfiguration != null) {
        builder.setDrmConfiguration(
                drmConfiguration.buildUpon().setKeySetId(downloadRequest.keySetId).build());
    }
    return builder.build();
}
```

### Response
#### Success Response (N/A)
N/A

#### Response Example
N/A
```

--------------------------------

### Embed JW Player (HTML)

Source: https://docs.jwplayer.com/platform/docs/players-get-started

This snippet demonstrates how to embed a cloud-hosted JW Player into an HTML page. It includes the necessary script tag that points to the JW Player library, which will render the player on your site. Ensure the script source URL is correct for your player.

```html
<body> 
  ... 
 	<script src="https://cdn.jwplayer.com/players/UVQWMA4o-kGWxh33Q.js"></script>
  ... 
</body>
```

--------------------------------

### Add Custom Parameter to Playlist (JW Player)

Source: https://docs.jwplayer.com/platform/docs/apps-set-up-an-electronic-programming-guide-epg

This example demonstrates how to add a custom parameter to a JW Player playlist configuration. The `contentType: "liveChannel"` pair is specifically required when creating a manual playlist for live channels that will be used with an EPG.

```javascript
{
  "title": "My Live Channel Playlist",
  "playlist": [
    {
      "mediaid": "your_live_channel_id",
      "title": "Live Channel",
      "streamer": "rtmp://your.stream.server/live/",
      "file": "your_stream_name",
      "type": "rtmp",
      "custom": {
        "contentType": "liveChannel"
      }
    }
  ],
  "autostart": true
}
```

--------------------------------

### Sample EPG Schedule Data Files (JSON)

Source: https://docs.jwplayer.com/platform/docs/apps-manage-electronic-programming-guides-epgs

Provides sample JSON files illustrating the Broadcast Live chapter points format for EPG schedule data. These files serve as examples for editing or deleting schedule information.

```json
[
  {
    "start_time": "2023-10-27T10:00:00Z",
    "end_time": "2023-10-27T11:00:00Z",
    "title": "Morning News",
    "description": "A summary of the day's top stories."
  },
  {
    "start_time": "2023-10-27T11:00:00Z",
    "end_time": "2023-10-27T12:00:00Z",
    "title": "Midday Documentary",
    "description": "An in-depth look at a historical event."
  }
]
```

--------------------------------

### Configure JW Player and Handle Playback

Source: https://docs.jwplayer.com/platform/docs/protection-studio-drm-exoplayer-integration

Configures JW Player with media items, sets playback parameters, and prepares the player for playback. This includes setting track selections, event listeners, audio attributes, and initial playback state.

```java
player.setTrackSelectionParameters(trackSelectionParameters);
player.addListener(new PlayerEventListener());
player.addAnalyticsListener(new EventLogger());
player.setAudioAttributes(AudioAttributes.DEFAULT, /* handleAudioFocus= */ true);
player.setPlayWhenReady(startAutoPlay);
playerView.setPlayer(player);
configurePlayerWithServerSideAdsLoader();
debugViewHelper = new DebugTextViewHelper(player, debugTextView);
debugViewHelper.start();

boolean haveStartPosition = startItemIndex != C.INDEX_UNSET;
if (haveStartPosition) {
    player.seekTo(startItemIndex, startPosition);
}
player.setMediaItems(mediaItems, /* resetPosition= */ !haveStartPosition);
player.prepare();
updateButtonVisibility();
return true;
```

--------------------------------

### Initialize ExoPlayer with Media Items

Source: https://docs.jwplayer.com/platform/docs/protection-studio-drm-exoplayer-integration

Initializes an ExoPlayer instance with a provided list of `mediaItems`. This code snippet sets up the player builder, potentially configures extension decoders, and builds the player. It's a fundamental step in enabling video playback within an Android application using ExoPlayer.

```java
protected boolean initializePlayer() {
    if (player == null) {
        Intent intent = getIntent();

        mediaItems = createMediaItems(intent);
        if (mediaItems.isEmpty()) {
            return false;
        }

        lastSeenTracks = Tracks.EMPTY;
        ExoPlayer.Builder playerBuilder =
                new ExoPlayer.Builder(/* context= */ this)
                        .setMediaSourceFactory(createMediaSourceFactory());
        setRenderersFactory(
                playerBuilder, intent.getBooleanExtra(IntentUtil.PREFER_EXTENSION_DECODERS_EXTRA, false));
        player = playerBuilder.build();

```

--------------------------------

### Create Media Items with DRM for Offline Playback (Java)

Source: https://docs.jwplayer.com/platform/docs/protection-studio-drm-exoplayer-integration

Creates a list of MediaItems, potentially with DRM configuration, for offline playback. It utilizes a DownloadTracker to retrieve existing download requests and applies download properties to the MediaItems.

```java
private static List<MediaItem> createMediaItems(Intent intent, DownloadTracker downloadTracker) {
    List<MediaItem> mediaItems = new ArrayList<>();
    for (MediaItem item : IntentUtil.createMediaItemsFromIntent(intent)) {
        mediaItems.add(
                maybeSetDownloadProperties(
                        item, downloadTracker.getDownloadRequest(item.localConfiguration.uri)));
    }
    return mediaItems;
}

private static MediaItem maybeSetDownloadProperties(
        MediaItem item, @Nullable DownloadRequest downloadRequest) {
    if (downloadRequest == null) {
        return item;
    }
    MediaItem.Builder builder = item.buildUpon();
    builder
            .setMediaId(downloadRequest.id)
            .setUri(downloadRequest.uri)
            .setCustomCacheKey(downloadRequest.customCacheKey)
            .setMimeType(downloadRequest.mimeType)
            .setStreamKeys(downloadRequest.streamKeys);
    @Nullable
    MediaItem.DrmConfiguration drmConfiguration = item.localConfiguration.drmConfiguration;
    if (drmConfiguration != null) {
        builder.setDrmConfiguration(
                drmConfiguration.buildUpon().setKeySetId(downloadRequest.keySetId).build());
    }
    return builder.build();
}
```

--------------------------------

### Fetch DRM Content URL and LAURLs via API (curl)

Source: https://docs.jwplayer.com/platform/docs/protection-studio-drm-jwp-web-player-integration

This `curl` command retrieves a signed content URL for DRM playback. It makes a GET request to the JW Player API, returning the media URL and associated DRM-specific LAURLs in the response's sources array. Note that these URLs are valid for only 10 minutes.

```curl
curl -L -X GET 'https://cdn.jwplayer.com/v2/media/{media_id}/drm/{policy_id}?token={valid_JWT}' \
   - H 'Authorization: Bearer {v2_api_secret}'
```

--------------------------------

### Initialize JW Player with DRM Playlist

Source: https://docs.jwplayer.com/platform/docs/protection-studio-drm-jwp-web-player-integration

Initializes the JW Player with a multi-item playlist, where each item includes DRM configurations for different playback types like DASH and HLS (FairPlay). The `mediaId` and placeholder `drm` URLs are provided, which will be dynamically replaced by the intermediary service.

```javascript
jwplayer("player").setup({
    "playlist": [{
        "title": "DRM Item 1",
        "mediaId": "mediaId1",
        "sources": [{
            "drm": {
                "widevine": {
                    "url": "https://temp.com"
                },
                "playready": {
                    "url": "https://temp.com"
                }
            },
            "file": "https://temp.mpd",
            "type": "application/dash+xml"
        },{
            "drm": {
                "fairplay": {
                    "processSpcUrl": "https://temp.com",
                    "certificateUrl": "https://temp.com"
                },
            },
            "file": "https://temp.m3u8",
            "type": "application/vnd.apple.mpegurl"
        }]
    },{
        "title": "DRM Item 2",
        "mediaId": "mediaId2",
        "sources": [{
            "drm": {
                "widevine": {
                    "url": "https://temp.com"
                },
                "playready": {
                    "url": "https://temp.com"
                }
            },
            "file": "https://temp.mpd",
            "type": "application/dash+xml"
        },{
            "drm": {
                "fairplay": {
                    "processSpcUrl": "https://temp.com",
                    "certificateUrl": "https://temp.com"
                },
            },
            "file": "https://temp.m3u8",
            "type": "application/vnd.apple.mpegurl"
        }]
    }]
});
```

--------------------------------

### Swift Fetch DRM Data from JW Player API

Source: https://docs.jwplayer.com/platform/docs/protection-studio-drm-jwp-ios-integration

Fetches DRM-related content data from a JW Player API endpoint using a GET request. It then decodes the JSON response into Swift structs and specifically extracts FairPlay DRM details, including the index of the correct source.

```swift
func fetchData(completion: @escaping() -> Void) {
        // Create a boolean to let us know when data fetch is complete
        var gotURI = false
        // Construct HTTP request headers
        let headers = ["Accept": "application/json; charset=utf-8"]
        // Construct HTTP request
        let request = NSMutableURLRequest(url: NSURL(string: jwSource!)! as URL,
                                             cachePolicy: .useProtocolCachePolicy,
                                             timeoutInterval: 10.0)
        request.httpMethod = "GET"
        // Add headers to request
        request.allHTTPHeaderFields = headers
        // Construct data task to handle response data or error
        let dataTask = URLSession.shared.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
            if (error != nil) {
                print(error)
            } else {
                guard let data = data else { return }
                // Decode JSON response using DeliveryAPI struct
                if let jsonData = try? newJSONDecoder().decode(DeliveryAPI.self, from: data){
            // Check we have a "fairplay" element in our data, and if so, get the index of the source
		let arr:Array = jsonData.playlist[0].sources
		var fpIndex: Int? = nil
		for (index, element) in arr.enumerated(){
			if element.drm.fairplay != nil {
				fpIndex = index
			}
		}
		// Allocate DeliveryAPI relevant fields to our stream config

```

--------------------------------

### Create Media Items with DRM Configuration for ExoPlayer

Source: https://docs.jwplayer.com/platform/docs/protection-studio-drm-exoplayer-integration

Creates a list of `MediaItem` objects for ExoPlayer, incorporating DRM configurations if available. It handles intent actions, checks for cleartext traffic permissions, requests storage permissions if necessary, and validates DRM scheme support for API level 18 and above. This function is crucial for setting up playback with protected content.

```java
private List<MediaItem> createMediaItems(Intent intent) {
    String action = intent.getAction();
    boolean actionIsListView = IntentUtil.ACTION_VIEW_LIST.equals(action);
    if (!actionIsListView && !IntentUtil.ACTION_VIEW.equals(action)) {
        showToast(getString(R.string.unexpected_intent_action, action));
        finish();
        return Collections.emptyList();
    }

    List<MediaItem> mediaItems =
            createMediaItems(intent, DemoUtil.getDownloadTracker(/* context= */ this));
    for (int i = 0; i < mediaItems.size(); i++) {
        MediaItem mediaItem = mediaItems.get(i);

        if (!Util.checkCleartextTrafficPermitted(mediaItem)) {
            showToast(R.string.error_cleartext_not_permitted);
            finish();
            return Collections.emptyList();
        }
        if (Util.maybeRequestReadExternalStoragePermission(/* activity= */ this, mediaItem)) {
            // The player will be reinitialized if the permission is granted.
            return Collections.emptyList();
        }

        MediaItem.DrmConfiguration drmConfiguration = mediaItem.localConfiguration.drmConfiguration;
        if (drmConfiguration != null) {
            if (Build.VERSION.SDK_INT < 18) {
                showToast(R.string.error_drm_unsupported_before_api_18);
                finish();
                return Collections.emptyList();
            } else if (!FrameworkMediaDrm.isCryptoSchemeSupported(drmConfiguration.scheme)) {
                showToast(R.string.error_drm_unsupported_scheme);
                finish();
                return Collections.emptyList();
            }
        }
    }
    return mediaItems;
}
```

--------------------------------

### Markdown Formatting for Static Pages

Source: https://docs.jwplayer.com/platform/docs/add-a-static-page

This snippet provides examples of common markdown syntax used for formatting content within static pages on the JW Player platform. It covers headings, emphasis, lists, links, and images, enabling rich text content creation.

```markdown
# h1 Heading

## h2 Heading

### h3 Heading

#### h4 Heading

##### h5 Heading

###### h6 Heading
```

```markdown
---

---

***
```

```markdown
**This is bold text**
_ _This is bold text_ _

*This is italic text*
_This is italic text_
```

```markdown
Unordered:

- Start a line with +, -, or *
- Sub-lists are made by indenting 2 spaces

Ordered:

1. Lorem ipsum dolor sit amet
2. Consectetur adipiscing elit
3. Integer molestie lorem at massa

Or:

1. You can use sequential numbers...
1. ...or keep all the numbers as 1.

Start numbering with offset:
57. foo
1. bar

Loose lists:
- foo
- bar
```

```markdown
[JWP](https://www.jwplayer.com)

[Web App](https://github.com/jwplayer/ott-web-app)
```

```markdown
![logo](https://ottwebapp.web.app/images/logo.png)
```

--------------------------------

### JW Player VAST Ad Targeting Macro Example

Source: https://docs.jwplayer.com/platform/docs/ad-tag-targeting-macro-reference

Example of a VAST ad tag utilizing JW Player macros for ad targeting. This specific example shows how to use the '__page-url__' macro with Google Ad Manager (GAM).

```text
https://pubads.g.doubleclick.net/gampad/ads?sz=640x480&iu=/88234159/video&impl=s
&gdfp_req=1&env=vp&output=vast&unviewed_position_start=1&description_url=__page-url__
&correlator=__timestamp__
```

--------------------------------

### Configuring JW Player with Content URL (Swift)

Source: https://docs.jwplayer.com/platform/docs/protection-studio-drm-jwp-ios-integration

This code demonstrates how to configure the JW Player using an extracted video content URL. It creates a JWPlayerItem and JWPlayerConfiguration, then sets the player's contentKeyDataSource and configures the player.

```swift
let url = URL(string: jwpVideoEndpoint!)!
let playerItem = try! JWPlayerItemBuilder().file(url).build()
let config = try! JWPlayerConfigurationBuilder().playlist([playerItem]).build()

player.contentKeyDataSource = self
player.configurePlayer(with: config)
```

--------------------------------

### Example Ad Tag URL with CMS ID

Source: https://docs.jwplayer.com/platform/docs/vdh-export-video-content-to-gam

This is an example of an ad tag URL after appending the `cmsid` and `vid` parameters. It shows a specific Source ID (9999999) from GAM and the JW Player `__item-mediaid__` macro, illustrating the dynamic replacement for targeting.

```text
&cmsid=9999999&vid=__item-mediaid__
```

--------------------------------

### EPG Schedule Data Format (JSON)

Source: https://docs.jwplayer.com/platform/docs/apps-set-up-an-electronic-programming-guide-epg

This JSON structure represents the data format for an EPG schedule, detailing broadcast live chapter points. It's crucial for visualizing live channel schedules correctly. Ensure your EPG data conforms to this format.

```json
[
  {
    "channel": "channel1",
    "start": 1678886400,
    "end": 1678890000,
    "title": "News Program",
    "description": "Daily news update.",
    "image": "https://example.com/images/news.jpg"
  },
  {
    "channel": "channel1",
    "start": 1678890000,
    "end": 1678893600,
    "title": "Documentary",
    "description": "Exploring the Amazon rainforest.",
    "image": "https://example.com/images/doc.jpg"
  }
]
```

--------------------------------

### Embed JW Player using HTML iframe

Source: https://docs.jwplayer.com/platform/docs/vpaid-20-interactive-ads-reference

This snippet demonstrates embedding a JW Player video directly into an HTML page using an iframe. The URL points to a pre-configured JW Player embed, simplifying integration.

```html
<iframe src="https://cdn.jwplayer.com/players/1g8jjku3-TyzxQHMs.html" width="100%" height="450" frameborder="0" scrolling="auto" allowfullscreen></iframe>
```

--------------------------------

### SPA Deployment: Inline Method and Script Management for JW Player

Source: https://docs.jwplayer.com/platform/docs/manage-placements

This example shows the 'Inline method' for deploying JW Player placements in a Single Page Application (SPA) environment. It highlights the importance of manually destroying and reloading the placement `<div>` and its associated script tag when navigating between pages, often managed using React's `useEffect` hook to ensure proper lifecycle management.

```javascript
import React, { useEffect } from 'react';

function MyComponent() {
  const placementId = 'YOUR_PLACEMENT_ID';
  const playerId = 'YOUR_PLAYER_ID';

  useEffect(() => {
    // Append the script tag to the DOM
    const script = document.createElement('script');
    script.src = `https://cdn.jwplayer.com/players/${playerId}.js`;
    script.async = true;
    document.body.appendChild(script);

    // Cleanup function to remove the script and potentially the div
    return () => {
      const existingScript = document.querySelector(`script[src*='${playerId}.js']`);
      if (existingScript) {
        existingScript.remove();
      }
      // You might also need to remove the placement div if it's dynamically created
      const placementDiv = document.getElementById(placementId);
      if (placementDiv) {
        placementDiv.innerHTML = ''; // Clear content, or remove the element itself
      }
    };
  }, [placementId, playerId]); // Re-run effect if player or placement ID changes

  return (
    <div id={placementId}></div>
  );
}

export default MyComponent;

```

--------------------------------

### JW Player Play Sessions Table Name Examples

Source: https://docs.jwplayer.com/platform/docs/data-sharing-datasets

Illustrates the naming convention for the JW Player Play Sessions dataset in both Direct Share and Reader Account configurations. The table names include placeholders for JW account ID and a snowflake ID.

```sql
SELECT * FROM JW_DATA.PUBLIC.PLAY_SESSIONS_<jw_account_id>_<snowflake_id>;
SELECT * FROM JW_DATA.PUBLIC.PLAY_SESSIONS_<jw_account_id>;
```

--------------------------------

### XML Example of Custom Namespaced Element for Tags

Source: https://docs.jwplayer.com/platform/docs/vdh-set-up-a-new-import-feed

This XML snippet demonstrates how a custom namespaced element in an MRSS feed can be used to define tags for imported media. The value of the element, such as 'Mountains', is applied as a tag.

```xml
<jp:locationType>Mountains</jp:locationType>
```

--------------------------------

### Enable Companion Ads with DIV ID and Dimensions (JavaScript)

Source: https://docs.jwplayer.com/platform/docs/players-manage-ads-in-a-player

This example demonstrates how to configure a player to display companion ads. It requires specifying the DIV ID of the ad container and its dimensions within the player configuration.

```javascript
var playerConfig = {
  // ... other player configuration options
  advertising: {
    // ... other advertising settings
    companionAds: {
      enabled: true,
      divId: "ad-container-id",
      dimensions: {
        width: 300,
        height: 250
      }
    }
  }
};

jwplayer("player-id").setup(playerConfig);
```

--------------------------------

### Update JW Player Playlist Item with Signed URLs

Source: https://docs.jwplayer.com/platform/docs/protection-studio-drm-jwp-web-player-integration

Implements the `setPlaylistItemCallback` for JW Player to dynamically update playlist items before they are loaded. It uses global variables `policyId` and `urlServiceHost` to fetch manifest and LAURLs from an intermediary service based on content type and media ID.

```javascript
jwplayer().setPlaylistItemCallback(function(item, index) {
    return new Promise(function(resolve, reject) {
        updatePlaylistItem(item);
        resolve(item);
    }); 
});

function updatePlaylistItem(item) {
    if (item.sources[0].type == "dash") {
        item.file = getManifestUrl("mpd", item.mediaId, policyId);
        item.sources[0].drm = {
            widevine: {
                url: getLaurl("widevine", item.mediaId, policyId)
            },
            playready: {
                url: getLaurl("playready", item.mediaId, policyId)
            }
        }
    } else {
        item.file = getManifestUrl("m3u8", item.mediaId, policyId);
        item.sources[0].drm = {
            fairplay: {
                processSpcUrl: getLaurl("fairplay", item.mediaId, policyId, "/laurl"),
                certificateUrl: getLaurl("fairplay", item.mediaId, policyId, "/cert")
            }
        }
    }
    item.sources[0].file = item.file;
}

function getLaurl(drm, mediaId, policyId, fairplayPostfix="") {
    console.log("getting laurl for " + mediaId);
    var xmlHttp = new XMLHttpRequest();
    xmlHttp.open("GET", `${urlServiceHost}/${drm}/${mediaId}/${policyId}${fairplayPostfix}`, false);
    xmlHttp.send(null);
    return xmlHttp.responseText;
}

function getManifestUrl(type, mediaId, policyId) {
    console.log("getting manifest for " + mediaId);
    var xmlHttp = new XMLHttpRequest();
    xmlHttp.open("GET", `${urlServiceHost}/${type}/${mediaId}/${policyId}`, false);
    xmlHttp.send(null);
    return xmlHttp.responseText;
}
```

--------------------------------

### Hide JW Player Pagination with CSS

Source: https://docs.jwplayer.com/platform/docs/vpaid-20-interactive-ads-reference

This CSS snippet targets the JW Player's automatic page-to-page navigation element and hides it using display: none. This is useful for custom player UIs.

```css
.rm-Pagination {
  display: none;
}
```

--------------------------------

### Export Batches of Videos to GAM

Source: https://docs.jwplayer.com/platform/docs/vdh-export-video-content-to-gam

This example shows how to export more than 500 videos to Google Ad Manager by using 'page_limit' and 'page_offset' parameters. This allows for incremental export of video content in manageable batches.

```url
https://cdn.jwplayer.com/v2/playlists/{playlist_id}?format=googledfp&page_limit=500&page_offset=1
```

```url
https://cdn.jwplayer.com/v2/playlists/{playlist_id}?format=googledfp&page_limit=500&page_offset=500
```

--------------------------------

### Swift Data Structures for JW Player DRM API

Source: https://docs.jwplayer.com/platform/docs/protection-studio-drm-jwp-ios-integration

Defines Swift structs conforming to Codable to parse JSON responses from the JW Player DRM API. Includes structures for the main response, playlist items, images, sources, DRM details (FairPlay, Widevine, PlayReady), and text tracks. Also includes a helper function to create a JSONDecoder.

```swift
import Foundation

// MARK: - DeliveryAPI
struct DeliveryAPI: Codable {
    let title, welcomeDescription, kind: String
    let playlist: [Playlist]
    let feedInstanceID: String

    enum CodingKeys: String, CodingKey {
        case title
        case welcomeDescription = "description"
        case kind, playlist
        case feedInstanceID = "feed_instance_id"
    }
}

// MARK: - Playlist
struct Playlist: Codable {
    let title, mediaid: String
    let link: String
    let image: String
    let images: [Image]
    let duration, pubdate: Int
    let playlistDescription: String
    let sources: [Source]
    let tracks: [Track]

    enum CodingKeys: String, CodingKey {
        case title, mediaid, link, image, images, duration, pubdate
        case playlistDescription = "description"
        case sources, tracks
    }
}

// MARK: - Image
struct Image: Codable {
    let src: String
    let width: Int
    let type: String
}

// MARK: - Source
struct Source: Codable {
    let drm: DRM
    let file: String
    let type: String
}

// MARK: - DRM
struct DRM: Codable {
    let fairplay: Fairplay?
    let widevine: Widevine?
    let playready: Playready?
}

// MARK: - Fairplay
struct Fairplay: Codable {
    let processSpcUrl, certificateUrl: String

    enum CodingKeys: String, CodingKey {
        case processSpcURL = "processSpcUrl"
        case certificateURL = "certificateUrl"
    }
}

// MARK: - Widevine
struct Widevine: Codable {
    let url: String
}

// MARK: - Playready
struct Playready: Codable {
    let url: String
}

// MARK: - Track
struct Track: Codable {
    let file: String
    let kind: String
}

// MARK: - Helper functions for creating encoders and decoders

func newJSONDecoder() -> JSONDecoder {
    let decoder = JSONDecoder()
    return decoder
}

```

--------------------------------

### Processing SPC Data for FairPlay License (Swift)

Source: https://docs.jwplayer.com/platform/docs/protection-studio-drm-jwp-ios-integration

This function sends SPC (Server Playback Context) data to the FairPlay license server and retrieves the content key. It handles HTTP requests, checks for errors and status codes, and returns the license data.

```swift
func contentKeyWithSPCData(_ spcData: Data, completionHandler handler: @escaping (Data?, Date?, String?) -> Void) {
    guard let contentUUID = self.contentUUID else {
        handler(nil, nil, nil)
        return
    }
    
    var ckcRequest = URLRequest(url: URL(string: jwpSpcProcessEndpoint!)!)
    ckcRequest.httpMethod = "POST"
    ckcRequest.httpBody = spcData
    ckcRequest.addValue("application/octet-stream", forHTTPHeaderField: "Content-Type")
    
    URLSession.shared.dataTask(with: ckcRequest) { (data, response, error) in
  let httpResponse = response as? HTTPURLResponse
  let transactionID = httpResponse!.allHeaderFields["x-amz-cf-id"] as? String
guard error == nil, (200...299).contains(httpResponse.statusCode) else {
if let unwrappedID = transactionID {
                let message = ["contentKeyWithSPCData": "Unexpected HTTP status code: \(httpResponse!.statusCode) from FPS certificate server with transaction ID: \(unwrappedID)"]
                print(message)
            }

        handler(nil, nil, nil)
        return
    }
    handler(data, nil, nil)
}.resume()
}
```

--------------------------------

### Requesting FairPlay Application Certificate (Swift)

Source: https://docs.jwplayer.com/platform/docs/protection-studio-drm-jwp-ios-integration

This function retrieves the FairPlay application certificate using the extracted certificate URL. It handles potential errors during the request and returns the certificate data if successful.

```swift
func appIdentifierForURL(_ url: URL, completionHandler handler: @escaping (Data?) -> Void) {
    
    guard let certUrl = URL(string: jwpCertificateEndpoint!), 
          let appIdData = try? requestApplicationCertificate() else { 
              handler(nil)
              return
          }
    handler(appIdData)
}

func requestApplicationCertificate() throws -> Data? {
        var applicationCertificate: Data? = nil
        let request = URLRequest(url: URL(string: (jwpCertificateEndpoint))!)
        
        let session = URLSession.shared
        var gotResp = false
        let task = session.dataTask(with: request,
                                    completionHandler: { data, response, error -> Void in
            if let error = error{
                let message = ["requestApplicationCertificate": "Unable to retrieve FPS certificate: \(String(describing: error))."]
                print(message)
                
                return
            }
            let httpResponse = response as! HTTPURLResponse
            let transactionID = httpResponse.allHeaderFields["x-amz-cf-id"] as? String
            if let unwrappedID = transactionID {
                if (httpResponse.statusCode >= 400){
                    let message = ["requestApplicationCertificate": "Unexpected HTTP status code: \(httpResponse.statusCode) from FPS certificate server with transaction ID: \(unwrappedID)"]
                    print(message)
                    
                    return
                }
            }
            applicationCertificate = data
            gotResp = true
        })
        task.resume()
        
        while !gotResp {
            // wait
        }
        return applicationCertificate
    }
}
```

--------------------------------

### Add User ID to Manifest Request URL

Source: https://docs.jwplayer.com/platform/docs/set-up-server-side-analytics

This example demonstrates how to append the `user_id` query parameter to a JWP-hosted manifest URL for user tracking. This is applicable to JWP-hosted streams and does not affect cacheability or reliability.

```URL
https://cdn.jwplayer.com/manifests/a1b2c3.m3u8?user_id=john_doe
```

--------------------------------

### JW Player Play Sessions Monthly Aggregates Table Name Examples

Source: https://docs.jwplayer.com/platform/docs/data-sharing-datasets

Shows the naming convention for the Play Sessions Monthly Aggregates dataset. Similar to Play Sessions, these table names also use placeholders for JW account ID and snowflake ID for direct sharing.

```sql
SELECT * FROM JW_DATA.PUBLIC.PLAY_SESSIONS_MONTHLY_AGGREGATES_<jw_account_id>_<snowflake_id>;
SELECT * FROM JW_DATA.PUBLIC.PLAY_SESSIONS_MONTHLY_AGGREGATES_<jw_account_id>;
```

--------------------------------

### Construct JSON Feed URL for Playlist Export (JW Platform)

Source: https://docs.jwplayer.com/platform/docs/vdh-export-playlists-to-syndication-channels

This snippet shows how to construct JSON feed URLs for exporting video content from JW Platform playlists. It includes examples of using `page_limit` and `page_offset` for paginating exports, enabling the retrieval of videos in manageable chunks.

```plaintext
https://cdn.jwplayer.com/v2/playlists/{playlist_id}?format=json&page_limit=500
https://cdn.jwplayer.com/v2/playlists/{playlist_id}?format=json&page_limit=500&page_offset=500
```

--------------------------------

### SQL: Date/Time Dimension Calculations for Timezones and Truncation

Source: https://docs.jwplayer.com/platform/docs/analytics-sql-calculations-for-metrics-and-dimensions

SQL snippets for date and time dimension calculations. This includes truncating the start time to the hour in a specific timezone ('America/New_York') and adjusting start time based on viewer timezone offset.

```SQL
date_trunc('hour', convert_timezone('UTC', 'America/New_York', sap.START_TIME)) as EASTERN_START_HR
```

```SQL
DATEADD('hour', VIEWER_TZ_OFFSET, START_TIME) as local_start_time
```

--------------------------------

### POST /v2/sites/{site_id}/playlists/manual-playlist

Source: https://docs.jwplayer.com/platform/docs/vdh-create-a-manual-playlist

Creates a manual playlist, allowing for the manual ordering of a static list of videos. This endpoint is intended for developers to programmatically create playlists.

```APIDOC
## POST /v2/sites/{site_id}/playlists/manual-playlist

### Description
Creates a manual playlist, allowing for the manual ordering of a static list of videos. This endpoint is intended for developers to programmatically create playlists.

### Method
POST

### Endpoint
`/v2/sites/{site_id}/playlists/manual-playlist`

### Parameters
#### Path Parameters
- **site_id** (string) - Required - The ID of the site for which to create the playlist.

#### Request Body
- **title** (string) - Required - The name of the playlist.
- **description** (string) - Optional - A description for the playlist, used for SEO and searchable via the JWP dashboard and Platform API.
- **custom_parameters** (object) - Optional - Key-value pairs for tracking custom playlist parameters.
  - **key** (string) - Required - The key for the custom parameter.
  - **value** (string) - Required - The value for the custom parameter.
- **playlist_page_permalink** (string) - Optional - A permalink to be used as the sharing link for the playlist.
- **media** (array) - Optional - An array of media items to include in the playlist.
  - **media_id** (string) - Required - The ID of the media item.
  - **order** (integer) - Required - The order of the media item within the playlist.

### Request Example
```json
{
  "title": "My Awesome Playlist",
  "description": "A curated list of top videos",
  "custom_parameters": {
    "genre": "tutorial"
  },
  "media": [
    {
      "media_id": "VIDEO_ID_1",
      "order": 1
    },
    {
      "media_id": "VIDEO_ID_2",
      "order": 2
    }
  ]
}
```

### Response
#### Success Response (201 Created)
- **id** (string) - The unique ID of the created playlist.
- **title** (string) - The title of the playlist.
- **description** (string) - The description of the playlist.
- **custom_parameters** (object) - The custom parameters associated with the playlist.
- **playlist_page_permalink** (string) - The permalink for the playlist page.
- **media_count** (integer) - The number of media items in the playlist.
- **created_at** (string) - The timestamp when the playlist was created.
- **updated_at** (string) - The timestamp when the playlist was last updated.

#### Response Example
```json
{
  "id": "PLAYLIST_ID",
  "title": "My Awesome Playlist",
  "description": "A curated list of top videos",
  "custom_parameters": {
    "genre": "tutorial"
  },
  "playlist_page_permalink": "/my-awesome-playlist",
  "media_count": 2,
  "created_at": "2023-10-27T10:00:00Z",
  "updated_at": "2023-10-27T10:00:00Z"
}
```
```

--------------------------------

### VAST Tag Example with __random-number__ Macro

Source: https://docs.jwplayer.com/platform/docs/ad-tag-targeting-macro-reference

This example demonstrates how to include the '__random-number__' macro in a VAST tag URL. This macro is replaced by a random number (cachebuster) when JW Player makes an ad call, helping to prevent ad caching. The ad server will receive the URL with the macro substituted.

```javascript
https://example.adserver.com/vastResponse.xml?cb=__random-number__
```

--------------------------------

### Get Playlists (JSON)

Source: https://docs.jwplayer.com/platform/docs/vdh-export-playlists-to-syndication-channels

Retrieve a playlist in JSON format. You can specify page_limit and page_offset to export videos in batches.

```APIDOC
## GET /v2/playlists/{playlist_id}

### Description
Retrieves a playlist in JSON format.

### Method
GET

### Endpoint
`/v2/playlists/{playlist_id}`

### Parameters
#### Path Parameters
- **playlist_id** (string) - Required - The ID of the playlist.

#### Query Parameters
- **format** (string) - Optional - The desired output format. Use `json` for JSON.
- **page_limit** (integer) - Optional - The maximum number of videos to return per page. Maximum is 500.
- **page_offset** (integer) - Optional - The offset for pagination. Use multiples of `page_limit`.

### Request Example
```json
{
  "example": "https://cdn.jwplayer.com/v2/playlists/{playlist_id}?format=json&page_limit=500&page_offset=500"
}
```

### Response
#### Success Response (200)
- **(JSON Object)** - A JSON object containing playlist information and video items.

#### Response Example
```json
{
  "playlist_id": "{playlist_id}",
  "title": "Playlist Title",
  "description": "Playlist Description",
  "media": [
    {
      "video_id": "video_id_1",
      "title": "Video Title 1",
      "description": "Video Description 1",
      "playback_url": "Video Playback URL 1",
      "published_at": "2023-10-27T10:00:00Z"
    }
  ],
  "links": {
    "self": "https://cdn.jwplayer.com/v2/playlists/{playlist_id}?format=json&page_limit=500&page_offset=0"
  }
}
```
```

--------------------------------

### Access Control API Reference

Source: https://docs.jwplayer.com/platform/docs/platform-welcome

Reference for the Access Control API, specifically for Studio DRM to protect content.

```APIDOC
## POST /v2/sites/{site_id}/drm-policies

### Description
This endpoint allows you to manage DRM policies for content protection using Studio DRM. It is part of the Access Control service.

### Method
POST

### Endpoint
/v2/sites/{site_id}/drm-policies

### Parameters
#### Path Parameters
- **site_id** (string) - Required - The unique identifier for your site.

### Request Body
(Details for request body fields would typically be found in the full API documentation. This is a placeholder.)

### Request Example
```json
{
  "example": "request body for creating a DRM policy"
}
```

### Response
#### Success Response (200)
(Details for success response fields would typically be found in the full API documentation. This is a placeholder.)

#### Response Example
```json
{
  "example": "response body for successful DRM policy creation"
}
```
```

--------------------------------

### Get Playlists (RSS)

Source: https://docs.jwplayer.com/platform/docs/vdh-export-playlists-to-syndication-channels

Retrieve a playlist in RSS format. You can specify page_limit and page_offset to export videos in batches.

```APIDOC
## GET /v2/playlists/{playlist_id}

### Description
Retrieves a playlist in RSS format.

### Method
GET

### Endpoint
`/v2/playlists/{playlist_id}`

### Parameters
#### Path Parameters
- **playlist_id** (string) - Required - The ID of the playlist.

#### Query Parameters
- **format** (string) - Optional - The desired output format. Use `mrss` for RSS.
- **page_limit** (integer) - Optional - The maximum number of videos to return per page. Maximum is 500.
- **page_offset** (integer) - Optional - The offset for pagination. Use multiples of `page_limit`.

### Request Example
```json
{
  "example": "https://cdn.jwplayer.com/v2/playlists/{playlist_id}?format=mrss&page_limit=500&page_offset=500"
}
```

### Response
#### Success Response (200)
- **(RSS Feed)** - The RSS feed containing playlist information.

#### Response Example
```xml
<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:jwplayer="http://developer.longtailvideo.com/docs/">
  <channel>
    <title>Playlist Title</title>
    <link>https://your-jwplayer-dashboard-link.com</link>
    <description>Playlist Description</description>
    <item>
      <title>Video Title 1</title>
      <link>Video Playback URL 1</link>
      <description>Video Description 1</description>
      <jwplayer:video_id>video_id_1</jwplayer:video_id>
      <pubDate>Publication Date 1</pubDate>
    </item>
    </channel>
</rss>
```
```

--------------------------------

### Media Management API Reference

Source: https://docs.jwplayer.com/platform/docs/platform-welcome

Reference for the Media Management API, used to deliver and host content on your JW Player account.

```APIDOC
## POST /v2/sites/{site_id}/media

### Description
This endpoint allows you to manage media within your JW Player account. It is part of the Media Management service for delivering and hosting content.

### Method
POST

### Endpoint
/v2/sites/{site_id}/media

### Parameters
#### Path Parameters
- **site_id** (string) - Required - The unique identifier for your site.

### Request Body
(Details for request body fields would typically be found in the full API documentation. This is a placeholder.)

### Request Example
```json
{
  "example": "request body for posting media"
}
```

### Response
#### Success Response (200)
(Details for success response fields would typically be found in the full API documentation. This is a placeholder.)

#### Response Example
```json
{
  "example": "response body for successful media post"
}
```
```

--------------------------------

### Standard Header Method Embed Script for JW Player Placement

Source: https://docs.jwplayer.com/platform/docs/manage-placements

This JavaScript snippet demonstrates the recommended 'Header method' for deploying JW Player placements. It's designed to be added to the `<head>` element of a webpage, allowing for the loading of multiple placements on a specific page by locating and loading strategies into placement-specific `<div>` elements.

```javascript
<!-- Header method embed script -->
<script src="https://cdn.jwplayer.com/players/YOUR_PLAYER_ID.js"></script>
```
Tokens:
Raw