How to determine the Dropbox folder location programmatically?

Question

I have a script that is intended to be run by multiple users on multiple computers, and they don't all have their Dropbox folders in their respective home directories. I'd hate to have to hard code paths in the script. I'd much rather figure out the path programatically.

Any suggestions welcome.

EDIT: I am not using the Dropbox API in the script, the script simply reads files in a specific Dropbox folder shared between the users. The only thing I need is the path to the Dropbox folder, as I of course already know the relative path within the Dropbox file structure.

EDIT: If it matters, I am using Windows 7.

What is the script supposed to do? Are you using the [Dropbox API](https://www.dropbox.com/developers)? — Karl Knechtel, Aug 25 '12 at 00:21

score 16 · Accepted Answer · edited May 23 '17 at 12:26

I found the answer here. Setting s equal to the 2nd line in ~\AppData\Roaming\Dropbox\host.db and then decoding it with base64 gives the path.

def _get_appdata_path():
    import ctypes
    from ctypes import wintypes, windll
    CSIDL_APPDATA = 26
    _SHGetFolderPath = windll.shell32.SHGetFolderPathW
    _SHGetFolderPath.argtypes = [wintypes.HWND,
                                 ctypes.c_int,
                                 wintypes.HANDLE,
                                 wintypes.DWORD,
                                 wintypes.LPCWSTR]
    path_buf = wintypes.create_unicode_buffer(wintypes.MAX_PATH)
    result = _SHGetFolderPath(0, CSIDL_APPDATA, 0, 0, path_buf)
    return path_buf.value

def dropbox_home():
    from platform import system
    import base64
    import os.path
    _system = system()
    if _system in ('Windows', 'cli'):
        host_db_path = os.path.join(_get_appdata_path(),
                                    'Dropbox',
                                    'host.db')
    elif _system in ('Linux', 'Darwin'):
        host_db_path = os.path.expanduser('~'
                                          '/.dropbox'
                                          '/host.db')
    else:
        raise RuntimeError('Unknown system={}'
                           .format(_system))
    if not os.path.exists(host_db_path):
        raise RuntimeError("Config path={} doesn't exists"
                           .format(host_db_path))
    with open(host_db_path, 'r') as f:
        data = f.read().split()

    return base64.b64decode(data[1])

To find host.db on Windows: `host_db_path = os.path.join(winpaths.get_appdata(), 'Dropbox', 'host.db')` Instead of `winpaths` you could [use ctypes directly with `CSIDL_APPDATA`](http://stackoverflow.com/a/626927/4279). On Linux, OSX: `host_db_path = os.path.expanduser('~/.dropbox/host.db')` — jfs, Aug 25 '12 at 01:40
The line `raise RuntimeError("Config path={} doesn't exists".format(p))` gives `NameError: global name 'p' is not defined`. — Caltor, Oct 08 '13 at 14:19
I think it should be `raise RuntimeError("Config path={} doesn't exist".format(host_db_path))` — Caltor, Oct 08 '13 at 14:34
The dropbox host.db file doesn't exist anymore in latest versions.. Grr.. Looking for a new solution. — JackB, Apr 21 '16 at 12:42

score 13 · Answer 2 · edited May 02 '17 at 20:08

There is an answer to this on Dropbox Help Center - How can I programmatically find the Dropbox folder paths?

Short version:

Use ~/.dropbox/info.json or %APPDATA%\Dropbox\info.json

Long version:

Access the valid %APPDATA% or %LOCALAPPDATA% location this way:

import os
from pathlib import Path
import json

try:
    json_path = (Path(os.getenv('LOCALAPPDATA'))/'Dropbox'/'info.json').resolve()
except FileNotFoundError:
    json_path = (Path(os.getenv('APPDATA'))/'Dropbox'/'info.json').resolve()

with open(str(json_path)) as f:
    j = json.load(f)

personal_dbox_path = Path(j['personal']['path'])
business_dbox_path = Path(j['business']['path'])

score 1 · Answer 3 · answered Aug 25 '12 at 00:43

1

You could search the file system using os.walk. The Dropbox folder is probably within the home directory of the user, so to save some time you could limit your search to that. Example:

import os
dropbox_folder = None

for dirname, dirnames, filenames in os.walk(os.path.expanduser('~')):
    for subdirname in dirnames:
        if(subdirname == 'Dropbox'):
            dropbox_folder = os.path.join(dirname, subdirname)
            break
    if dropbox_folder:
        break

# dropbox_folder now contains the full path to the Dropbox folder, or
# None if the folder wasn't found

Alternatively you could prompt the user for the Dropbox folder location, or make it configurable via a config file.

answered Aug 25 '12 at 00:43

Hubro

56,214
69
228
381

I did actually implement this, but then I found out some users had put their Dropbox folders outside their home directory... – c00kiemonster Aug 25 '12 at 00:45
Then simply search the entire filesystem instead. It will only search until it finds a folder called Dropbox. I still think the best solution would be to prompt the user though. – Hubro Aug 25 '12 at 00:47
This will find the user's Dropbox application folder, but that's not necessarily the locate where Dropbox actually stores the user's data files (there's default but it's user definable). That information is stored in a `host.db` file located within that directory. – martineau Jul 13 '13 at 23:42

score 1 · Answer 4 · edited May 23 '17 at 12:34

1

This adaptation based on J.F. Sebastian's suggestion works for me on Ubuntu:

os.path.expanduser('~/Dropbox')

And to actually set the working directory to be there:

os.chdir(os.path.expanduser('~/Dropbox'))

edited May 23 '17 at 12:34

Community

1
1

answered Sep 25 '14 at 00:17

zkurtz

3,230
7
28
64

only if the dropbox is actually installed there. – skjerns Jan 24 '20 at 17:42

score 1 · Answer 5 · edited Mar 16 '16 at 01:34

1

Note: answer is valid for Dropbox v2.8 and higher

Windows

jq -r ".personal.path" < %APPDATA%\Dropbox\info.json

This needs jq - JSON parser utility to be installed. If you are happy user of Chocolatey package manager, just run choco install jq before.

Linux

jq -r ".personal.path" < ~/.dropbox/info.json

Just similarly to Windows install jq using package manager of your distro.

edited Mar 16 '16 at 01:34

Zizouz212

4,908
5
42
66

answered Mar 16 '16 at 00:31

maoizm

682
13
17

Nick DeRobertis · Answer 6 · 2017-02-11T16:30:18.473

Note: requires Dropbox >= 2.8

Dropbox now stores the paths in json format in a file called info.json. It is located in one of the two following locations:

%APPDATA%\Dropbox\info.json
%LOCALAPPDATA%\Dropbox\info.json

I can access the %APPDATA% environment variable in Python by os.environ['APPDATA'], however I check both that and os.environ['LOCALAPPDATA']. Then I convert the JSON into a dictionary and read the 'path' value under the appropriate Dropbox (business or personal).

Calling get_dropbox_location() from the code below will return the filepath of the business Dropbox, while get_dropbox_location('personal') will return the file path of the personal Dropbox.

import os
import json

def get_dropbox_location(account_type='business'):
    """
    Returns a string of the filepath of the Dropbox for this user

    :param account_type: str, 'business' or 'personal'
    """
    info_path = _get_dropbox_info_path()
    info_dict = _get_dictionary_from_path_to_json(info_path)
    return _get_dropbox_path_from_dictionary(info_dict, account_type)

def _get_dropbox_info_path():
    """
    Returns filepath of Dropbox file info.json
    """
    path = _create_dropox_info_path('APPDATA')
    if path:
        return path
    return _create_dropox_info_path('LOCALAPPDATA')

def _create_dropox_info_path(appdata_str):
    r"""
    Looks up the environment variable given by appdata_str and combines with \Dropbox\info.json

    Then checks if the info.json exists at that path, and if so returns the filepath, otherwise
    returns False
    """
    path = os.path.join(os.environ[appdata_str], r'Dropbox\info.json')
    if os.path.exists(path):
        return path
    return False

def _get_dictionary_from_path_to_json(info_path):
    """
    Loads a json file and returns as a dictionary
    """
    with open(info_path, 'r') as f:
        text = f.read()

    return json.loads(text)

def _get_dropbox_path_from_dictionary(info_dict, account_type):
    """
    Returns the 'path' value under the account_type dictionary within the main dictionary
    """
    return info_dict[account_type]['path']

This is a pure Python solution, unlike the other solution using info.json.

score 0 · Answer 7 · answered Aug 25 '12 at 00:45

One option is you could go searching for the .dropbox.cache directory which (at least on Mac and Linux) is a hidden folder in the Dropbox directory.

I am fairly certain that Dropbox stores its preferences in an encrypted .dbx container, so extracting it using the same method that Dropbox uses is not trivial.

score 0 · Answer 8 · edited May 23 '17 at 12:02

This should work on Win7. The use of getEnvironmentVariable("APPDATA") instead of os.getenv('APPDATA') supports Unicode filepaths -- see question titled Problems with umlauts in python appdata environvent variable.

import base64
import ctypes
import os

def getEnvironmentVariable(name):
    """ read windows native unicode environment variables """
    # (could just use os.environ dict in Python 3)
    name = unicode(name) # make sure string argument is unicode
    n = ctypes.windll.kernel32.GetEnvironmentVariableW(name, None, 0)
    if not n:
        return None
    else:
        buf = ctypes.create_unicode_buffer(u'\0'*n)
        ctypes.windll.kernel32.GetEnvironmentVariableW(name, buf, n)
        return buf.value

def getDropboxRoot():
    # find the path for Dropbox's root watch folder from its sqlite host.db database.
    # Dropbox stores its databases under the currently logged in user's %APPDATA% path.
    # If you have installed multiple instances of dropbox under the same login this only finds the 1st one.
    # Dropbox stores its databases under the currently logged in user's %APPDATA% path.
    # usually "C:\Documents and Settings\<login_account>\Application Data"
    sConfigFile = os.path.join(getEnvironmentVariable("APPDATA"),
                               'Dropbox', 'host.db')

    # return null string if can't find or work database file.
    if not os.path.exists(sConfigFile):
        return None

    # Dropbox Watch Folder Location is base64 encoded as the last line of the host.db file.
    with open(sConfigFile) as dbxfile:
        for sLine in dbxfile:
            pass

    # decode last line, path to dropbox watch folder with no trailing slash.
    return base64.b64decode(sLine)

if __name__ == '__main__':
    print getDropboxRoot()

How to determine the Dropbox folder location programmatically?

8 Answers8

Short version:

Long version:

Linked