Pando Developer Site

While the Pando "Send-to-Web" preview is quick and easy, it doesn't always fit exactly as desired into an existing site design. If you'd like to design your own package previews, one easy way to do this is using the Pando Javascript API. The API makes the package metadata available to Javascript, so you need not write any server-side code to generate custom package previews. In addition to the information in the "Send-to-Web" preview, the Package Info Web Service also gives you real-time reports of the number of downloads and the expiration date.

For comparison, here is how to do previews in PHP.

Let's say we want to be able to display a package preview containing the thumbnail, title, number of times downloaded and number of days to expiration (or days since expiration). We want the title and thumbnail to link to the package URL only if it is not expired. We want it to look something like:

Building Target HTML and CSS

Since we'll be writing Javascript to generate our HTML preview, it helps to have a good sense of what we expect that output to look like before we start.

<table class="pandopackage"><tr>
  <td class="packagethumb" align="center" valign="center">
    <a href="[Package URL]"><img src="[Thumbnail URL]" alt=""></a>
  </td>
  <td class="packagemeta" valign="center">
    <span class="ptitle"><a href="[Package URL]">Title</a></span>
    <p>
    Downloaded <strong>N</strong> times<br>
    <span style="color: green;">Expires in X days</span><br>
    </p>
  </td>
</tr></table>

Note: For this example we're using a table based layout primarily because the Pando thumbnail is a variable size (maximum size is 100 pixels x 75 pixels, but it can be smaller in any dimension). If we want to center the thumbnail image both vertically and horizontally in a way that works in most browsers, a table cell is the most reliable way.

Accompanied with the following css, we get a nicely formatted image preview:

table.pandopackage {
	border: 1px solid green;
	float: left;
	margin-right: 10px;
}
.pandopackage td.packagethumb {
	width: 100px;
	height: 75px;
	text-align: center;
}
.pandopackage .packagethumb img {
	border: 0;
	vertical-align:middle;
}
.pandopackage td.packagemeta {
	margin: 0 0 0 10px;
	padding: 0;		
	width: 150px;
	font-family: Verdana, Arial, sans-serif;
	font-size: 11px;
}
.pandopackage .packagemeta span.ptitle {
	font-family: 'Lucida Grande', Arial, sans-serif;
	font-size: 14px;
	font-weight: bold;
	margin: 0 1em 0 0;
}

Building the Callback Function

In order to generate the HTML with the appropriate metadata for our preview, we'll need a callback function for PandoAPI.js to call that can accept the packageInfo array and construct the appropriate HTML. The following callback function will calculate the number of days till/since expiration, determine whether the package is expired, generate a title and thumbnail string (only wrapped in an anchor tag if the image is not expired), get the number of package downloads and construct an HTML string that looks like our target HTML. You can follow along in the comments:

function printPackageCallBack(packageInfo) {
	//Get number of days till expiration (negative = expired)
	var days = Math.round( (new Date(packageInfo['expirationDate']) - new Date()) / 86400000);
	//store expiration status
	var expired = (days >= 0) ? 0 : 1;
	//use absolute values of days for a readable string
	days = Math.abs(days);
	//get title from package info
	var title = packageInfo['title'];
	
	if (title.length > 30) {
		title = title.substring(0,28) + '...';
	}
	
	//generate img tag with thumbnail from package info
	var thumb = "<img src='"+ packageInfo['thumbnailURL'] +"' alt='' />";
	//generate anchor tag from package URL; assumes packageKey is set
	var packageA = "<a href='" + PandoAPI.getPackageURL(packageId,packageKey) + "'>";
	//get appropriately pluralized X day(s) string
	var daystring = days +' day'+ ( (days > 1) ? ('s') : ('') );
	//get # of downloads from package info
	var dl = packageInfo['downloads'];
	//if package is not expired, link the title and thumbnail to the package URL
	//  and set the expiration days string accordingly
	if(!expired) {
		title = packageA + title + '</a>';
		thumb = packageA + thumb + '</a>';
		daystring = '<span style="color: green;">Expires in '+ daystring +'</span><br />';
	//otherwise, do not link the title/thumbnail, and set expiration string accordingly
	} else if (!packageInfo['expirationDate']) {
		daystring = '<span style="color: green;"><strong>Never expires</span></strong><br />'
		title = packageA + title + '</a>';
		thumb = packageA + thumb + '</a>';
	} else {
		daystring = '<span style="color: red;">Expired '+ daystring +' ago</span><br />';
	}
	//generate human-friendly Downloaded X times / Never Download string
	if(dl > 0)
		dlstring = 'Downloaded <strong>'+dl+'</strong> time'+( (dl > 1) ? ('s') : ('') );
	else
		dlstring = 'Never downloaded';
	//write out the package preview
	out = ("\r\n<table class='pandopackage'>\r\n<tr>\r\n\t<td valign='center' align='center' 
	  class='packagethumb'>\r\n\t\t"+ thumb + '\r\n\t</td>\r\n\t<td valign="center"
	  class="packagemeta">\r\n\t\t<span class="ptitle">'+ title +'</span>\r\n\t\t<p>\r\n\t\t'
      + dlstring +'<br />\r\n\t\t'+ daystring +'\r\n\t\t</p>\r\n\t</td>\r\n</tr>\r\n</table>'
    );
	document.write(out);
}

Now, if we call PandoAPI.getPacakgeInfo with a package id, key and the above callback function, it will write directly into our page:

<script type="text/javascript">
  PandoAPI.getPackageInfo('5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB', 
    printPackageCallBack, 
    'C51E9F2767B6747A9C9841AF7EEB9CC0E967D5B37CEC05B8C9DF310A03958AD2');
</script>

A Touch of Elegance

That works fine, but document.writes are a little crude and the function call is a little tricky to construct correctly. Also, if the javascript fails to load (e.g., due to a temporary service outage), it could stop our entire page from loading from the point where we include the script. A common practice is to put remotely-dependent javascript code just above the </body> tag, so if it fails to load, it doesn't affect the rest of the page. However, if we do this, we could only write our package preview to the end of the page.

To make the function call to generate the preview a little simpler, we can write a wrapper function that accepts the package URL as an input (which is easy to acquire), parses out the package id and key and then invokes PandoAPI.getPackageInfo with the correct parameters. E.g.,

function parsePandoUrl(url) {
  var parts = url.split('?',2);
  var args = parts[1];
  parts = args.split('&');
  for(var i=0; i<parts.length; i++) {
    if(parts[i].match(/^id=[A-Z0-9]*/))
      packageId = parts[i].substring(3);
    if(parts[i].match(/^key=[A-Z0-9]*/))
      packageKey = parts[i].substring(4);			
  }
}

function showPackage(url) {
  parsePandoUrl(url);
  PandoAPI.getPackageInfo(packageId,printPackageCallBack,packageKey);
}

Now we can display a package preview for a particular package URL, like so:

<script type="text/javascript">
showPackage('http://cache.pando.com/soapservices/package.pando?
  id=5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB
  &key=C51E9F2767B6747A9C9841AF7EEB9CC0E967D5B37CEC05B8C9DF310A03958AD2');
</script>

And finally, in order to be able to call this function just before the closing <body> tag, we can change our call to document.write in the callback function to instead modify the "innerHTML" contents of an existing element on the page. For this example, we'll assume there's an empty <div> tag with the id of "packagedetails" somewhere on the page. We can then swap out document.write with:

document.getElementById('packagedetails').innerHTML = out;

Bring It All Together

Here is a stand-alone HTML implementation. [final custom javascript] [final custom css]. Feel free to use these on your web site as is, or extend them any way you like!

If you have questions, or want to share what you've come up with, post a comment below!

If you want to implement your own RSS feed, or wish to add Pando support to an existing RSS feed server, you'll need to know some technical details.

A Pando RSS feed is a standard RSS 2.0 feed containing Pando files as enclosures. Pando will download any enclosure with the MIME type "application/x-pando", or with the file extension ".pando".

The Pando JavaScript API (PandoAPI.js) provides access to the Pando Web Services for JavaScript code that is running inside a web browser.

To see an example of how to use PandoAPI.js, see Custom Package Previews with PandoAPI.js.

One important limitation of the Javascript XmlHttpRequest function (a cornerstone of AJAX) is that it does not allow a script to load the contents of a file from a domain other than the one on which the script is running. There are good reasons, from a security standpoint, that this limitation exists. There are many workarounds for this for sources you trust (e.g., proxying calls on your own server). We decided to experiment with a Javascript library that allows you to retrieve metadata from packages encoded in JSON without requiring server-side code, just client-side javascript.

The Pando Javascript API library is at http://cache.pando.com/soapservices/PandoAPI.js. To use it, you need to include it in your HTML document in the <head> section: <script src="http://cache.pando.com/soapservices/PandoAPI.js" type="text/javascript"></script>

PandoAPI.toString

The Pando Javascript API has three functions. The simplest (PandoAPI.toString) simply outputs the current version of the PandoAPI and is useful for debugging. For example,

<html>
  <head>
   <script src="http://cache.pando.com/soapservices/PandoAPI.js" type="text/javascript">
   </script>
  </head>
  <body>
   <script type="text/javascript">
     document.write(PandoAPI.toString());
   </script>
  </body>
</html>

This will output something like: PandoAPI vtrunk

PandoAPI.getPackageURL

The second function (PandoAPI.getPackageURL) is also simple. It requires the package id and key (and optionally accepts the gotPando parameter) and generates a Package URL.

<html>
  <head>
   <script src="http://cache.pando.com/soapservices/PandoAPI.js" type="text/javascript">
   </script>
  </head>
  <body>
   <script type="text/javascript">
    document.write(PandoAPI.getPackageURL('5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB',
      'C51E9F2767B6747A9C9841AF7EEB9CC0E967D5B37CEC05B8C9DF310A03958AD2'));
   </script>
  </body>
</html>

This will output the URL to the package:

http://cache.pando.com/soapservices/Package/Package.pando?
	id=5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB
	&key=C51E9F2767B6747A9C9841AF7EEB9CC0E967D5B37CEC05B8C9DF310A03958AD2 

You may also set the optional gotPando parameter. By default, it is false. Setting it to true will generate a Package URL that will skip the usual "is Pando installed?" test, and simply deliver the package. For example, replacing the necessary line from the above example:

document.write(PandoAPI.getPackageURL('5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB',
  'C51E9F2767B6747A9C9841AF7EEB9CC0E967D5B37CEC05B8C9DF310A03958AD2',
  true));

This will result in a URL that looks like

http://cache.pando.com/soapservices/Package/Package.pando?
	id=5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB
	&key=C51E9F2767B6747A9C9841AF7EEB9CC0E967D5B37CEC05B8C9DF310A03958AD2&hasPando=yes

Note: When a user follows such a link, the Pando services will attempt to set the Pando "installed" cookie.

getPackageInfo

The most powerful tool provided by this API is the PandoAPI.getPackageInfo function. It accepts as parameters the package ID, a callback function and the package key (optional). When called, this function writes another <script> tag into your document that makes available the package info in JSON format, and then calls the provided callback function to process this data. This example simply writes all the available package metadata directly into the page:

<html>
  <head>
  <script src="http://cache.pando.com/soapservices/PandoAPI.js" type="text/javascript"></script>
  </head>
  <body>
	<script type="text/javascript">
	function printPackageCallBack(packageInfo) {
 	  //print all the properties in the packageInfo object
	  for (var prop in packageInfo) 
		document.write(prop+': <em>'+packageInfo[prop]+'</em><br/>');
	}
		
	//the package id and key (replace with your own values)
	var packageId = '5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB'; 	
	var packageKey = 'C51E9F2767B6747A9C9841AF7EEB9CC0E967D5B37CEC05B8C9DF310A03958AD2';

	//use the API to retrieve the package info - results are returned to the callback function
	PandoAPI.getPackageInfo(packageId,printPackageCallBack, packageKey);

	</script>

	</body>
</html>

The resultant output (with "files" trimmed) looks something like:

version: 1.0
packageId: 5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB
key: C51E9F2767B6747A9C9841AF7EEB9CC0E967D5B37CEC05B8C9DF310A03958AD2
title: Spring Street Art
description: At 11 Spring St. some of NYC's best street artists have canvassed (literally)
the building with art that is sprayed/painted/glued on the exterior and interior walls.
creationDate: Sun, 17 Dec 2006 14:06:30 -0500
packager: Yaron Samid
thumbnailURL: http://services.pando.com/soapservices/SendToWeb?action=thumbnail
  &id=5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB
packageURL: http://cache.pando.com/soapservices/Package/package.pando?
  id=5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB
  &key=C51E9F2767B6747A9C9841AF7EEB9CC0E967D5B37CEC05B8C9DF310A03958AD2
packageSize: 187249946
fileCount: 91
files: [object Object], ..., [object Object]
downloads: 55
expirationDate: Sat, 12 Dec 2026 15:42:20 -0500

Notice that the file metadata aren't listed. Each file is an object containing name and size properties. If we replace our callback function to just print out a file list, e.g.:

function printPackageCallBack(packageInfo) {
  files = packageInfo['files'];
  for (var file in files)
	document.write(files[file].name +' : '+ files[file].size +' bytes<br />');
}

We get a (trimmed) list of file names, with sizes in bytes:

Spring Street Art/IMG_8277.jpg : 2196499 bytes
Spring Street Art/IMG_8368.jpg : 2397601 bytes
Spring Street Art/IMG_8369.jpg : 2432566 bytes
  ...
Spring Street Art/IMG_8366.jpg : 2319711 bytes
Spring Street Art/IMG_8367.jpg : 2071726 bytes

Now go read Custom Package Previews with PandoAPI.js.

PandoAPI.hasPando

This method gives web sites outside of the pando.com domain limited access to the status of the pando.com "installed" cookie. It accepts a callback function as an argument. This callback function accepts one argument, which can be true or false. When you invoke PandoAPI.hasPando, it will call document.write and write a script into your page that runs the callback function with the value set to true or false. Your callback function decides what to do with this information. We recommend running this method in your page's section and then waiting until the page is fully loaded (i.e., window.onload) to make use of the results. Please see "Using PandoAPI.js Installed Cookie Check" for a detailed example.

Getting Package Info

With a given Package ID (and optionally, package key), metadata about Pando packages can be retrieved from the Pando system. Request URLs take the following form:

http://cache.pando.com/soapservices/SendToWeb?action=info&format=Format&id=PackageId&key=PackageKey


Format can be either "xml" or "json," which determines how the data you request will be returned. The information returned includes:

• "static" package info (also stored in the package file itself)
  • package id (passed in the URL)
  • encryption key (optional; included only if passed in the URL). If the key is not provided, users cannot download the file from the Package URL, below.
  • package name
  • description
  • creation date, in RFC 822 format
  • packager name
  • thumbnail URL
  • package URL
  • total file size, in bytes
  • list of files, with count
• "dynamic" package info (changes over time)
  • number of downloads (number of completed downloads for the torrent right now).
  • expiration date, in RFC 822 format; omitted if the torrent has infinite expiration
  • expired; true if the package has expired from Pando's servers, omitted otherwise.

Example: XML

So, for example, the XML encoded package info for a package can be retrieved from the following URL:

http://cache.pando.com/soapservices/SendToWeb?action=info&format=xml
  &id=5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB
  &key=C51E9F2767B6747A9C9841AF7EEB9CC0E967D5B37CEC05B8C9DF310A03958AD2


Which returns the following result (with the "files" list trimmed -- full result here).

<?xml version="1.0"?>
<packageInfo>
	<version>1.0</version>
	<packageId>5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB</packageId>
	<key>C51E9F2767B6747A9C9841AF7EEB9CC0E967D5B37CEC05B8C9DF310A03958AD2</key>
	<title>Spring Street Art</title>
	<description>
		At 11 Spring St. some of NYC's best street artists have canvassed 
		(literally) the building with art that is sprayed/painted/glued on the 
		exterior and interior walls.
	</description>
	<creationDate>Sun, 17 Dec 2006 14:06:30 -0500</creationDate>
	<packager>Yaron Samid</packager>
	<thumbnailURL>http://services.pando.com/soapservices/SendToWeb?action=thumbnail
	&id=5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB</thumbnailURL>
	<packageURL>http://cache.pando.com/soapservices/Package/package.pando?
		id=5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB
		&key=C51E9F2767B6747A9C9841AF7EEB9CC0E967D5B37CEC05B8C9DF310A03958AD2
	</packageURL>
	<packageSize>187249946</packageSize>
	<files num="91">
		<file name="Spring Street Art/IMG_8277.jpg" size="2196499"/>
		[... trimmed ...]
		<file name="Spring Street Art/IMG_8367.jpg"size="2071726"/>
	</files>
	<downloads>55</downloads>
	<expirationDate>Sat, 12 Dec 2026 15:42:20 -0500</expirationDate>
</packageInfo>

Example: JSON

To retrieve a JSON encoded version of the same data, we simply ask for a different format in the URL:

http://cache.pando.com/soapservices/SendToWeb?action=info&format=json
  &id=5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB
  &key=C51E9F2767B6747A9C9841AF7EEB9CC0E967D5B37CEC05B8C9DF310A03958AD2


Which returns the following result (with the "files" list trimmed -- full result here).

{"version":"1.0",
"packageId":"5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB",
"key":"C51E9F2767B6747A9C9841AF7EEB9CC0E967D5B37CEC05B8C9DF310A03958AD2",
"title":"Spring Street Art",
"description":"At 11 Spring St. some of NYC's best street artists have canvassed
  (literally) the building with art that is sprayed/painted/glued on
  the exterior and interior walls.",
"creationDate":"Sun, 17 Dec 2006 14:06:30 -0500",
"packager":"Yaron Samid",
"thumbnailURL":"http://services.pando.com/soapservices/SendToWeb?action=thumbnail
  &id=5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB",
"packageURL":"http://cache.pando.com/soapservices/Package/package.pando
  ?id=5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB
  &key=C51E9F2767B6747A9C9841AF7EEB9CC0E967D5B37CEC05B8C9DF310A03958AD2",
"packageSize":187249946,
"fileCount":91,
"files":[
  {"name":"Spring Street Art/IMG_8277.jpg","size":2196499},
  [... trimmed ...],
  {"name":"Spring Street Art/IMG_8367.jpg","size":2071726}],
"downloads":55,
"expirationDate":"Sat, 12 Dec 2026 15:42:20 -0500"}	

The thumbnail image of a package can be accessed by retrieving it from the Package Thumbnail URL.

Anatomy of a Package Thumbnail URL

Like Package URLs, the Package Thumbnail URL is a specially structured URL, containing the Package ID:

http://cache.pando.com/soapservices/SendToWeb?action=thumbnail&id=PackageId


Example: image tag

If you know the Package ID, you can automatically generate an image tag. For example:

<img alt="Spring Street Art" title="Download Spring Street art with Pando"
   src="http://cache.pando.com/soapservices/SendToWeb?action=thumbnail
   &id=5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB">

Which looks like:

Example: image link

Using both the Package Thumbnail URL and the Package URL, could wrap the image in a link to the package itself, like this:

<a href="http://cache.pando.com/soapservices/package.pando?
   id=5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB
   &key=C51E9F2767B6747A9C9841AF7EEB9CC0E967D5B37CEC05B8C9DF310A03958AD2">
   <img alt="Spring Street Art" title="Download Spring Street art with Pando" 
      src="http://cache.pando.com/soapservices/SendToWeb?action=thumbnail
        &id=5AEDE982393976A10050F2EC7C20C3C5EFDE0BBB"/>
</a>

Which looks like:

How Pando Generates Thumbnails

For learn more about how Pando creates thumbnails, see Publish Pretty Pando Packages.

Every Pando package has a unique Package URL. The file at the URL is the Pando file for the package.

The pando:send URL tells Pando to open a Send window. If provided, it will auto-fill the email address and local files so that the user can review the information and send it. It can be used by either web sites or applications.

pando:send?email_address=submissions@videosite.com&files_to_send=c:\Cover.JPG,c:\Video.avi

Both email_address and files_to_send are optional. If they are not provided, they are left blank for the user to fill in. This provides you with the flexibility for many uses:

• Send a set of files using Pando, with the user entering the recipient email address
• Have the user pick a file or collection of files to send to you
• You provide the files and the recipient address, and the user approves packaging and uploading

The pando:send URL's can be used from either a web site or an application.

Example: Web Site

For example, a web site may want users to send video files to the site using Pando. It could do so by giving a single 'submissions' email address, like this:

pando:send?email_address=submissions@videosite.com

This would open Pando's Send New window, pre-filled to send a package to submissions@videosite.com. The user would simply add the video, and click send. This is much simpler for users than launching Pando, clicking "Send Now", and copying and pasting the email address.

Sample HTML

To provide a link on a web page to allow people to send using Pando, here is a sample HTML:

<a href="pando:send?email_address=submissions@videosite.example.com"><img src="http://www.pando.com/sites/developers.pando.com/files/Pando-Me-Button.png"></a>

This looks like:

We recommend that web sites use the above graphic, so that Pando users will be able to tell that you support Pando more easily.

Example: Web Site with Uploader Accounts

The web site could choose to generate a unique email address for each sender to use, and to implement an automated email processing facility. This is a technique commonly used on photo hosting web sites to allow people to send photo's securely from camera-phones (so that other people can't post photos to your web site). Similarly, this technique would allow people to use Pando to send files into their personal web sites. In this case, the URL would be similar to the above, but with a unique user ID, like this:

pando:send?email_address=12345678@submissions.videosite.com

If you are interested in integrating Pando deliveries into your workflow, you should contact us to discuss the Pando Server Integration Toolkit.

Example: Application

An application that is used to create or organize rich media files (such as a photo organizer, a video editor, etc.) may want to make it easy for users to send the result of their work using Pando. This can be done by adding a button to the application to "Send using Pando" that opens a pando:send URL. This will cause Pando to launch (if it is not already running), and to prepare the sending.

For example, if a video editing application added a "send using Pando" command to its GUI, it could attach the files to Pando by opening an URL like:

pando:send?files_to_send=c:\Cover.JPG,c:\Video.avi

This would bring up a Send New window in Pando, with the cover art and video file pre-attached, so the user could enter the recipient's email address, name the package, and send it.

We recommend using this button: for sending using Pando, so that Pando users can easily recognize that your application supports Pando.

Sample Windows C++ Code

The following is an example of how a Windows application can open a URL. The application should construct the URL as defined above, and then execute the following with the desired URL replacing the italicized example URL:

ShellExecute(m_hWnd, NULL, "pando:send?files_to_send=c:\Cover.JPG,c:\Video.avi", NULL, NULL, SW_SHOWDEFAULT);

If the application wants to use Pando to package and upload the files, but manage the delivery of the Pando Package URL itself, it can do so using the Pando Client Automation Toolkit.

Supported Versions

pando:send links are supported in Pando version 1.4 and newer, Mac OS X and Windows. The files_to_send parameter may work on Mac 1.4, but the email_address parameter does not work in the current Mac version. This will be addressed in a future version of Pando.

Pando provides two mechanisms for web sites and applications to trigger downloading Pando packages. The first is to link to a Pando Package URL, and the second is to open a pando:download URL.

Open Pando Package URL

The easiest way to provide links triggering Pando downloads is to simply open the Pando Package URL.

This method will first check whether the user has Pando installed.

If Pando is installed, the download will automatically start.

If Pando is not installed, the web browser will display a web page that will inform the user that they need to install Pando and help them with the process. Once installation is complete, the download of the desired package will automatically start.

Examples

The link can be presented as a simple HTML link. For example:

<a href="http://cache.pando.com/soapservices/Package/package.pando?
id=5A4A7B2AE83E0AA3DAF066C28703C6F3132B0633
&key=3557F2AAD6CEAEC0FB6B1F1E19C7531A116A1C2B209554FC9343F2A6ED9DAC94">
CNN: In Case you Missed It for February 12, 2007</a>.

This looks like: CNN: In Case you Missed It for February 12, 2007.

If you like, you can use this download button:

CNN: In Case you Missed It for February 12, 2007<br />
<a href="http://cache.pando.com/soapservices/Package/package.pando?
id=5A4A7B2AE83E0AA3DAF066C28703C6F3132B0633
&key=3557F2AAD6CEAEC0FB6B1F1E19C7531A116A1C2B209554FC9343F2A6ED9DAC94">
<img src="http://rss.pando.com/themes/rssvideo/pando_dl_button2.png">
</a>.

This looks like:
CNN: In Case you Missed It for February 12, 2007

The links can be used in RSS enclosures, so that Pando can subscribe to the RSS feed as a Channel.

Pando's technology can be integrated into your server applications and workflow, providing all of the capabilities of the Pando platform. To learn more about the tools and services we offer to integrate with your applications contact us at http://www.pandonetworks.com/contact.