Syncing Photos from Android to Google Photos via Script

Hey team, Darian here. Let’s talk about a quick win that saved me a surprising amount of time. We have a few Android devices in the field that capture daily status photos of our server racks. For months, I was manually connecting them via USB to pull the photos and upload them to a shared album. It was tedious, error-prone, and frankly, a waste of a good engineer’s time. I realized I was burning about two hours a week on this. That’s when I built this little Python script to automate the whole process. Now, the photos just appear in the right Google Photos album every night. It’s a simple automation, but these are the kinds of efficiencies that really add up.

This guide will walk you through setting up a similar workflow. It’s designed to be a fire-and-forget solution.

Prerequisites

Before we dive in, make sure you have the following ready to go:

• An Android device you want to sync from.
• A computer or server that can run a Python script and access the internet.
• A Google Cloud Platform (GCP) project.
• Python 3 installed on your machine.
• A method to get photos from your Android to your computer (I personally use Syncthing for a wireless, folder-to-folder sync, but a scheduled USB transfer works too).

The Step-by-Step Guide

Step 1: Configure the Google Cloud Project

First, we need to tell Google that our script is allowed to access the Photos API. This is the most crucial setup step.

1. Navigate to your GCP Console and select your project.
2. Go to “APIs & Services” > “Library” and search for “Google Photos Library API”. Enable it.
3. Next, head to “APIs & Services” > “Credentials”. Click “Create Credentials” and select “OAuth client ID”.
4. Choose “Desktop app” as the application type. Give it a name like “Android Sync Script”.
5. After creation, a modal will appear. Click the “Download JSON” button. Rename this file to credentials.json and place it in your project directory. This file is your key, so keep it secure.

Pro Tip: When setting up your OAuth consent screen, you only need to add the .../auth/photoslibrary.appendonly scope if your script will only be uploading photos. It’s always best practice to request the minimum permissions necessary. This scope prevents the script from reading or deleting existing photos.

Step 2: The Python Script Logic

Alright, let’s get to the code. I’ll skip the standard virtualenv setup and dependency installation commands since you likely have your own workflow for that. Just make sure you have the necessary Google API libraries for Python installed. The main ones you’ll need are google-api-python-client, google-auth-oauthlib, and google-auth-httplib2.

Our script will perform three main tasks:

1. Authenticate: Use the credentials.json file to get permission from Google. The first time you run this, it will open a browser window for you to log in and grant access. It then saves a token.json file so you don’t have to do this again.
2. Upload: Find all image files in a specified local directory, upload their raw bytes to Google, and receive an “upload token” for each one.
3. Create Media Items: Use the upload tokens to tell Google Photos to officially add these images to your library.

Here’s the complete script. I’ve added comments to explain each part.

import os
import pickle
import requests
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request
from googleapiclient.discovery import build

# --- Configuration ---
SCOPES = ['https://www.googleapis.com/auth/photoslibrary.appendonly']
API_SERVICE_NAME = 'photoslibrary'
API_VERSION = 'v1'
CLIENT_SECRETS_FILE = 'credentials.json'
TOKEN_FILE = 'token.json'
LOCAL_PHOTO_DIR = 'photos_to_upload' # The folder where Android syncs to

def get_credentials():
    """Handles user authentication and token management."""
    creds = None
    if os.path.exists(TOKEN_FILE):
        with open(TOKEN_FILE, 'rb') as token:
            creds = pickle.load(token)

    if not creds or not creds.valid:
        if creds and creds.expired and creds.refresh_token:
            creds.refresh(Request())
        else:
            flow = InstalledAppFlow.from_client_secrets_file(CLIENT_SECRETS_FILE, SCOPES)
            # The port=0 will find a free port automatically.
            creds = flow.run_local_server(port=0)
        
        with open(TOKEN_FILE, 'wb') as token:
            pickle.dump(creds, token)
    return creds

def upload_image(image_path, service):
    """Uploads a single image and returns an upload token."""
    # Step 1: Get the upload URL
    # In my production setups, I use a more robust session object.
    headers = {
        'Authorization': 'Bearer ' + service.credentials.token,
        'Content-type': 'application/octet-stream',
        'X-Goog-Upload-Content-Type': 'image/jpeg',
        'X-Goog-Upload-Protocol': 'raw',
    }
    
    try:
        with open(image_path, 'rb') as img_data:
            response = requests.post('https://photoslibrary.googleapis.com/v1/uploads', headers=headers, data=img_data)
            response.raise_for_status() # Raises an exception for bad status codes
            print(f"Successfully uploaded bytes for: {os.path.basename(image_path)}")
            return response.content.decode('utf-8')
    except requests.exceptions.RequestException as e:
        print(f"Error uploading bytes for {image_path}: {e}")
        return None


def main():
    """Main function to run the sync process."""
    print("Starting photo sync process...")
    
    # Ensure the photo directory exists
    if not os.path.isdir(LOCAL_PHOTO_DIR):
        print(f"Error: Source directory '{LOCAL_PHOTO_DIR}' not found.")
        return 1 # Indicate failure

    creds = get_credentials()
    service = build(API_SERVICE_NAME, API_VERSION, credentials=creds, static_discovery=False)
    
    image_files = [f for f in os.listdir(LOCAL_PHOTO_DIR) if f.lower().endswith(('.png', '.jpg', '.jpeg'))]
    if not image_files:
        print("No new images found to upload.")
        return 0 # Indicate success, nothing to do

    upload_tokens = []
    for filename in image_files:
        full_path = os.path.join(LOCAL_PHOTO_DIR, filename)
        upload_token = upload_image(full_path, service)
        if upload_token:
            upload_tokens.append({'simpleMediaItem': {'uploadToken': upload_token, 'fileName': filename}})

    if not upload_tokens:
        print("No files were successfully uploaded to generate tokens.")
        return 1

    # Step 2: Create media items from upload tokens
    # Note: The API supports batching up to 50 items at a time.
    try:
        request_body = {
            "newMediaItems": upload_tokens
        }
        response = service.mediaItems().batchCreate(body=request_body).execute()
        print(f"API Response: {response}")
        print(f"Successfully created {len(upload_tokens)} media items in Google Photos.")

        # --- Cleanup: Move uploaded files to an 'archive' folder ---
        archive_dir = os.path.join(LOCAL_PHOTO_DIR, 'archived')
        if not os.path.exists(archive_dir):
            # This is one of those setup steps I can't script for you
            # but you'll want to create this 'archived' directory.
            print(f"Please create the directory: {archive_dir}")

        for filename in image_files:
             os.rename(os.path.join(LOCAL_PHOTO_DIR, filename), os.path.join(archive_dir, filename))
        print("Moved uploaded files to the archive directory.")

    except Exception as e:
        print(f"An error occurred while creating media items: {e}")
        return 1

    print("Sync process completed successfully.")
    return 0 # Indicate success

if __name__ == '__main__':
    main()

Pro Tip: Notice the cleanup step at the end. After a successful upload, I move the file to an ‘archived’ subdirectory. This is critical for idempotency. It ensures that the next time the script runs, it doesn’t re-upload the same photos. Without this, you’ll have duplicates.

Step 3: Schedule the Script

The final piece is automation. You don’t want to run this manually. On a Linux system, a cron job is perfect for this. I have mine set to run at 2 AM every day when system load is low.

You can set up a cron job that looks something like this:

0 2 * * * python3 script.py

This simple line tells the system to execute our script every day at 2:00 AM. For Windows, Task Scheduler achieves the same result.

Common Pitfalls (Where I Usually Mess Up)

• First Run Authentication: Remember that the very first time you run this script, it will try to open a web browser for you to authorize the application. If you set this up on a headless server, run it once interactively from your own machine to generate the token.json, then copy both the script and the token file to the server.
• Token Expiration: The token.json can expire or be revoked. My script has a basic refresh logic, but in a robust production environment, I’d add more explicit error handling around authentication failures.
• API Quotas: The Google Photos API has usage limits. For personal use, you’ll likely never hit them. But if you’re uploading thousands of photos a day, you’ll need to check your GCP console for quota information and potentially implement backoff logic.
• File Paths: A classic mistake. Make sure the LOCAL_PHOTO_DIR variable points exactly to where your photos are being synced from your Android. Double-check for typos.

Conclusion

And that’s it. You’ve now offloaded a manual, repetitive task to a reliable script. This is the core of what we do in DevOps: find the friction points, automate them, and move on to the next challenge. This script has been running without a hitch for me for over a year, and it’s one less thing I have to think about. I hope it saves you as much time as it has saved me.

Cheers,
Darian Vance

Darian Vance

Lead Cloud Architect & DevOps Strategist

With over 12 years in system architecture and automation, Darian specializes in simplifying complex cloud infrastructures. An advocate for open-source solutions, he founded TechResolve to provide engineers with actionable, battle-tested troubleshooting guides and robust software alternatives.

🤖 Frequently Asked Questions