I've been using TwitPic since 2008 and have uploaded 1,200 images there.

There's no official export function for TwitPic. The services which used to exist relied on their RSS feeds - which have since been killed off.

This little Python script uses some undocumented APIs to grab all your images, save them in a directory, and make sure they have the correct timestamp.

Firstly, the documented bit. It's possible to make an unauthenticated API call to get the most recent 20 images any user has uploaded.

https://api.twitpic.com/2/users/show.json?username=edent&page=1

Obviously, use your own username in place of mine!

You can increment the page number, to get each page. Using the "photo_count" property, you should be able to work out how many pages you will need to request in order to grab all the photos. Remember to round up to the nearest integer.

Next, we have the undocumented API call. It's possible to request the thumbnail of an image with a simple API call:

https://twitpic.com/show/thumb/d834ni

To grab the full image, simply change "thumb" to "full":

http://twitpic.com/show/full/d834ni

Deficiencies

Sadly, the TwitPic images don't retain their original EXIF metadata - so there's no way of seeing where the photo was take, what camera was used, etc.

In fact, original images are not preserved at all. None seem to be larger than 800*600 - even though the API "helpfully" tells you what their original full resolution was.

My code is a quick sketch in Python. It could be made to run in parallel as it takes quite a while to download all the images - even though the total file size was only 100MB.

It has only been tested on Linux, so some things may need to change if you're on another OS. Specifically, this code strips out "/" from the file name - other computers may need other special characters replaced.

My code also assumes you have 100 pages or fewer of pictures to download.

On the plus side, it does make sure that the file names won't be too long for your file system and that any HTML entities are correctly decoded.

Enjoy!

Code

import urllib
import urllib2
import json
import collections
import HTMLParser
import time
import os

#   Create a parser for HTML entities
h = HTMLParser.HTMLParser()

#   Maximum filename length
#   Last 4 characters will be .jpg or .png etc
max_length = os.statvfs('.').f_namemax - 4

#   Target Page
twitpic_api = "https://api.twitpic.com/2/users/show.json?username=YOURNAMEHERE&page="

#   Get the data about the target page
for page in range(0, 100):
    print page
    twitpic_data = json.load(urllib2.urlopen(twitpic_api + str(page)))

    #   Get the info about each image on the page
    twitpic_images = twitpic_data["images"]

    for item in twitpic_images:
        twitpic_id = item['short_id']
        twitpic_title = item["message"]
        #   Replace / (which can't be used in a file name) with a similar looking character
        twitpic_title = twitpic_title.replace('/', u'u2044')
        twitpic_title = twitpic_title[:max_length]
        twitpic_file_type = item["type"]
        twitpic_time = time.mktime(time.strptime(item["timestamp"], "%Y-%m-%d %H:%M:%S"))
        twitpic_file_url = "https://twitpic.com/show/full/"+twitpic_id
        twitpic_file_name = h.unescape(twitpic_title) + "." + twitpic_file_type

        #   Save the file
        urllib.urlretrieve (twitpic_file_url, twitpic_file_name)
        #   Set the file time
        os.utime(twitpic_file_name,(twitpic_time, twitpic_time))

You can see the full code on Dabr's Google Code page.

First of all, you'll need to have enabled OAuth for your Twitter client. I use Abraham's excellent OAuth libraries for PHP.

This tutorial assumes you already have OAuth working. I'll attempt to explain what I'm doing as I go along - but the code should be pretty readable.

Start by reading the Twitpic API documentation. You will also need to register for an API key - this only takes a few seconds.

We start by setting CURL's headers to those required by Twitpic

//Has the user submitted an image and message?
if ($_POST['message'])
{
    $twitpicURL = 'http://api.twitpic.com/2/upload.json';

    //Set the initial headers
    $header = array(
                            'X-Auth-Service-Provider: https://api.twitter.com/1/account/verify_credentials.json',
                            'X-Verify-Credentials-Authorization: OAuth realm="http://api.twitter.com/"'
                        );

Next, we create the OAuth credentials that we need. Essentially, we're signing a URL request. We then pass that on to Twitpic and they verify it with Twitter. We never pass our OAUTH_CONSUMER_SECRET - so Twitpic can't impersonate us.

    //Using Abraham's OAuth library
    require_once('OAuth.php');

    // instantiating OAuth customer
    $consumer = new OAuthConsumer(OAUTH_CONSUMER_KEY, OAUTH_CONSUMER_SECRET);

    // instantiating signer
    $sha1_method = new OAuthSignatureMethod_HMAC_SHA1();

    // user's token
    list($oauth_token, $oauth_token_secret) = explode('|', $GLOBALS['user']['password']);
    $token = new OAuthConsumer($oauth_token, $oauth_token_secret);

    // Generate all the OAuth parameters needed
    $signingURL = 'https://api.twitter.com/1/account/verify_credentials.json';

    $request = OAuthRequest::from_consumer_and_token($consumer, $token, 'GET', $signingURL, array());

    $request->sign_request($sha1_method, $consumer, $token);

We add these generated credentials into the header.

    $header[1] .= ", oauth_consumer_key=\"" . $request->get_parameter('oauth_consumer_key') ."\"";
    $header[1] .= ", oauth_signature_method=\"" . $request->get_parameter('oauth_signature_method') ."\"";
    $header[1] .= ", oauth_token=\"" . $request->get_parameter('oauth_token') ."\"";
    $header[1] .= ", oauth_timestamp=\"" . $request->get_parameter('oauth_timestamp') ."\"";
    $header[1] .= ", oauth_nonce=\"" . $request->get_parameter('oauth_nonce') ."\"";
    $header[1] .= ", oauth_version=\"" . $request->get_parameter('oauth_version') ."\"";
    $header[1] .= ", oauth_signature=\"" . urlencode($request->get_parameter('oauth_signature')) ."\"";

Add everything into CURL

    //open connection
    $ch = curl_init();

    //Set paramaters
    curl_setopt($ch, CURLOPT_HTTPHEADER, $header);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, TRUE);
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, 0);

    //set the url, number of POST vars, POST data
    curl_setopt($ch,CURLOPT_URL,$twitpicURL);

The data we send to Twitpic (message text, image and key) have to go via POST.

    //TwitPic requires the data to be sent as POST
    $media_data = array(
                            'media' => '@'.$_FILES['media']['tmp_name'],
                          'message' => ' ' . stripslashes($_POST['message']), //A space is needed because twitpic b0rks if first char is an @
                          'key'=>TWITPIC_API_KEY
                        );

    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch,CURLOPT_POSTFIELDS,$media_data);

All done, we now send the data to Twitpic.

    //execute post
    $result = curl_exec($ch);
    $response_info=curl_getinfo($ch);

    //close connection
    curl_close($ch);

If this has worked, Twitpic will pass back the URL of the image we posted. We then need to post the entire message to Twitter ourselves (Twitpic can't do it for us).

    if ($response_info['http_code'] == 200) //Success
    {
        //Decode the response
        $json = json_decode($result);
        $id = $json->id;
        $twitpicURL = $json->url;
        $text = $json->text;
        $message = trim($text) . " " . $twitpicURL;

This next part is specific to Dabr - your client may post things differently.

        //Send the user's message to twitter
        $request = API_URL.'statuses/update.json';

        $post_data = array('source' => 'dabr', 'status' => $message);
        $status = twitter_process($request, $post_data);

        //Back to the timeline
        twitter_refresh("twitpic/confirm/$id");
    }

If it didn't work, Twitpic will tell us why.

    else
    {
        $content = "<p>Twitpic upload failed. No idea why!</p>";
        $json = json_decode($result);
        $content .= "<br /><b>message</b> " . urlencode($_POST['message']);
        $content .= "<br /><b>json</b> " . print_r($json);
        $content .= "<br /><b>Response</b> " . print_r($response_info);
        $content .= "<br /><b>header</b> " . print_r($header);
        $content .= "<br /><b>media_data</b> " . print_r($media_data);
        $content .= "<br /><b>URL was</b> " . $twitpicURL;
        $content .= "<br /><b>File uploaded was</b> " . $_FILES['media']['tmp_name'];
    }
}

The easy bit.

It's easy to post the data to Twitpic

$media_data = array(
    'media' => '@'.$_FILES['media']['tmp_name'],
    'message' => html_entity_decode($_POST['message']),
    'key'=>'123465789132465'
);
curl_setopt($ch,CURLOPT_POSTFIELDS,$media_data);

OAuth Credentials

Using Abrahams OAuth library for PHP, it's easy to get the required OAuth data.

require_once('OAuth.php');
// instantiating OAuth customer
$consumer = new OAuthConsumer(OAUTH_CONSUMER_KEY, OAUTH_CONSUMER_SECRET);
// instantiating signer
$sha1_method = new OAuthSignatureMethod_HMAC_SHA1();
// user's token
list($oauth_token, $oauth_token_secret) = explode('|', $GLOBALS['user']['password']);
$token = new OAuthConsumer($oauth_token, $oauth_token_secret);

// signing URL
$fakeurl = 'https://twitter.com/account/verify_credentials.xml';
$request = OAuthRequest::from_consumer_and_token($consumer, $token, 'GET', $fakeurl, array());
$request->sign_request($sha1_method, $consumer, $token);
$OAuthurl = $request->to_url();

The Tricky Bit

I'm following the header example in the API documentation. Passing these variable to Twitpic is where I seem to go wrong.

$header = array(
      'X-Auth-Service-Provider: https://api.twitter.com/1/account/verify_credentials.json',
      'X-Verify-Credentials-Authorization: OAuth realm="http://api.twitter.com/"'
   );

I then modify the second header so it reads

"X-Verify-Credentials-Authorization: OAuth realm="http://api.twitter.com/",
oauth_consumer_key="aaaaaaa",
oauth_nonce="bbbbbbbbbbb",
oauth_signature="ccccccccccccc%3D",
oauth_signature_method="HMAC-SHA1",
oauth_timestamp="123456798",
oauth_token="15948715-dddddddddd",
oauth_version="1.0""

The Error

401 "Could not authenticate you (header rejected by twitter)."

GAH!