Migrate Dropbox Files to Nextcloud (Self-hosted Cloud)

Hey team, Darian here. I want to talk about a workflow that personally saved me a lot of hassle. For a while, I was using a personal Dropbox for quick file drops and our self-hosted Nextcloud for more permanent, structured storage. The context-switching was inefficient, and I once spent 30 frantic minutes looking for a client asset that was in Dropbox when I swore it was in Nextcloud. That’s when I decided to automate it. This script automatically syncs files from a specific Dropbox folder to our Nextcloud instance, giving us a single source of truth without manual drag-and-drop. It’s a “set it and forget it” solution.

Prerequisites

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

• A self-hosted Nextcloud instance with administrator access.
• A Dropbox account and access to its Developer App Console.
• Python 3.8+ installed on a server or machine that can run scheduled tasks.
• Familiarity with creating Python virtual environments and installing packages.

The Guide: From Dropbox to Nextcloud, Step-by-Step

Step 1: Get Your Dropbox API Token

First, we need to give our script permission to read files from your Dropbox account. We do this by creating a dedicated “app”.

1. Navigate to the Dropbox App Console and choose “Create app”.
2. Select “Scoped Access” and choose the permissions you need. For this, we only need to read files, so select “App folder” access to limit the script’s scope.
3. Give your app a unique name (e.g., “Nextcloud-Sync-Bot”).
4. Once created, go to the “Permissions” tab. You’ll need to grant it files.metadata.read and files.content.read.
5. Finally, go to the “Settings” tab. Under “Generated access token”, click “Generate” and copy the token. This is your key to the Dropbox API. Keep it safe.

Pro Tip: Dropbox access tokens generated this way are long-lived by default, which is fine for a trusted server-side script. For higher security environments, you’d implement an OAuth2 flow with refresh tokens, but that’s a bit of overkill for a personal or internal migration tool.

Step 2: Create a Nextcloud App Password

Just like with Dropbox, we don’t want to use our main password in a script. Nextcloud’s “App Passwords” are the way to go.

1. Log into your Nextcloud instance.
2. Click your profile icon in the top-right and go to Settings.
3. In the left navigation, select Security.
4. Scroll down to “Devices & sessions” and under “Create new app password”, give it a name like “Dropbox-Migrator” and click “Create new app password”.
5. Nextcloud will show you a username (your actual username) and a long, generated password. Copy this password immediately; you won’t see it again.

Step 3: The Python Sync Script

Alright, let’s get to the core logic. First, set up a dedicated directory for our project. Inside, you’ll want to create a Python virtual environment. I’ll skip the standard virtualenv setup since you likely have your own workflow for that. Just make sure you install the necessary libraries into your environment using pip: dropbox, requests, and python-dotenv.

Create a file named sync_script.py. The script will perform a few key actions: list files in a target Dropbox folder, download each one’s content into memory, and then upload it to a corresponding path in Nextcloud via its WebDAV API.

import os
import dropbox
import requests
from dotenv import load_dotenv

def migrate_files():
    # Load environment variables from config.env
    load_dotenv('config.env')

    # --- Dropbox Credentials & Config ---
    DROPBOX_TOKEN = os.getenv('DROPBOX_ACCESS_TOKEN')
    DROPBOX_FOLDER_PATH = '/Apps/Nextcloud-Sync-Bot' # Or whatever you named your app folder

    # --- Nextcloud Credentials & Config ---
    NEXTCLOUD_URL = os.getenv('NEXTCLOUD_URL') # e.g., 'https://cloud.yourdomain.com'
    NEXTCLOUD_USER = os.getenv('NEXTCLOUD_USERNAME')
    NEXTCLOUD_APP_PASSWORD = os.getenv('NEXTCLOUD_APP_PASSWORD')
    NEXTCLOUD_TARGET_FOLDER = 'Dropbox-Imports' # A folder in your Nextcloud root

    # Basic validation
    if not all([DROPBOX_TOKEN, NEXTCLOUD_URL, NEXTCLOUD_USER, NEXTCLOUD_APP_PASSWORD]):
        print("Error: Missing one or more environment variables.")
        return

    # Initialize Dropbox client
    try:
        dbx = dropbox.Dropbox(DROPBOX_TOKEN)
        dbx.users_get_current_account()
        print("Successfully connected to Dropbox.")
    except Exception as e:
        print(f"Error connecting to Dropbox: {e}")
        return

    # Define Nextcloud WebDAV endpoint
    webdav_base_url = f"{NEXTCLOUD_URL}/remote.php/dav/files/{NEXTCLOUD_USER}"

    try:
        # Recursively list files in the Dropbox folder
        result = dbx.files_list_folder(DROPBOX_FOLDER_PATH, recursive=True)
        files_to_migrate = [entry for entry in result.entries if isinstance(entry, dropbox.files.FileMetadata)]

        if not files_to_migrate:
            print("No files found in the specified Dropbox folder to migrate.")
            return

        print(f"Found {len(files_to_migrate)} files to migrate.")

        for file_metadata in files_to_migrate:
            dropbox_file_path = file_metadata.path_display
            print(f"Processing: {dropbox_file_path}")

            # Download file content from Dropbox
            try:
                metadata, res = dbx.files_download(path=dropbox_file_path)
                file_content = res.content
            except dropbox.exceptions.HttpError as err:
                print(f"*** Dropbox download error for {dropbox_file_path}: {err}")
                continue

            # Construct Nextcloud upload path
            # We strip the base Dropbox path to get the relative path
            relative_path = os.path.relpath(dropbox_file_path, DROPBOX_FOLDER_PATH)
            nextcloud_upload_path = f"{webdav_base_url}/{NEXTCLOUD_TARGET_FOLDER}/{relative_path}"

            # Upload to Nextcloud using WebDAV (PUT request)
            response = requests.put(
                nextcloud_upload_path,
                data=file_content,
                auth=(NEXTCLOUD_USER, NEXTCLOUD_APP_PASSWORD),
                headers={'Content-Type': 'application/octet-stream'}
            )

            if response.status_code in [201, 204]: # 201 = Created, 204 = No Content (Overwrite)
                print(f"  -> Successfully uploaded to Nextcloud.")
            else:
                print(f"  -> Failed to upload to Nextcloud. Status: {response.status_code}, Response: {response.text}")

    except Exception as e:
        print(f"An unexpected error occurred during migration: {e}")

if __name__ == "__main__":
    migrate_files()

Step 4: Configure Your Environment

Create a file named config.env in the same directory as your script. Storing credentials here keeps them out of your code, which is a critical best practice.

# Dropbox Configuration
DROPBOX_ACCESS_TOKEN="YOUR_DROPBOX_GENERATED_TOKEN_HERE"

# Nextcloud Configuration
NEXTCLOUD_URL="https://cloud.yourdomain.com"
NEXTCLOUD_USERNAME="your_nextcloud_username"
NEXTCLOUD_APP_PASSWORD="your-nextcloud-app-password-here"

Fill this in with the credentials you gathered in Steps 1 and 2.

Step 5: Automate with Cron

To make this a true “set it and forget it” solution, we can schedule it to run automatically. On a Linux server, a cron job is perfect for this. I usually set mine to run late at night.

You’ll need to edit your crontab file. I won’t detail the command to open the editor, as it varies, but once you have it open, add a line like this to run the script every Monday at 2 AM:

0 2 * * 1 python3 script.py

Make sure this command is run from within your project’s directory, or provide the full path to `script.py`. The key is that it must be able to find both the script and the `config.env` file.

Common Pitfalls & Where I Mess Up

I’ve set this up a few times, and here are the places I’ve stumbled:

• Incorrect Nextcloud WebDAV URL: The URL is very specific. It must include `/remote.php/dav/files/YOUR_USERNAME`. I once forgot the username part and spent an hour debugging 404 errors.
• File Path Mismatches: The script assumes a clean mapping. If you have complex folder structures, pay close attention to the `os.path.relpath` logic. A leading or trailing slash can throw everything off.
• Large File Timeouts: The current script downloads the entire file into memory. For very large files (multiple GBs), this is not ideal. In my production setups for heavy-duty work, I’d modify this to use streaming downloads and chunked uploads to handle large files gracefully and avoid memory issues or request timeouts.

Conclusion

That’s the basic framework. You now have a reliable, automated pipeline to move files from Dropbox into your self-hosted Nextcloud instance. This not only centralizes your data but also reinforces your data ownership. From here, you could expand the script to delete files from Dropbox after a successful transfer or add more robust error logging. Hope this helps you reclaim some time and organize your digital life.

All the best,
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