ashley streb

This article explains the usage of sitemaps in enabling the discovery of your video content. Additionally, a strategy and sample code are provided for exposing your video content through the Brightcove system into both a sitemap and video sitemap.

There is a standard document, called a sitemap, that search engine indexers will look for when examining your site. This document will concisely tell the search engines what content is exposed on your site, the meta-data about that content and where that content is located on your site. Sitemaps are an XML file that follows a standard specificiation. Google specified different flavors of sitemaps that make them specialized for different vertical needs: news organizations, code and video.

For your video content you should always include the following sitemaps:

• Sitemap - A sitemap that will index your content in the standard text based search engines such as www.google.com or search.yahoo.com.
• Video Sitemap - A sitemap that will index your content in media centric search engines such as video.google.com

Note that both of these sitemaps index the meta-data about your video content and provide links to end-users. The difference is where the meta-data that is indexed is obtained from and how the content is surfaced in search results. Specific to the video sitemap, the search engine can use the meta-data contained in the sitemap document in addition to extracting information directly from the video file.

A proper SEO strategy for your video content will include creating both a standard sitemaps as well as a video sitemap. From a priority perspective, you want to create a standard Sitemap first and then a Video Sitemap.

Strategy

In addition to the meta-data about the video file we need to provide two 'landing' locations for our video content. The first is a page URL that the video
Because sitemaps are page centric, we need to create a model where each video in your library will have a unique page, or URL associated with it. This can be accomplished by having a single page whose behavior and content can be dynamically changed by passing in different query parameters to the page. E.g., if you have a URL like http://www.example.com/video.html?videoId=123 you would have the video.html page look for the videoId query parameter (videoId=123) and modify the contents of the page returned to the browser to contain information about video with id 123. This would be done on the server-side of your application where the page would look for the id and then use the Brightcove Media APIs to fetch meta-data about the video and write it into the page.

For the purposes of this article, it will be assumed that there is a single landing page on your site which can be used to playback all video content for you site. Different query parameters will be passed to the page to tell the page what video to playback and what video to surface meta-data for. For example, lets say you have a page that displays the contents of an entire playlist and queues up a specific video in a player. You tell the page what playlist to display meta-data for via a bclid query parameter and what video to surface in a player via the bctid parameter. Thus, what we want to do is create a URL for every unique playlist and video id combination.

Additionally, we must specify either the <video:content_loc> or <video:player_loc> element. We will opt to expose the content inside of a player to make sure it is played back through your player which will keep the analytics, advertising and branding with your content. We will make the player_loc element point to a Single Title Player from the Brightcove system via the Player URL publishing code. We can pass different video id's to this player to play via the bctid query parameter.

Code

#!/usr/bin/env ruby

=begin
This script can be used to generate a video sitemap for all videos associated with
playlists in a specific account.  To use, modify the CONFIGURATION section
to suit your particular account.
=end

########################################################################
# Imports
########################################################################

require 'rubygems'
require 'net/http'
require 'rexml/document'
require 'json'
include REXML

########################################################################
# Configuration
########################################################################

# Your Media API Token that provides access to the URL of the video file.
# If you don't have this, request it from Customer Support
MEDIA_API_TOKEN="JwdHSeKoF4-V_IOqxFx0Zfvnc3EbqY-Tcu1Jxax3mcM."

# The page on your site that will host the player and video.  The
# playlist and video id will be appended as query parameters to this
# path
LANDING_PAGE="http://www.roark31337.com/video"

# The Player URL publishing code for a single title player
# from your account.  This will be referenced by the
# video sitemap
PLAYER_URL="http://link.brightcove.com/services/player/bcpid4221758001"

# query parameter name that the 'playlist id' in brightcove should
# be associated with.  Can be extracted by your page and fed
# to your player
PLAYLIST_QUERY_PARAM_NAME="bclid"

# query parameter name that the 'video id' in brightcove should
# be associated with.  Can be extracted by your page and fed
# to your player
VIDEO_QUERY_PARAM_NAME="bctid"

########################################################################
# Properties
########################################################################
SITEMAP_FILE="video_sitemap.xml"

########################################################################
# Methods
########################################################################

# Create the root element of our document which contains the default
# namespace fo the document and the 'urlset' element.
def create_sitemap_header
    sitemap = Document.new()
    sitemap << XMLDecl.new("1.0", "UTF-8")
    sitemap.add_element("urlset", {'xmlns'=>'http://www.sitemaps.org/schemas/sitemap/0.9', 'xmlns:xsi'=>'http://www.w3.org/2001/XMLSchema-instance', 'xsi:schemaLocation'=>'http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd', 'xmlns:video'=>'http://www.google.com/schemas/sitemap-video/1.1'})
    return sitemap
end

# This method is used to fetch the videos from the server using the
# Media APIs.  NOTE: the token provided _must_ be enabled to output
# the URL to the videos.  The parsed JSON output is returned as a string
def fetch_playlists()
   url = "http://api.brightcove.com/services/library?command=find_all_playlists&get_item_count=true&token=#{MEDIA_API_TOKEN}"
   resp = Net::HTTP.get_response(URI.parse(url))
   data = resp.body

   # we convert the returned JSON data to native Ruby
   # data structure - a hash
   result = JSON.parse(data)

   # if the hash has 'Error' as a key, we raise an error
   if result.has_key? 'Error'
      raise "Error communicating with api.brightcove.com, exiting"
   end
   return result
end

# Iterate over the videos in the playlist and add an entry
# to the sitemap for each video.  This will include a unique URL
# to each video/playlist combination
def add_playlist_videos(playlist, sitemap)

  playlist['videos'].each do | video |
    # add the url element
    url_element = Element.new("url", sitemap.root)

    # add in location which is URL + playlist id and video id
    loc_element = Element.new("loc", url_element)
    loc_element.text = "#{LANDING_PAGE}?#{PLAYLIST_QUERY_PARAM_NAME}=#{playlist['id']}&#{VIDEO_QUERY_PARAM_NAME}=#{video['id']}"

    # add in the 'video' child element that contains video specific extensions
    video_element = Element.new("video:video", url_element)

    video_player_element = Element.new("video:player_loc", video_element)
    video_player_element.add_attribute("allow_embed", "Yes")
    video_player_element.text = "#{PLAYER_URL}?bctid=#{video['id']}"

    video_thumb_element = Element.new("video:thumbnail_loc", video_element)
    video_thumb_element.text = "#{video['thumbnailURL']}"

    video_title_element = Element.new("video:title", video_element)
    video_title_element.text = "#{video['name']}"

    video_description_element = Element.new("video:description", video_element)
    video_description_element.text = "#{video['shortDescription']}"

    video_pub_element = Element.new("video:publication_date", video_element)
    video_pub_element.text = "#{Time.at(video['lastModifiedDate'].to_f/1000).strftime('%Y-%m-%d')}"

    video_duration_element = Element.new("video:duration", video_element)
    video_duration_element.text = (video['length'].to_i/1000).to_s

    video_family_element = Element.new("video:family_friendly", video_element)
    video_family_element.text = "Yes"

    # add in our tags
    video['tags'].each do |tag|
      video_tag_element = Element.new("video:tag", video_element)
      video_tag_element.text = tag
    end
  end

end

# write out our sitemap to the filesystem so that it can then be pushed to the root
# directory of the website.  The file will be named sitemap.xml by default
def serialize_sitemap(sitemap)
  sitemap_file = File.new(SITEMAP_FILE, "w")
  sitemap.write(sitemap_file, 0)
  sitemap_file.close()
end

# The main method called to generate the sitemap for all the videos
# in the playlists associated with the account.  This requires
# using the Media APIs to fetch the playlists for the account
# and then for each video in each playlist creating a unique
# url entry in the sitemap
def generate_sitemap()
  sitemap=create_sitemap_header()

  playlists=fetch_playlists()
  playlists['items'].each do | playlist |
   add_playlist_videos(playlist, sitemap)
  end

  serialize_sitemap(sitemap)
  return sitemap
end

# kick of running our script by calling the generate_script method
generate_sitemap()

After that, you simply need to manually ingest the video sitemap file into Google. You can learn how to do that here.