PowerShell
Facebook Download all Photos to Local Files

Demonstrates how to download all of one's Facebook photos to a local filesystem directory. This sample code keeps a local cache to avoid re-downloading the same photos twice. The program can be run again after a time, and it will download only photos that haven't yet been downloaded.
Chilkat PowerShell Downloads

Download Chilkat for PowerShell
PowerShell
Add-Type -Path "C:\chilkat\ChilkatDotNet47-x64\ChilkatDotNet47.dll"

$success = $false

# This example requires the Chilkat API to have been previously unlocked.
# See Global Unlock Sample for sample code.

# This example will use a local disk cache to avoid re-fetching the same
# photo id after it's been fetched once.
$fbCache = New-Object Chilkat.Cache
# The cache will use 1 level of 256 sub-directories.
$fbCache.Level = 1
# Use a directory path that makes sense on your operating system..
$fbCache.AddRoot("C:/fbCache")

# This example assumes a previously obtained an access token
$oauth2 = New-Object Chilkat.OAuth2
$oauth2.AccessToken = "FACEBOOK-ACCESS-TOKEN"

$rest = New-Object Chilkat.Rest

# Connect to Facebook.
$success = $rest.Connect("graph.facebook.com",443,$true,$true)
if ($success -ne $true) {
    $($rest.LastErrorText)
    exit
}

# Provide the authentication credentials (i.e. the access key)
$rest.SetAuthOAuth2($oauth2)

# There are two choices:  
# We can choose to download the photos the person is tagged in or has uploaded
# by setting type to "tagged" or "uploaded".
$rest.AddQueryParam("type","uploaded")

# To download all photos, we begin with an outer loop that iterates over
# the list of photo nodes in pages.  Each page returned contains a list of 
# photo node ids.  Each photo node id must be retrieved to get the download URL(s)
# of the actual image.

# I don't know the max limit for the number of records that can be downloaded at once.
$rest.AddQueryParam("limit","100")

# Get the 1st page of photos ids.
# See https://developers.facebook.com/docs/graph-api/reference/user/photos/ for more information.
$responseJson = $rest.FullRequestNoBody("GET","/v2.7/me/photos")
if ($rest.LastMethodSuccess -ne $true) {
    $($rest.LastErrorText)
    exit
}

$photoJson = New-Object Chilkat.JsonObject
$saPhotoUrls = New-Object Chilkat.StringArray
$sbPhotoIdPath = New-Object Chilkat.StringBuilder

$json = New-Object Chilkat.JsonObject
$json.EmitCompact = $false
$json.Load($responseJson)

# Get the "after" cursor.
$afterCursor = $json.StringOf("paging.cursors.after")
while ($json.LastMethodSuccess -eq $true) {

    $("-------------------")
    $("afterCursor = " + $afterCursor)

    # For each photo id in this page...
    $i = 0
    $numItems = $json.SizeOfArray("data")
    while ($i -lt $numItems) {
        $json.I = $i
        $photoId = $json.StringOf("data[i].id")
        $("photoId = " + $photoId)

        # We need to fetch the JSON for this photo.  Check to see if it's in the local disk cache,
        # and if not, then get it from Facebook.
        $photoJsonStr = $fbCache.FetchText($photoId)
        if ($fbCache.LastMethodSuccess -eq $false) {
            # It's not locally available, so get it from Facebook..
            $sbPhotoIdPath.Clear()
            $sbPhotoIdPath.Append("/v2.7/")
            $sbPhotoIdPath.Append($photoId)

            $rest.ClearAllQueryParams()
            $rest.AddQueryParam("fields","id,album,images")

            $("Fetching photo node from Facebook...")

            # This REST request will continue using the existing connection.
            # If the connection was closed, it will automatically reconnect to send the request.
            $photoJsonStr = $rest.FullRequestNoBody("GET",$sbPhotoIdPath.GetAsString())
            if ($rest.LastMethodSuccess -ne $true) {
                $($rest.LastErrorText)
                exit
            }

            # Add the photo JSON to the local cache.
            $fbCache.SaveTextNoExpire($photoId,"",$photoJsonStr)
        }

        # Parse the photo JSON and add the main photo download URL to saPhotoUrls
        # There may be multiple URLs in the images array, but the 1st one is the largest and main photo URL.
        # The others are smaller sizes of the same photo.
        $photoJson.Load($photoJsonStr)
        $imageUrl = $photoJson.StringOf("images[0].source")
        if ($photoJson.LastMethodSuccess -eq $true) {

            # Actually, we'll add a small JSON document that contains both the image ID and the URL.
            $imgUrlJson = New-Object Chilkat.JsonObject
            $imgUrlJson.AppendString("id",$photoId)
            $imgUrlJson.AppendString("url",$imageUrl)
            $saPhotoUrls.Append($imgUrlJson.Emit())
            $("imageUrl = " + $imageUrl)
        }

        $i = $i + 1
    }

    # Prepare for getting the next page of photos ids.
    # We can continue using the same REST object.
    # If already connected, we'll continue using the existing connection.
    # Otherwise, a new connection will automatically be made if needed.
    $rest.ClearAllQueryParams()
    $rest.AddQueryParam("type","uploaded")
    $rest.AddQueryParam("limit","20")
    $rest.AddQueryParam("after",$afterCursor)

    # Get the next page of photo ids.
    $responseJson = $rest.FullRequestNoBody("GET","/v2.7/me/photos")
    if ($rest.LastMethodSuccess -ne $true) {
        $($rest.LastErrorText)
        exit
    }

    $json.Load($responseJson)
    $afterCursor = $json.StringOf("paging.cursors.after")
}

$("No more pages of photos.")

# Now iterate over the photo URLs and download each to a file.
# We can use Chilkat HTTP.  No Facebook authorization (access token) is required to download
# the photo once the URL is known.  
$http = New-Object Chilkat.Http

# We'll cache the image data so that if run again, we don't re-download the same image again.
$numUrls = $saPhotoUrls.Count
$i = 0
$urlJson = New-Object Chilkat.JsonObject

$fac = New-Object Chilkat.FileAccess

while ($i -lt $numUrls) {
    $urlJson.Load($saPhotoUrls.GetString($i))
    $photoId = $urlJson.StringOf("id")
    $imageUrl = $urlJson.StringOf("url")

    # Check the local cache for the image data.
    # Only download and save if not already cached.
    $imageBytes = $fbCache.FetchFromCache($imageUrl)
    if ($fbCache.LastMethodSuccess -eq $false) {
        #  This photo needs to be downloaded.

        $sbImageUrl = New-Object Chilkat.StringBuilder
        $sbImageUrl.Append($imageUrl)

        # Let's form a filename..
        $extension = ".jpg"
        if ($sbImageUrl.Contains(".gif",$false) -eq $true) {
            $extension = ".gif"
        }

        if ($sbImageUrl.Contains(".png",$false) -eq $true) {
            $extension = ".png"
        }

        if ($sbImageUrl.Contains(".tiff",$false) -eq $true) {
            $extension = ".tiff"
        }

        if ($sbImageUrl.Contains(".bmp",$false) -eq $true) {
            $extension = ".bmp"
        }

        $sbLocalFilePath = New-Object Chilkat.StringBuilder
        $sbLocalFilePath.Append("C:/Photos/facebook/uploaded/")
        $sbLocalFilePath.Append($photoId)
        $sbLocalFilePath.Append($extension)

        $imageBytes = $http.QuickGet($imageUrl)
        if ($http.LastMethodSuccess -ne $true) {
            $($http.LastErrorText)
            exit
        }

        # We've downloaded the photo image bytes into memory.
        # Save it to the cache AND save it to the output file.
        $fbCache.SaveToCacheNoExpire($imageUrl,"",$imageBytes)
        $fac.WriteEntireFile($sbLocalFilePath.GetAsString(),$imageBytes)

        $("Downloaded to " + $sbLocalFilePath.GetAsString())
    }

    $i = $i + 1
}

$("Finished downloading all Facebook photos!")