Mount Locally

You mount the container’s storage on your own computer, so the connection is client-initiated: your machine connects to the container, not the other way around. From there you get drag-and-drop file access in whatever file manager you already use.

What that gives you:

• Client-initiated - you open the connection from your local machine
• Local tools on container files - edit with VS Code, Photoshop, or Excel
• No container changes - SFTP via the Hoody SSH Proxy, WebDAV via hoody-files
• Familiar file managers - Finder and Explorer treat it like any network drive

---

API endpoints summary

File access:

• Hoody Files API - HTTP-based filesystem operations
• File Protocols - Connect external SFTP/FTP/SMB/WebDAV/HTTP backends into the container

Related access:

• SSH Access - Secure shell for command-line operations
• Hoody Terminal - Web-based shell (no mounting needed)

---

How it works

Two protocols support local mounting:

SFTP

Provided by: Hoody API (SSH Proxy)

• Built on SSH protocol (port 22)
• Same infrastructure as SSH access
• Same authentication (SSH keys)
• Privacy-preserving routing
• Universal SFTP client support

WebDAV

Provided by: hoody-kit (hoody-files service)

• HTTP/HTTPS-based protocol
• Authentication via Proxy Permissions
• Native macOS/Windows support
• Mount directly in file managers
• Works through firewalls easily

Both protocols reach the same container filesystem: SFTP through the Hoody API, WebDAV through hoody-kit.

---

SFTP mounting

SFTP is provided by the Hoody API’s SSH Proxy, the same infrastructure as SSH access.

Note

SFTP vs SSH distinction: SFTP is not provided by hoody-files. It is part of the Hoody API’s SSH Proxy infrastructure. Only WebDAV comes from hoody-files (hoody-kit).

Requirements

Note

SSH key required: SFTP uses SSH authentication. Your container must have an ssh_public_key configured. See SSH Access for key generation.

Connection details

Protocol: SFTP (SSH File Transfer Protocol)
Host: {projectId}-{containerId}-ssh.{serverName}.containers.hoody.com
Port: 22
Username: root
Authentication: SSH public key

You mount from your local machine to the container: a client-initiated connection, for security and control.

Example: if your container is on server us-west-1, the SFTP host is:

{projectId}-{containerId}-ssh.us-west-1.containers.hoody.com

Privacy benefit: the same endpoint serves all containers on that server. SFTP routing happens by SSH public key during the handshake, so the target container is not visible in the connection URL.

---

Mount SFTP in macOS Finder

Via Finder

1. Open Finder → Go menu → Connect to Server (⌘K)
2. Server Address:

   sftp://{projectId}-{containerId}-ssh.us-west-1.containers.hoody.com

3. Click Connect
4. Authentication:
   • Select your SSH private key from keychain
   • Or add new key: Keychain Access → add ~/.ssh/hoody-container-1
5. The container filesystem mounts as a network drive

Mounted at: /Volumes/{projectId}-{containerId}-ssh.us-west-1.containers.hoody.com/

Via Terminal

# Mount via sshfs (requires osxfuse/macFUSE)
brew install macfuse
brew install gromgit/fuse/sshfs-mac

# Create mount point
mkdir -p ~/Hoody/container-1

# Mount container
sshfs root@{projectId}-{containerId}-ssh.us-west-1.containers.hoody.com:/ \
  ~/Hoody/container-1 \
  -o IdentityFile=~/.ssh/hoody-container-1

# Access files
ls ~/Hoody/container-1/hoody/storage

# Unmount when done
umount ~/Hoody/container-1

---

Mount SFTP in Windows Explorer

WinSCP (Recommended)

Download: WinSCP

1. New Site:

   • File protocol: SFTP
   • Host name: {projectId}-{containerId}-ssh.us-west-1.containers.hoody.com
   • Port: 22
   • User name: root

2. Authentication:

   • Advanced → SSH → Authentication
   • Private key file: Browse to %USERPROFILE%\.ssh\hoody-container-1
   • WinSCP converts to .ppk format automatically

3. Login - the container filesystem appears in WinSCP’s file manager

4. Optional: Tools → Preferences → Integration → Explorer

   • Enable “Windows Explorer integration”
   • Access via right-click “WinSCP” in Explorer

FileZilla

1. Edit → Settings → Connection → SFTP

   • Add key file: %USERPROFILE%\.ssh\hoody-container-1

2. Site Manager → New Site:

   • Protocol: SFTP
   • Host: {projectId}-{containerId}-ssh.us-west-1.containers.hoody.com
   • Port: 22
   • Logon Type: Key file
   • User: root
   • Key file: (already added above)

3. Connect - a two-pane file manager shows local and remote side by side

Native Windows

Windows has no native SFTP client. Use WinSCP or FileZilla.

Or map a WebDAV drive instead (see the WebDAV section below).

---

Mount SFTP in Linux

# Install sshfs
sudo apt-get install sshfs  # Debian/Ubuntu
sudo dnf install sshfs      # Fedora
sudo pacman -S sshfs        # Arch

# Create mount point
mkdir -p ~/hoody-containers/container-1

# Mount container
sshfs root@{projectId}-{containerId}-ssh.us-west-1.containers.hoody.com:/ \
  ~/hoody-containers/container-1 \
  -o IdentityFile=~/.ssh/hoody-container-1

# Access files
ls ~/hoody-containers/container-1/hoody/storage

# Make persistent (add to /etc/fstab)
echo "root@{projectId}-{containerId}-ssh.us-west-1.containers.hoody.com:/ /home/user/hoody-containers/container-1 fuse.sshfs defaults,IdentityFile=/home/user/.ssh/hoody-container-1,allow_other 0 0" | sudo tee -a /etc/fstab

# Unmount
fusermount -u ~/hoody-containers/container-1

---

SFTP client comparison

Client	Platform	GUI	Features
FileZilla	Win/Mac/Linux	Yes	Two-pane, queue, bookmarks, free
WinSCP	Windows	Yes	Explorer integration, scripting, sync
Cyberduck	Mac/Windows	Yes	Finder integration, cloud services
Transmit	Mac	Yes	Polished UI, fast, paid
sshfs	Mac/Linux	No	Command-line, native mounting
Mountain Duck	Mac/Windows	Yes	Mount as drive letter, paid

---

WebDAV mounting

WebDAV provides HTTP-based filesystem access with native operating-system support.

Get the WebDAV URL

CLI

# Get container details to build WebDAV URL
hoody containers get $CONTAINER_ID

# The WebDAV URL follows this pattern:
# https://{project}-{container}-files-1.{server}.containers.hoody.com/

SDK

const container = await client.api.containers.get(CONTAINER_ID);
const { project_id, id, server_name } = container.data;

// Construct WebDAV URL from container details
const webdavUrl = `https://${project_id}-${id}-files-1.${server_name}.containers.hoody.com/`;
console.log(webdavUrl);
// https://PROJECT_ID-CONTAINER_ID-files-1.us-west-1.containers.hoody.com/

HTTP

# Get container details to find server name and IDs
curl "https://api.hoody.com/api/v1/containers/$CONTAINER_ID" \
  -H "Authorization: Bearer $TOKEN"

# Build WebDAV URL from response:
# https://{project_id}-{container_id}-files-1.{server_name}.containers.hoody.com/

URL

?

One request, one link

cURL runs inside your container and can wrap any HTTP request into a single GET URL. The call stops being something you need a client for and becomes something you can paste into a browser, send in a chat, bookmark, schedule with cron, or drop into a no-code tool.

Nothing is installed on the machine that opens it. The link does carry whatever credentials the call needs, so treat it as you would treat those credentials.

Slashes, colons and braces pass through as they are. The one character you must encode is an & inside a value, which happens when the wrapped URL carries its own query string. Left raw it ends the value early, and the rest is read as cURL's own parameters, so you get a 200 on a request you did not make.

How the wrapping works Chaining calls into one link Turning a link into a shortcut

Returns the container’s details, including project_id, id, and server_name, which you combine into the WebDAV URL as shown above.

Copy

https://PROJECT_ID-CONTAINER_ID-curl-1.SERVER.containers.hoody.com/api/v1/curl/request?url=https://api.hoody.com/api/v1/containers/CONTAINER_ID&method=GET&bearer_token=TOKEN&response=transparent

The link carries a credential and executes with it, so it is as sensitive as the credential itself — and it passes through the cURL service's request log on the way, not just the target's. Share it only where you would share the secret, and prefer a delegated token with minimal permissions and an expiry: see API tokens.

Connection details:

URL: https://{project}-{container}-files-1.{server}.containers.hoody.com/
Authentication: Hoody Proxy Permissions

Example URL:

https://PROJECT_ID-CONTAINER_ID-files-1.us-west-1.containers.hoody.com/

Note

Serving path: WebDAV is served at the root / of the files service. Clients speak WebDAV verbs (PROPFIND, COPY, MOVE, LOCK, UNLOCK, PROPPATCH, OPTIONS) directly against the service root. There is no /webdav path suffix.

Caution

Authentication: WebDAV requests are routed through the Hoody Proxy, which enforces access control before forwarding to the hoody-files service. Configure who can access via Proxy Permissions.

If your container has permissions configured, you’ll need those credentials. If permissions are disabled, which is the default, no authentication is required.

You mount from your client to the container, so you control the connection.

---

Mount WebDAV in macOS Finder

Via Finder

1. Finder → Go → Connect to Server (⌘K)

2. Server Address:

   https://PROJECT_ID-CONTAINER_ID-files-1.us-west-1.containers.hoody.com/

3. Click Connect

4. Authentication:

   • If Proxy Permissions configured: Use those credentials
   • If no permissions: Leave blank or use any credentials (access is open)

5. The container filesystem mounts as a WebDAV drive

Mounted at: /Volumes/webdav/

Persistent Mount

Add to Login Items for auto-mount:

1. Mount WebDAV as above
2. System Settings → General → Login Items
3. Click + and select mounted drive
4. Auto-mounts on login

---

Mount WebDAV in Windows Explorer

Map Network Drive

1. Right-click “This PC” → Map network drive

2. Drive letter: Choose (e.g., Z:)

3. Folder:

   https://PROJECT_ID-CONTAINER_ID-files-1.us-west-1.containers.hoody.com/

4. Check: “Reconnect at sign-in” (for persistence)

5. Check: “Connect using different credentials”

6. Credentials:

   • If Proxy Permissions configured: Use those credentials
   • If no permissions: Leave blank, or use any credentials, since access is open

7. Click Finish - the drive appears in Explorer as Z:\

Troubleshooting

If “The network path was not found”:

1. Enable WebClient service:

   # Run as Administrator
   sc config webclient start=auto
   sc start webclient

2. Modify registry for HTTPS support:

   • HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WebClient\Parameters
   • Set BasicAuthLevel = 2 (DWORD)
   • Restart WebClient service

3. Try mapping again

---

Mount WebDAV in Linux

# Install davfs2
sudo apt-get install davfs2  # Debian/Ubuntu
sudo dnf install davfs2      # Fedora

# Create mount point
sudo mkdir -p /mnt/hoody-container

# Add credentials to /etc/davfs2/secrets (if Proxy Permissions configured)
echo "https://PROJECT_ID-CONTAINER_ID-files-1.us-west-1.containers.hoody.com/ USERNAME PASSWORD" | sudo tee -a /etc/davfs2/secrets
# OR leave blank if no permissions configured
sudo chmod 600 /etc/davfs2/secrets

# Mount
sudo mount -t davfs https://PROJECT_ID-CONTAINER_ID-files-1.us-west-1.containers.hoody.com/ /mnt/hoody-container

# Access files
ls /mnt/hoody-container/hoody/storage

# Make persistent (add to /etc/fstab)
echo "https://PROJECT_ID-CONTAINER_ID-files-1.us-west-1.containers.hoody.com/ /mnt/hoody-container davfs user,noauto 0 0" | sudo tee -a /etc/fstab

# Unmount
sudo umount /mnt/hoody-container

---

Mount WebDAV on Android

WebDAV Navigator

Recommended WebDAV client for Android:

1. Install WebDAV Navigator from Play Store

2. Add Connection:

   • Tap + → WebDAV
   • URL: https://PROJECT_ID-CONTAINER_ID-files-1.us-west-1.containers.hoody.com/
   • If Proxy Permissions configured: Enter credentials
   • If no permissions: Leave blank or use any credentials

3. Browse Files:

   • Tap connection to browse container filesystem
   • /hoody/storage, /home/user, etc. all accessible

4. File Operations:

   • Download files to device
   • Upload from device to container
   • Create folders, rename, delete
   • Open with Android apps

Solid Explorer

A file manager with WebDAV support:

1. Install Solid Explorer

2. Add Storage:

   • Menu → Storage → Cloud → WebDAV
   • Server: PROJECT_ID-CONTAINER_ID-files-1.us-west-1.containers.hoody.com
   • Path: /
   • Protocol: HTTPS
   • If permissions: Enter credentials

3. Access:

   • Container appears as network storage
   • Two-pane file manager (local + WebDAV)
   • Drag and drop between device and container

FX File Explorer

1. Install FX File Explorer

2. Network → Add Network Location → WebDAV

   • Full URL: https://PROJECT_ID-CONTAINER_ID-files-1.us-west-1.containers.hoody.com/
   • Credentials if needed

3. Browse and manage files like local storage

---

Mount WebDAV on iOS and iPadOS

Files App (Native)

iOS 13 and later have built-in WebDAV support.

1. Open Files app

2. Tap ••• (More) → Connect to Server

3. Server:

   https://PROJECT_ID-CONTAINER_ID-files-1.us-west-1.containers.hoody.com/

4. Authentication:

   • If Proxy Permissions configured: Enter credentials
   • If no permissions: Tap “Connect as Guest”

5. Container mounts in sidebar under “Shared”

6. Access Files:

   • Browse container filesystem
   • Open files with iOS apps
   • Share files between apps
   • Download and upload by dragging

Documents by Readdle

A file manager with WebDAV support, search, and PDF viewing:

1. Install Documents

2. Services → + → WebDAV Server

   • Title: “Hoody Container”
   • URL: https://PROJECT_ID-CONTAINER_ID-files-1.us-west-1.containers.hoody.com/
   • Credentials if Proxy Permissions configured

3. Full file management:

   • Browse, search, preview files
   • Download to device
   • Upload from device or iCloud
   • Zip/unzip files
   • Integrated PDF viewer

FE File Explorer

1. Install FE File Explorer

2. Remote Storage → WebDAV

   • Server: PROJECT_ID-CONTAINER_ID-files-1.us-west-1.containers.hoody.com
   • Path: /
   • Protocol: HTTPS

3. Two-pane file manager with thumbnails

---

SFTP vs WebDAV

The two differ in setup, platform support, and metadata handling:

Feature	SFTP	WebDAV
Provided By	Hoody API (SSH Proxy)	hoody-kit (hoody-files)
Setup	Requires SSH key	Uses Proxy Permissions
Native Support	macOS/Linux (via sshfs)	macOS/Windows/iOS (built-in)
Mobile Support	Android/iOS SSH clients	Android/iOS native file managers
Security	SSH protocol	HTTPS
Firewall	Port 22 (sometimes blocked)	Port 443 (rarely blocked)
Speed	Fast	Slightly slower (HTTP overhead)
Metadata	Full POSIX support	Limited metadata
Compatibility	All SFTP clients	All WebDAV clients

Recommendation:

• SFTP: when you already have SSH configured and need full POSIX metadata (desktop or laptop)
• WebDAV: for native OS mounting, especially on mobile (iOS Files app, Android file managers)
• Either one for basic file transfer, where they work equally well

---

Use cases

Edit container files locally

Mount the container, edit locally, and the changes land in the container immediately:

# Mount container filesystem
# macOS:
open sftp://{projectId}-{containerId}-ssh.us-west-1.containers.hoody.com

# Edit files in your favorite local editor
code /Volumes/{projectId}-{containerId}-ssh.us-west-1.containers.hoody.com/hoody/storage/myapp/

# Changes saved locally = changes in container instantly

Good for: editing code, configs, and logs without an SSH terminal.

Back up container data

Drag and drop a backup through your file manager:

# Mount container
# Copy /hoody/storage to local backup
cp -r /Volumes/webdav/hoody/storage ~/Backups/container-backup-2025-11-10/

# Or use rsync for incremental backups
rsync -av /Volumes/webdav/hoody/storage/ ~/Backups/container-latest/

Better than: manual file downloads via the HTTP API.

Upload files in bulk

Upload hundreds of files in one operation:

# Mount container WebDAV
# Drag entire project folder from local machine
# to /Volumes/webdav/hoody/storage/projects/

# Or use command-line
cp -r ~/Projects/website/* /Volumes/webdav/var/www/html/

Faster than: sequential HTTP uploads.

Watch logs as they are written

Tail logs in a local text editor:

# Mount container
# Open log file with live-updating editor (e.g., VS Code, Sublime Text)
code /Volumes/webdav/hoody/storage/myapp/logs/app.log

# Log updates appear in real-time as container writes

Alternative to: SSH plus tail -f.

---

Best practices

Use SFTP for privacy

SFTP’s public key routing means the connection URL doesn’t reveal which container you’re accessing:

# Same endpoint for all containers
{projectId}-{containerId}-ssh.us-west-1.containers.hoody.com

# Routing happens by SSH key (invisible to network observers)

WebDAV URLs contain the project and container IDs, which are visible to anyone who sees the URL.

Store credentials securely

SFTP: SSH keys already in ~/.ssh/ with permissions 600

WebDAV: Use credential managers:

• macOS: Keychain stores WebDAV passwords automatically
• Windows: Credential Manager saves mapped drive credentials
• Linux: davfs2 secrets file with chmod 600

Never hard-code API tokens in scripts.

Unmount when done

Leaving mounts active consumes resources:

# macOS
umount /Volumes/webdav

# Linux
fusermount -u ~/hoody-containers/container-1

# Windows
net use Z: /delete

Or set up auto-unmount on logout and shutdown.

Mount read-only when browsing

SFTP (Linux/macOS):

sshfs root@{projectId}-{containerId}-ssh.{serverName}.containers.hoody.com:/ ~/container-1 \
  -o ro,IdentityFile=~/.ssh/key

A read-only mount prevents accidental deletions when you are only browsing or reading files.

Prefer the HTTP API for automation

Local mounting is for human interaction: file managers and editors.

For automation such as scripts and CI/CD, use the Hoody Files HTTP API:

# Automation: Direct HTTP
curl "https://...-files.../api/v1/files/data.json"

# Automation: Mounting unnecessary
mount → access → unmount (slower, more complex)

---

Useful questions

Do I need SSH configured for SFTP mounting?

Yes. SFTP uses SSH authentication, so your container must have an ssh_public_key configured. See SSH Access.

WebDAV does not require SSH. It uses Hoody Proxy Permissions, or no authentication if permissions are disabled.

Can I mount multiple containers simultaneously?

Yes. Each container has unique SFTP and WebDAV endpoints, so mount as many as you need.

SFTP: Different SSH keys route to different containers (same hostname).

WebDAV: Different container URLs mount as different drives.

Does mounting affect container performance?

Minimal impact. File operations go through the hoody-files service, which is optimized for this use case.

Heavy operations, such as copying gigabytes of data, consume bandwidth and I/O like any file transfer.

Can other users mount my container?

SFTP: Only if they have the container’s SSH private key.

WebDAV: Only if they pass Proxy Permissions (if configured). If permissions disabled, WebDAV is open access.

Security: Configure Proxy Permissions for WebDAV access control. SFTP is always key-protected.

What happens if I delete files via mounted drive?

Files are permanently deleted from the container filesystem, the same as running rm over SSH.

Safety: Create snapshots before bulk deletions.

Does mounting work with containers in “block” network mode?

Yes. Mounting is inbound, to the container, through the Hoody Proxy. Network block mode only prevents outbound traffic from the container.

---

Troubleshooting

SFTP connection refused

Problem: “Connection refused” when mounting SFTP

Solutions:

1. Verify container is running:

   curl "https://api.hoody.com/api/v1/containers/{id}" \
     -H "Authorization: Bearer $TOKEN"
   # Check: "status": "running"

2. Test SSH connectivity:

   ssh -i ~/.ssh/hoody-container-1 root@{projectId}-{containerId}-ssh.{serverName}.containers.hoody.com
   # Should connect to shell

3. Check SSH key is added to container:

   # Verify via API
   GET /api/v1/containers/{id}
   # Check: "ssh_public_key" field is set

WebDAV authentication failed

Problem: Windows can’t connect to WebDAV, authentication fails

Solutions:

1. Enable WebClient service:

   sc config webclient start=auto
   sc start webclient

2. Allow Basic Auth over HTTPS: Registry: HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\WebClient\Parameters

   • Set BasicAuthLevel = 2
   • Restart WebClient

3. Check Proxy Permissions:

   • If permissions configured: Verify credentials are correct
   • If no permissions: Any credentials should work (or leave blank)
   • See Proxy Permissions for configuration

macOS refuses the HTTPS certificate

Problem: macOS blocks the WebDAV connection over the SSL certificate

Solution: Hoody issues and renews per-server wildcard certificates (*.{serverName}.containers.hoody.com), so this should not happen.

If it does:

1. Verify URL is correct (use container’s actual URL from Hoody)
2. Try SFTP instead (SSH doesn’t have this issue)

Files look outdated after editing

Problem: Changes made in container don’t appear in mounted filesystem

Cause: File manager caching

Solutions:

1. Unmount and remount:

   umount /Volumes/webdav
   # Remount

2. Refresh view: F5 or ⌘R in file manager

3. Use Hoody Terminal to verify file contents:

   cat /path/to/changed/file

Slow transfer speeds

Problem: File transfers via mounted filesystem are slow

Solutions:

1. Check network latency:

   ping {projectId}-{containerId}-ssh.{serverName}.containers.hoody.com
   # High latency = slow transfers

2. Use a nearby server: create the container on a geographically close server

3. Compress before transfer:

   # Instead of copying entire directory
   tar czf backup.tar.gz /source/dir
   # Copy single compressed file (faster)

4. Use a direct HTTP upload for large files:

   curl -X PUT "https://...-files.../api/v1/files/uploads/large-file.zip" \
     --data-binary @large-file.zip

---

What’s next

Other storage capabilities:

• Container Storage → - The container filesystem and /hoody/storage
• SQLite Driver → - Concurrent-write-safe databases in /hoody/databases/
• Cloud Storage → - Mount 62 cloud providers via hoody-files
• Shared Storage → - Share directories between containers
• /ramdisk → - RAM-backed storage

File access methods:

• Hoody Files API → - HTTP-based filesystem operations
• SSH Access → - Secure shell for command-line
• Hoody Terminal → - Web-based shell access

What this page covered:

• SFTP is provided by the Hoody API, on the SSH Proxy infrastructure
• WebDAV is provided by hoody-files, a hoody-kit service
• You mount from your machine to the container, so the connection is yours to open and close
• The container filesystem mounts in macOS Finder, Windows Explorer, and Linux
• SFTP uses SSH keys, with privacy-preserving routing through the Hoody API
• WebDAV uses Proxy Permissions for authentication
• You reach the same filesystem as over SSH, through a file manager instead