Self-Hosting a Podcast
Tags: xml, rss, web
Published: 2018-01-31 17:15:32

---
title: Self-Hosting a Podcast
published: true
description: There are hundreds of ways to publish a podcast...but you really CAN do it yourself!
tags: xml, rss, web
cover_image: https://thepracticaldev.s3.amazonaws.com/i/8x9cue1sjjovdu21ryn4.jpg
---

Have you ever dreamed of hosting your own podcast? Or, maybe you already have one, but you don't know how to get it into the earbuds of listeners around the world.

When I came up with the idea for the MousePaw'dCast, the first question was how to publish it. Sure, we could park it as a random file somewhere, but we wanted to really get it out there! I did a lot of research into different services. Most of them cost money, and the free options were either trial-only, overly limited, or just downright creepy.

Then I remembered something that we often forget in today's service-oriented economy: **you really can do it yourself**.

Here's what you need.

* A plain old ordinary website.

* An account on Archive.org (optional, see below).

* A text editor.

* A little bit of patience.

# Drawbacks

Before we talk about how to do this, we need to get a few disadvantages out of the way:

* You're your own technical support. If something breaks, you're in charge of fixing it.

* You won't have advanced statistics, such as the number of subscribers. A few directories may provide this information, but many won't.

* You cannot easily monetize your podcast, since there's no way to tell how many people are listening or subscribing.

* Your podcast will be free; there is no way to charge people to listen to it.

As long as you don't mind these limitations, let's continue!

# Choosing a Host

First and foremost, we must have a place to serve the actual podcast audio from. The host should be...

* Very reliable - you don't want a listener to suddenly find they can't play the podcast.

* Good speed - you don't want your podcast "buffering" all the time.

* Capable of handling high demand - ultimately, everyone is streaming the podcast from the host.

There are two ways to do this, then: we can **host it ourselves** or **upload to Archive.org**.

The self-hosting approach is pretty straight forward. If your server meets the requirements discussed, it's as simple as putting the MP3 audio files on it. Easy, peasy.

However, if you don't want to use your own server for this, you can use the **Internet Archive**, which is the approach I'll be taking in this tutorial.

There are only two limitations to publishing via the Internet Archive:

1. Limited statistics.

2. The material must be either Creative Commons or Public Domain.

That second one may sound scary, but **when it comes to free-to-listen podcasts, there is no conceivable reason why you can't license under Creative Commons.** [Creative Commons Attribution NonCommercial-NoDerivs](https://creativecommons.org/licenses/by-nc-nd/3.0/) means that anyone can listen and share freely, but they can't remix it or use it for their own commercial purposes. You aren't giving up your own rights to your work.

# Preparing Materials

Before we start the whole process, let's make sure our podcast is *ready* to go. You should have the following materials. If you're missing any, make them right now!

* A one-paragraph description of your podcast episode, in plain text. You'll need this in several places.

* A square image for your podcast. It should be square, and saved in `jpg` format. Personally, I've found that 400x400 dimensions provide the perfect balance between size and quality.

* A web page for your podcast. Seriously, go make it now! This should include a complete episode index, as well as links to the different places to listen and download.

* The podcast episode itself, obviously. This should be saved in `MP3` format. If you're using Archive.org for file hosting, you can also upload in `OGG` format and it will derive the `MP3` for you; either way, all the podcast directories require `MP3`.

NOTE: If you're licensing the podcast under Creative Commons, you should announce that license in the podcast. You can really mention it anywhere, but the outro is the most logical place. ;)

# Uploading to Archive.org

NOTE: If you chose to host the files yourself, just skip this section.

Once you've created an account at Archive.org, go to the Upload page, and click `Upload Files`. Click `Select Files`, and upload the following to the same item:

* The podcast episode as an `MP3` or `OGG`. **Only upload one episode per item.**

* The podcast cover image as a `JPG`.

NOTE: The filename you choose for your episode audio file does matter. I recommend a strict naming convention like `myawesomepodcast_ep1.mp3`. Hold to that naming convention for each episode.

Fill out the following fields, following a format something like what I did here, but changing values for your needs.

```
Page Title: Episode 1: Cool Stuff

Page URL: MyAwesomePodcastEp1

Description: This is the one-paragraph description that you wrote in the previous step. Although the description itself needs to be plain-text in other places, you can go nuts with formatting here.

Subject Tags: podcast, topic, another topic, yet another topic, you get the idea

Creator: My Awesome Organization

Date: (The current date.)

Collection: Community Audio

Test Item: No

Language: English

License: (Choose the options for your license.)
```

Then, click `Upload and Create Your Item`.

Your podcast logo should appear on the item page, to the left of the audio playback bar. If the image *doesn't* appear, `Edit` the item, and select `change the information`. Under `Files, formats, and derivations:`, find the image file you uploaded. Make sure its `Format` is set to `Item Image`. Save your changes.

NOTE: The Internet Archive will automatically derive your item, creating the other formats of audio they host. If you only uploaded an `OGG`, give it some time, and the `MP3` form will be automatically created.

# Setting Up Your RSS File

To make your podcast discoverable and subscribable, you will need to create an RSS file. This is the part that scares most people off, but it isn't as hard as it sounds!

(If you want to see a complete and correct podcast RSS file, check out the one for the [MousePaw'dCast](https://mousepawmedia.com/rss/mousepawdcast.xml), and just view source.)

## Show Data

Start by opening up your favorite XML-capable text editor, and create a new file called `myawesomepodcast.xml`. Paste the following in:

```xml
<rss version="2.0" xmlns:media="http://search.yahoo.com/mrss/" xmlns:atom="http://www.w3.org/2005/Atom"
    xmlns:creativeCommons="http://backend.userland.com/creativeCommonsRssModule"
    xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd">
    <channel>
    </channel>
</rss>
```

Within the `<channel>` node, put the following, but change the URL to the place where your RSS *will* be hosted from.

```xml
<atom:link href="https://example.com/rss/myawesomepodcast.xml" rel="self" type="application/rss+xml" />
```

Now we'll set up the show's metadata, within the `<channel>` node, and after the `<atom:link` child we just defined.. This part only needs to be done once!

First, we define the title and description for the podcast show, as well as the link to the show's homepage.

```xml
<title>My Awesome Podcast</title>
<link>https://example.com/podcast</link>
<description>This is a one-sentence description of your show.</description>
```

We also need email addresses for the podcast editor, for show-related questions, and the webmaster email for technical stuff.

```xml
<managingEditor>podcast@example.com (Example)</managingEditor>
<webMaster>webmaster@example.com (Example)</webMaster>
```

Define the language for your podcast, and the copyright. Even if this is Creative Commons, you/your organization still technically holds copyright.

```xml
<language>en-us</language>
<copyright>Copyright (C) 2018 My Awesome Organization. All Rights Reserved.</copyright>
```

If you chose to license this under Creative Commons (again, necessary if you're hosting the files on Archive.org), the license goes next. You need to use the official URL for the **license deed**. See [creativecommons.org/licenses](https://creativecommons.org/licenses/) for a complete list.

```xml
<creativeCommons:license>
	https://creativecommons.org/licenses/by-nc-nd/4.0/
</creativeCommons:license>
```

The date you *originally* published the podcast goes under the `<pubDate>` node, while the last date you *updated* the podcast goes under the `<lastBuildDate>` node. Both are technically optional, but they're nice to have. (See [What is the difference between <pubDate> and <lastBuildDate> in RSS?](https://stackoverflow.com/q/1698076/472647). We use the [RFC 822](https://www.w3.org/Protocols/rfc822/) format here.

NOTE: While you must include the time to be technically correct in format, time *accuracy* isn't important here. It's fine if you just fudge the time.

```xml
<pubDate>Sat, 27 May 2017 02:00:00 GMT</pubDate>
<lastBuildDate>Wed, 31 Jan 2018 02:00:00 GMT</lastBuildDate>
```

We also include our lovely show image, which should be uploaded to the podcast's website. We also include the name of the podcast show, and the URL to the podcast web page.

```xml
<image>
	<url>https://example.com/img/podcast_cover.jpg</url>
	<title>My Awesome Podcast</title>
	<link>https://example.com/podcast</link>
</image>
```

This tag is needed for technical reasons. Just include it.

```xml
<docs>http://www.rssboard.org/rss-specification</docs>
```

We want to host on iTunes if at all possible, especially because many other services pull from that directory! We must include a few tags to be considered for inclusion there.

First is obviously the authorship.

```xml
<itunes:author>My Awesome Organization</itunes:author>
```

We also need to select some keywords, and a single category, for organizing our podcast. ([Here is a list of iTunes categories](https://gist.github.com/skattyadz/814315)). We also need to specify whether our podcast is adults-only.

```xml
<itunes:keywords>software,programming,game development,education,open source,technology</itunes:keywords>

<itunes:category text="Technology"/>

<itunes:explicit>clean</itunes:explicit>
```

We include the link to the cover image for the podcast from the podcast web page.

WARNING: Note that we are NOT serving the image URL over HTTPS! RSS and HTTPS have a love-hate relationship, mostly hate. Some fields just *don't* work with HTTPS, and this is one of them.

```xml
<itunes:image href="http://mousepawmedia.com/img/ours/mousepawdcast_cover.jpg"/>

```

Finally, we define ourselves or our organization as the owners of the podcast, and include a contact email.

```xml
<itunes:owner>
<itunes:name><![CDATA[My Awesome Organization]]></itunes:name>
	<itunes:email>podcast@example.com</itunes:email>
</itunes:owner>
```

## Episode Data

Now let's add an episode! This simply goes below our show data, still within the `<channel>` node.

You need one of these `<item>` nodes for every episode, and you should sort them in descending order (newest first).

```xml
<item>

</item>
```

Within the `<item>` node, let's define our episode name, as well as the link to the Archive.org page for it (or else, a dedicated episode page on our website). Note that we need the link under both `<link>` and `<guid>`

```xml
<title>Episode 1: Cool Stuff</title>
<link>https://archive.org/details/MyAwesomePodcastEp1</link>
<description>
	This is the one-paragraph description that you wrote in the previous step. Although the description itself needs to be plain-text in other places, you can go nuts with formatting here.
</description>
<guid isPermaLink="true">https://archive.org/details/MyAwesomePodcastEp1</guid>
```

We announce the date that we published the episode, in [RFC 822](https://www.w3.org/Protocols/rfc822/) format.

```xml
<pubDate>Fri, 26 Jan 2018 04:00:00 GMT</pubDate>
```         

Here's where things get tricky. If you fudge this part, the podcast directories won't be able to see your episode!

We actually define the episode information *twice*, following the two major formats. All the podcast directories use one or the other.

The first is the `<media:` format ([defined here](http://www.rssboard.org/media-rss)). We start by defining the content itself. This can be used exactly as you see it here, only changing...

* The direct `url` to the episode's `MP3`, and
* The exact `duration` of the podcast in *seconds*.

```xml
<media:content
	medium="audio"
	url="https://archive.org/download/MyAwesomePodcastEp1/myawesomepodcast_ep1.mp3"
	type="audio/mpeg"
	isDefault="true"
	expression="full"
	duration="3850">

</media:content>
```

The rest of the `<media:` nods go *under* the `<media:content>` node.

Now we specify the title and description.

```xml
<media:title type="plain">Episode 1: Cool Stuff</media:title>

<media:description>
	This is the one-paragraph description that you wrote in the previous step. Although the description itself needs to be plain-text in other places, you can go nuts with formatting here.
</media:description>

```

We need to specify whether the episode is for adults only (`adult`) or all audiences (`nonadult`). If you prefer, you can also use the ICRA or MPAA formats (see the [spec](http://www.rssboard.org/media-rss#media-rating)).

```xml
<media:rating scheme="urn:simple">nonadult</media:rating>
```

Specify the path to the show cover image...

```xml
<media:thumbnail url="https://example.com/img/podcast_cover.jpg"/>
```

We also should set a few keywords for our episode.

```xml
<media:keywords>
	programming, writing, creative writing, software, development, mousepaw media
</media:keywords>
```

That's it for the `<media:content>` node!

Now we can include the path to the media via the second format, `<enclosure>`. (Services that use this will pick up the episode data defined *above* our `<media:` node.) Remember, this goes *after* the `<media:content>` node.

Once again, you can use this tag exactly as I have it, just updating two fields...

* The `url`, which **must use HTTP, and NOT HTTPS!** If you use an HTTPS link to the `MP3`, some services will be unable to see the episode. 

* The `length` in *bytes*. Weird, I know.

```xml
<enclosure url="http://archive.org/download/MyAwesomePodcastEp1/myawesomepodcast_ep1.mp3" length="73312022" type="audio/mpeg"/>
```

Finally, we need to make iTunes happy with three more fields.

First, we tell iTunes where to find our podcast cover image.

```xml
<itunes:image href="https://example.com/img/podcast_cover.jpg"/>
```

We also need to specify the rating (`clean` or `explicit`)...

```xml
<itunes:explicit>clean</itunes:explicit>
```

...and we list the duration of the podcast in `HH:MM:SS` format.

```xml
<itunes:duration>1:04:10</itunes:duration>
```

Make sure you've closed your `</item>` node below all of that.

Now, upload your RSS to your podcast website at the URL you specified at the top of this XML file.

Before we go any further, you should validate your file! I use the [W3C Feed Validation Service](https://validator.w3.org/feed/) to check for syntax errors. I have put it to the test - it does *not* give false negatives! If it complains, fix the problem.

NOTE: If you get complaints about an invalid URL, you should be using `HTTP` instead of `HTTPS` for it.

# Getting Onto Podcast Directories

Great, you're ready to go live! Now comes the fun part: submitting to podcast directories!

Here's the ones I recommend (submission instructions linked). In most cases, you submit your podcast for consideration, and they decide whether to include it. Thus, quality matters!

* [SubscribeOnAndroid](https://www.subscribeonandroid.com/podcasters/): This doesn't list your podcast so much as provide you with a handy "Subscribe" link that works on 12+ Android-based podcast apps.
* [iTunes](https://itunespartner.apple.com/en/podcasts/overview), a.k.a. Apple Podcasts: If you only try to submit to one directory, make it this one! If you're on iTunes, you'll also automatically be picked up by Overcast.fm, PocketCasts, PodcastAddict, iCatcher, PlayerFM, and many other services.
* [Google Play](https://play.google.com/music/podcasts/publish): A major podcast service on Android, and no surprise! Getting on here is pretty easy.
* [iHeartRadio](https://www.iheart.com/news/submit-your-podcast-15298037/) is another popular service, and submission is as simple as a web form.
* [TuneIn](https://help.tunein.com/customer/portal/emails/new?ticket[labels_new]=podcast&t=764630)
* dev.to: Seriously, where else? If you have a tech podcast, just email the good folks here for consideration.

NOTE: I know Stitcher is a major podcast directory, but I didn't like their Terms of Service for podcasters.

As you get added to each directory, be sure to add links to your podcast web page, to encourage people to subscribe!

# Keep Going!

That's it! You have a real live podcast, available for all the world to enjoy! Now you only need to do a few obvious things to keep it going:

* Record new episodes, obviously.

* Every time you record a new episode and upload it, add it to the RSS feed on its own `<item>` node, above all the other episodes. *Revalidate your RSS feed*!

* Announce to all your friends, family, and social media followers that they can listen to you on all those awesome services.

* Sit back and smile. Your voice can be heard around the world on all the major podcast services. That's pretty awesome!

`<cursory_plug>`Oh yeah, and check out my own company's podcast, the [**MousePaw'dCast**](https://dev.to/mousepaw)!`</cursory_plug>`