How to Remove the 12 mbps Limitation from Plex to Chromecast

Update: As of October 15th, 2015 (about 10 months after I originally wrote these instructions), Plex has finally removed the hard coded maximum bitrate. This guide will remain for historical reasons, but you should now not be required to follow these steps to stream high bitrate video to your Chromecast.

I am an enthusiastic user of Plex, but recently I discovered that they were making the poor choice of hard-coding a bitrate limitation in their Chromecast application. Essentially, this enforced a 12,000 kbps (~12 mbps) limitation on media, meaning that anything that has a higher bitrate would be transcoded. This isn’t a problem when you have a decent server running Plex, but I am running it on an old laptop that can barely keep up with 4 mbps transcodes.

I was able to get around the hard coded limitation (the technical how-I-did-it is also available), and you can do it to:

Requirements

Before you begin, you need a couple of different things:

  • Chrome web browser
  • A Plex server
  • A Chromecast
  • A Chromecast developer account
  • $5.00 USD (payable to Google for your Chromecast developer account)
  • Static file hosting, such as GitHub Gists or Amazon S31

Note, this hack only works in Chrome. It does not allow you to start casting high bitrate content from your iOS or Android devices.

Setting Up Your Chromecast

First, we will setup your Chromecast as a developer device. Because Chromecast applications (custom ones like Plex uses, at least) are vetted through a similar model as a mobile phone app store (i.e. they need to be approved before being runnable by others), we can’t just point a Chromecast to your new application. Also, I cannot personally host the modified application because of copyright laws (the code is property of Plex), so you must do the modification yourself.

Before you can actually make the modification, though, you need to turn on developer mode on your Chromecast. You will need a Cast Developer Account, which is used to make your devices “developer” friendly. This has a one time fee of $5.00.

To register for a Cast Developer Account, visit the web console and sign in with your Google account:

https://cast.google.com/publish/

You will see something like the following.

Cast developer registration

Simply follow the registration process and pay the $5.00 registration fee, and you will be taken to the dashboard.

Cast Developer console

Now, go ahead and click “Add a New Device”. Go to your physical Chromecast device and look for the serial number on the plastic housing, and input it into the form. You can also set a friendly description so that you know which Chromecast is which if you are registering more than once device.

You may want to register all of your Chromecast devices at once, since they take about 15 minutes to become ready.

Once you’ve added all of your devices to the console, you will need to wait about 15 minutes2 for the status to change to “Ready for Testing”. Once the device is ready for testing, you will need to reboot your device. The best way to do this is to unplug your Chromecast for a 60 seconds or more, then plug it back in.

Important: If you have a Chromecast (and not another Google Cast device), you will need to ensure your device sends its serial number when checking for updates, before rebooting the device. To do this, you can open the Chromecast app on your phone or tablet, and look in the device’s settings. On iOS, you can get here by tapping the Chromecast’s name in the list of devices, then “General”:

Send Your Serial Number When Checking for Updates

After your Chromecast is set to send its serial number when checking for updates, you can perform the reboot by unplugging the device for 60 seconds and plugging it back in.

Modifying Plex’s Chromecast Application

We can now remove the hard coded limitation of 12,000 kbps that Plex has set in their application. To do this, you need to download two files to your desktop:

To save the files, right click anywhere on the page (that is not on the image, if you’re looking at the “index.html” file), choose the “View Page Source” option. Browsers other than Chrome may use different wording for this menu item.

This will allow you to copy the raw source of the page without the browser tampering with it. Copy and paste the “source” of each of the above files into files on your desktop with the same names (i.e. “index.html” and “plex.js”).

Now, you will need to actually perform the modifications.

plex.js

Open the “plex.js” file in a text editor.

If you are on Windows, I highly suggest that you do not use Notepad. Notepad++ is a great, free alternative text editor. It is designed for programmers (unlike regular Notepad), so it won’t mess up the files you are trying to edit. Mac users can use any text editor they wish, except TextEdit. TextEdit mangles the HTML file even worse than Notepad on Windows, and tries to convert it into a rich text document. TextWrangler is a good, free, and lightweight text editor.

You can use the find command in your text editor (usually “Ctrl + F” or “Cmd + F” on a Mac) to look for the following text:

Simply change that section of code, so the code surrounding it now looks like the following:

Notice the missing code: "maxBitrate":12e3,. This is the bitrate limitation converted to scientific notation.

Save the file– we’re now going to upload it to GitHub’s Gist service.

Go to GitHub’s Gist service, and paste the content of your modified “plex.js” file into the text window. Because the file is so large, it will take a couple seconds. Also, in the “Name this file…” textbox, enter “plex.js”:

Create a Gist

Once you hit the “Create Secret Gist” button, you will see something like the following:

Created Gist for Plex

Go ahead and click the “Raw” button in the top right hand corner of the file’s contents, and you will be taken to a page with just your Javascript’s content. Make a note of the URL, which will look like the following:

Change the domain in the URL to githack.com, like so:

GitHack is a service that transforms raw GitHub Gists into files that render in the browser. By default, if you visited your page the browser would just consider the file to be plain text.

Now, we need to modify the page that is actually loaded by the Chromecast.

index.html

Open the “index.html” in a text editor.

You will need to make a couple of modifications to this file.

If you used the “View Page Source” method, find a line with the following:

Simply add a new line above it with the following content:

Also, find the line with the following content near the end of the file:

Change this to the URL that you made a note of earlier, with the “githack.com” domain:

Now, save the file and copy its contents. Create a new GitHub Gist and paste the contents of the “index.html” file into it. Change the name to “index.html”, and then create the secret Gist.

After the Gist is created, click the “Raw” button. Make a note of this URL, and also change the domain to “githack.com” like you did for the other file. Now, if you open this new URL in your web browser, you should see the following:

Ready to Cast!

This means your application is now working correctly, so we can go ahead and publish the URL into the Cast Developer Console!

Side note: You can use other hosting services, such as Amazon S3 or shared hosting, if you have them available. Simply change the above instructions to point to the relevant locations.

Publishing the Application

Go back to the Cast Developer Console, and click “Add New Application”. Choose the “Custom Receiver” application type and choose a name for your application. For the URL, use the “githack.com” URL that points to your “index.html” file.

You will see a “successfully registered” message, and be presented with an application ID that looks like: 4580A3F9. Make a note of this.

Installing the Chrome Extension

I developed a Chrome extension that performs the modifications necessary to the Plex website to inject your new app ID into the Plex web application. This allows for you to use your modified Chromecast application instead of the default one.

You can download the extension from my website.

Download Chrome Extension

The download will pop up a scary message saying that the extension may be able to harm your browser– this is only because it has not been uploaded through the Chrome web store. You can check the source of the extension if you are a developer, or just ignore the message and hit “Keep”.

Because the extension is not through the web store, you have to install it from the Chrome extensions page. Go to your Chrome settings and click “Extensions” in the sidebar, or navigate to “chrome://extensions” in another tab.

Open your downloads folder in Windows Explorer or your Mac’s Finder, and then drag the extension you just downloaded onto the Chrome extensions window. You will be prompted to add the extension.

Add the Chrome Extension

Now, you can add your application ID to the extension. Simply click the “Options” link next to the “High Bitrate Plex for Chromecast” extension in the list, enter the application ID you made a note of earlier, and hit save. You may wish to restart your browser for good measure.

Fixing the Chromecast Profile

Before you can actually stream higher bitrate media, you also need to change the XML profile for the Chromecast. On your Plex Media Server, find the “Chromecast.xml” profile located in the resources folder of the Plex server.

On Windows, this is found in:

On the Mac, the profile is located in:

On Ubuntu, the profile should be located here:

Open the XML profile, and find the following line:

Simply change the 12000 to a larger number, such as 300003, and save the profile. Restart your Plex server to apply the new profile changes.

Wrapping it Up

Now, go ahead and go to the Plex web application. With any luck, you’ll see the Chromecast icon pop up as usual. Now, when you try and cast content, you should actually see your application’s name in the Chromecast extension instead of just “Plex”.

This also means you can now cast high bitrate media (i.e. over 12,000 kbps) to your Chromecast without transcoding! You can verify this with any high bitrate media you have, or with the Jellyfish Bitrate Test videos. If you use the Jellyfish test videos, try out the 20 mbps or 25 mbps files– files in the 40 mbps did not work for me.

Once this fix is applied, all you have to do is install the Chrome extension onto any computers you wish to cast from. And because the Chromecast streams directly from your Plex server, you don’t even have to keep the PC on– you can put it away after you start the stream.

Hopefully, this proves to Plex that there is demand to remove the single maxBitrate statement in their Chromecast application. It’s obvious that the device is capable, and beyond me why they have stood their ground for so long. At least for now this limitation is just a slight inconvenience than a complete showstopper.


  1. Shared web hosting accounts, basic object storage, and any other publicly accessible web storage will be fine. Even GitHub Gists will work, which I will show you how to use. 
  2. You can always skip ahead to the next step and upload your Chromecast application and come back to the remaining part of this step later. 
  3. The Chromecast begins stuttering around 30,000 kbps. So yes, there is an upper limit, but it’s over double what Plex has initially set. 

Subscribe to my mailing list

Get my latest posts delivered directly to your inbox
 
 

Leave a Reply

Your email address will not be published. Required fields are marked *