Cloud Storage

Connect cloud storage backends such as Google Drive, Dropbox, OneDrive, iCloud, and dozens more to a Hoody files container. Each endpoint registers a new backend of a specific provider type, returning the backend identifier you can later mount under any filesystem path. The body of every endpoint is a provider-specific configuration object whose defaults reflect typical usage, and you can override any field per request.

All endpoints share the same response envelope: a successful connection returns 201 with the new backend’s id, type, and backend_type; a failed connection returns 400 with success: false and an error string.

Consumer cloud storage

`POST /api/v1/backends/drive`

Connect a Google Drive backend.

Request Body

Name	Type	Required	Default	Description
`acknowledge_abuse`	boolean	No	`false`	Allow download of files Google flagged as abusive
`allow_import_name_change`	boolean	No	`false`	Allow filetype change when uploading Google docs
`alternate_export`	boolean	No	`false`	Deprecated, no longer needed
`auth_owner_only`	boolean	No	`false`	Only consider files owned by the authenticated user
`auth_url`	string	No	`""`	Auth server URL (blank uses provider default)
`chunk_size`	string	No	`"8388608"`	Upload chunk size (power of 2, >= 256k)
`client_credentials`	boolean	No	`false`	Use OAuth2 client credentials flow
`client_id`	string	No	`""`	Google Application Client Id
`client_secret`	string	No	`""`	OAuth Client Secret
`copy_shortcut_content`	boolean	No	`false`	Copy shortcut contents rather than shortcuts on server-side copy
`description`	string	No	`""`	Description of the remote
`disable_http2`	boolean	No	`true`	Disable HTTP/2 (workaround for known Drive HTTP/2 issue)
`encoding`	string	No	`"16777216"`	Backend encoding (see encoding overview)
`env_auth`	boolean	No	`false`	Get IAM credentials from runtime
`export_formats`	string	No	`"docx,xlsx,pptx,svg"`	Comma-separated preferred download formats for Google docs
`fast_list_bug_fix`	boolean	No	`true`	Workaround for Drive listing bug
`formats`	string	No	`""`	Deprecated, see `export_formats`
`impersonate`	string	No	`""`	Impersonate this user with a service account
`import_formats`	string	No	`""`	Comma-separated preferred upload formats for Google docs
`keep_revision_forever`	boolean	No	`false`	Keep new head revision of each file forever
`list_chunk`	integer	No	`1000`	Listing chunk size 100-1000, 0 disables
`metadata_labels`	string	No	`"0"`	Read or write labels metadata (`off`, `read`, `write`, `failok`, `read,write`)
`metadata_owner`	string	No	`"1"`	Read or write owner metadata
`metadata_permissions`	string	No	`"0"`	Read or write permissions metadata
`pacer_burst`	integer	No	`100`	API calls allowed without sleeping
`pacer_min_sleep`	integer	No	`0`	Minimum sleep between API calls (seconds)
`resource_key`	string	No	`""`	Resource key for link-shared files
`root_folder_id`	string	No	`""`	ID of the root folder (blank for default)
`scope`	string	No	`""`	Comma-separated OAuth scopes (`drive`, `drive.readonly`, `drive.file`, `drive.appfolder`, `drive.metadata.readonly`)
`server_side_across_configs`	boolean	No	`false`	Allow server-side operations across Drive configs
`service_account_credentials`	string	No	`""`	Service account JSON blob
`service_account_file`	string	No	`""`	Service account JSON file path
`shared_with_me`	boolean	No	`false`	Only show “Shared with me” files
`show_all_gdocs`	boolean	No	`false`	Include non-exportable Google docs in listings
`size_as_quota`	boolean	No	`false`	Show sizes as storage quota usage
`skip_checksum_gphotos`	boolean	No	`false`	Skip checksums on Google photos/videos
`skip_dangling_shortcuts`	boolean	No	`false`	Skip dangling shortcut files
`skip_gdocs`	boolean	No	`false`	Skip Google docs in listings
`skip_shortcuts`	boolean	No	`false`	Skip shortcut files entirely
`starred_only`	boolean	No	`false`	Only show starred files
`stop_on_download_limit`	boolean	No	`false`	Make 10 TiB/day download limit errors fatal
`stop_on_upload_limit`	boolean	No	`false`	Make 750 GiB/day upload limit errors fatal
`team_drive`	string	No	`""`	ID of the Shared Drive (Team Drive)
`token`	string	No	`""`	OAuth Access Token as JSON blob
`token_url`	string	No	`""`	Token server URL (blank uses provider default)
`trashed_only`	boolean	No	`false`	Only show trashed files
`upload_cutoff`	string	No	`"8388608"`	Cutoff for switching to chunked upload
`use_created_date`	boolean	No	`false`	Use created date instead of modified date
`use_shared_date`	boolean	No	`false`	Use shared date instead of modified date
`use_trash`	boolean	No	`true`	Send files to trash instead of deleting permanently
`v2_download_min_size`	string	No	`"-1"`	If object is larger, use Drive v2 API to download

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "drive-1f7b3c2a",
    "type": "drive",
    "backend_type": "drive",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Invalid OAuth token"
}

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectDrive({
  client_id: 'your-google-client-id.apps.googleusercontent.com',
  client_secret: 'your-google-client-secret',
  scope: 'drive',
  root_folder_id: ''
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/drive" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "client_id": "your-google-client-id.apps.googleusercontent.com",
    "client_secret": "your-google-client-secret",
    "scope": "drive"
  }'

`POST /api/v1/backends/dropbox`

Connect a Dropbox backend.

Request Body

Name	Type	Required	Default	Description
`auth_url`	string	No	`""`	Auth server URL (blank uses provider default)
`batch_commit_timeout`	integer	No	`600`	Max seconds to wait for a batch to finish committing
`batch_mode`	string	No	`"sync"`	Upload batching mode (`off`, `sync`, `async`)
`batch_size`	integer	No	`0`	Max files per upload batch (less than 1000)
`batch_timeout`	integer	No	`0`	Max idle seconds before uploading a batch
`chunk_size`	string	No	`"50331648"`	Upload chunk size (< 150 MiB)
`client_credentials`	boolean	No	`false`	Use OAuth2 client credentials flow
`client_id`	string	No	`""`	OAuth Client Id
`client_secret`	string	No	`""`	OAuth Client Secret
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"52469762"`	Backend encoding
`impersonate`	string	No	`""`	Impersonate a user (business accounts)
`pacer_min_sleep`	integer	No	`0`	Minimum sleep between API calls (seconds)
`root_namespace`	string	No	`""`	Different Dropbox namespace ID to use as root
`shared_files`	boolean	No	`false`	Operate on individual shared files
`shared_folders`	boolean	No	`false`	Operate on shared folders
`token`	string	No	`""`	OAuth Access Token as JSON blob
`token_url`	string	No	`""`	Token server URL (blank uses provider default)

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "dropbox-9a4b1e88",
    "type": "dropbox",
    "backend_type": "dropbox",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Dropbox token rejected"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectDropbox({
  client_id: 'your-dropbox-client-id',
  client_secret: 'your-dropbox-client-secret',
  chunk_size: '50331648'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/dropbox" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "client_id": "your-dropbox-client-id",
    "client_secret": "your-dropbox-client-secret"
  }'

`POST /api/v1/backends/onedrive`

Connect a Microsoft OneDrive backend.

Request Body

Name	Type	Required	Default	Description
`access_scopes`	string	No	`"Files.Read Files.ReadWrite Files.Read.All Files.ReadWrite.All Sites.Read.All offline_access"`	Space-separated OAuth scopes
`auth_url`	string	No	`""`	Auth server URL (blank uses provider default)
`av_override`	boolean	No	`false`	Allow download of files the server flags as infected
`chunk_size`	string	No	`"10485760"`	Upload chunk size (multiple of 320k)
`client_credentials`	boolean	No	`false`	Use OAuth2 client credentials flow
`client_id`	string	No	`""`	OAuth Client Id
`client_secret`	string	No	`""`	OAuth Client Secret
`delta`	boolean	No	`false`	Use delta listing for recursive listings
`description`	string	No	`""`	Description of the remote
`disable_site_permission`	boolean	No	`false`	Do not request `Sites.Read.All`
`drive_id`	string	No	`""`	ID of the drive to use
`drive_type`	string	No	`""`	Type of the drive (`personal`, `business`, `documentLibrary`)
`encoding`	string	No	`"57386894"`	Backend encoding
`expose_onenote_files`	boolean	No	`false`	Show OneNote files in listings
`hard_delete`	boolean	No	`false`	Permanently delete files on removal
`hash_type`	string	No	`"auto"`	Hash type (`auto`, `quickxor`, `sha1`, `sha256`, `crc32`, `none`)
`link_password`	string	No	`""`	Password for links created by the link command
`link_scope`	string	No	`"anonymous"`	Link scope (`anonymous`, `organization`)
`link_type`	string	No	`"view"`	Link type (`view`, `edit`, `embed`)
`list_chunk`	integer	No	`1000`	Listing chunk size
`metadata_permissions`	string	No	`"0"`	Read/write permissions metadata
`no_versions`	boolean	No	`false`	Remove all versions on modifying operations
`region`	string	No	`"global"`	National cloud region (`global`, `us`, `de`, `cn`)
`root_folder_id`	string	No	`""`	ID of the root folder
`server_side_across_configs`	boolean	No	`false`	Server-side operations across OneDrive configs
`tenant`	string	No	`""`	Service principal tenant ID
`token`	string	No	`""`	OAuth Access Token as JSON blob
`token_url`	string	No	`""`	Token server URL (blank uses provider default)

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "onedrive-3c81d6e2",
    "type": "onedrive",
    "backend_type": "onedrive",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "OneDrive drive_id not found"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectOnedrive({
  client_id: 'your-azure-app-client-id',
  client_secret: 'your-azure-app-client-secret',
  region: 'global',
  drive_type: 'personal'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/onedrive" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "client_id": "your-azure-app-client-id",
    "client_secret": "your-azure-app-client-secret",
    "region": "global"
  }'

`POST /api/v1/backends/iclouddrive`

Connect an Apple iCloud Drive backend.

Request Body

Name	Type	Required	Default	Description
`apple_id`	string	Yes	`""`	Apple ID
`client_id`	string	No	`"d39ba9916b7251055b22c7f910e2ea796ee65e98b2ddecea8f5dde8d9d1a815d"`	Client id
`cookies`	string	No	`""`	Cookies (internal use only)
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"50438146"`	Backend encoding
`password`	string	Yes	`""`	Password
`trust_token`	string	No	`""`	Trust token

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "iclouddrive-77a2c041",
    "type": "iclouddrive",
    "backend_type": "iclouddrive",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "iCloud authentication failed"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectIclouddrive({
  apple_id: 'user@example.com',
  password: 'app-specific-password'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/iclouddrive" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "apple_id": "user@example.com",
    "password": "app-specific-password"
  }'

`POST /api/v1/backends/google-photos`

Connect a Google Photos backend.

Request Body

Name	Type	Required	Default	Description
`auth_url`	string	No	`""`	Auth server URL (blank uses provider default)
`batch_commit_timeout`	integer	No	`600`	Max seconds to wait for a batch to finish committing
`batch_mode`	string	No	`"sync"`	Upload batching mode (`off`, `sync`, `async`)
`batch_size`	integer	No	`0`	Max files per upload batch (less than 50)
`batch_timeout`	integer	No	`0`	Max idle seconds before uploading a batch
`client_credentials`	boolean	No	`false`	Use OAuth2 client credentials flow
`client_id`	string	No	`""`	OAuth Client Id
`client_secret`	string	No	`""`	OAuth Client Secret
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"50348034"`	Backend encoding
`include_archived`	boolean	No	`false`	View and download archived media
`proxy`	string	No	`""`	gphotosdl proxy URL for full-resolution downloads
`read_only`	boolean	No	`false`	Request read-only access to photos
`read_size`	boolean	No	`false`	Read size of media items (recommended for mount)
`start_year`	integer	No	`2000`	Earliest year to include in downloads
`token`	string	No	`""`	OAuth Access Token as JSON blob
`token_url`	string	No	`""`	Token server URL (blank uses provider default)

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "google-photos-4e7a9b21",
    "type": "google photos",
    "backend_type": "google photos",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Google Photos OAuth scope missing"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectGooglePhotos({
  read_only: true,
  read_size: true,
  start_year: 2015
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/google-photos" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "read_only": true,
    "read_size": true,
    "start_year": 2015
  }'

`POST /api/v1/backends/pcloud`

Connect a Pcloud backend.

Request Body

Name	Type	Required	Default	Description
`auth_url`	string	No	`""`	Auth server URL (blank uses provider default)
`client_credentials`	boolean	No	`false`	Use OAuth2 client credentials flow
`client_id`	string	No	`""`	OAuth Client Id
`client_secret`	string	No	`""`	OAuth Client Secret
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"50438146"`	Backend encoding
`hostname`	string	No	`"api.pcloud.com"`	Hostname (`api.pcloud.com` or `eapi.pcloud.com`)
`password`	string	No	`""`	Your pcloud password
`root_folder_id`	string	No	`"d0"`	Non-root folder to start from
`token`	string	No	`""`	OAuth Access Token as JSON blob
`token_url`	string	No	`""`	Token server URL (blank uses provider default)
`username`	string	No	`""`	Your pcloud username (required only for cleanup command)

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "pcloud-8d2f4a90",
    "type": "pcloud",
    "backend_type": "pcloud",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "pcloud hostname unreachable"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectPcloud({
  client_id: 'your-pcloud-client-id',
  client_secret: 'your-pcloud-client-secret',
  hostname: 'api.pcloud.com'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/pcloud" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "hostname": "api.pcloud.com",
    "username": "user@example.com",
    "password": "pcloud-password"
  }'

`POST /api/v1/backends/yandex`

Connect a Yandex Disk backend.

Request Body

Name	Type	Required	Default	Description
`auth_url`	string	No	`""`	Auth server URL (blank uses provider default)
`client_credentials`	boolean	No	`false`	Use OAuth2 client credentials flow
`client_id`	string	No	`""`	OAuth Client Id
`client_secret`	string	No	`""`	OAuth Client Secret
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"50429954"`	Backend encoding
`hard_delete`	boolean	No	`false`	Permanently delete files instead of sending to trash
`spoof_ua`	boolean	No	`true`	Use the official Yandex Disk user agent
`token`	string	No	`""`	OAuth Access Token as JSON blob
`token_url`	string	No	`""`	Token server URL (blank uses provider default)

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "yandex-6b0e22c5",
    "type": "yandex",
    "backend_type": "yandex",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Yandex Disk token expired"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectYandex({
  client_id: 'your-yandex-client-id',
  client_secret: 'your-yandex-client-secret',
  hard_delete: false
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/yandex" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "client_id": "your-yandex-client-id",
    "client_secret": "your-yandex-client-secret"
  }'

Privacy and security-focused

`POST /api/v1/backends/protondrive`

Connect a Proton Drive backend.

Request Body

Name	Type	Required	Default	Description
`2fa`	string	No	`""`	2FA code if 2FA is enabled
`app_version`	string	No	`"macos-drive@1.0.0-alpha.1+hoody-vfs"`	App version string sent with every API request
`client_access_token`	string	No	`""`	Client access token (internal use only)
`client_refresh_token`	string	No	`""`	Client refresh token (internal use only)
`client_salted_key_pass`	string	No	`""`	Client salted key pass (internal use only)
`client_uid`	string	No	`""`	Client uid (internal use only)
`description`	string	No	`""`	Description of the remote
`enable_caching`	boolean	No	`true`	Cache file/folder metadata to reduce API calls
`encoding`	string	No	`"52559874"`	Backend encoding
`mailbox_password`	string	No	`""`	Mailbox password (for two-password Proton accounts)
`original_file_size`	boolean	No	`true`	Return file size before encryption
`password`	string	Yes	`""`	Proton account password
`replace_existing_draft`	boolean	No	`false`	Replace draft on filename conflict
`username`	string	Yes	`""`	Proton account username

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "protondrive-c9a4e712",
    "type": "protondrive",
    "backend_type": "protondrive",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Proton Drive 2FA code invalid or expired"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectProtondrive({
  username: 'user@proton.me',
  password: 'proton-password',
  mailbox_password: 'mailbox-password',
  '2fa': '123456'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/protondrive" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "username": "user@proton.me",
    "password": "proton-password"
  }'

`POST /api/v1/backends/mega`

Connect a Mega backend.

Request Body

Name	Type	Required	Default	Description
`debug`	boolean	No	`false`	Output more debug from Mega
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"50331650"`	Backend encoding
`hard_delete`	boolean	No	`false`	Permanently delete files instead of sending to trash
`pass`	string	Yes	`""`	Mega password
`use_https`	boolean	No	`false`	Use HTTPS for transfers
`user`	string	Yes	`""`	Mega username

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "mega-21d8b3f6",
    "type": "mega",
    "backend_type": "mega",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Mega login failed"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectMega({
  user: 'user@example.com',
  pass: 'mega-password',
  use_https: true
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/mega" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "user": "user@example.com",
    "pass": "mega-password"
  }'

`POST /api/v1/backends/koofr`

Connect a Koofr, Digi Storage, or other Koofr-compatible backend.

Request Body

Name	Type	Required	Default	Description
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"50438146"`	Backend encoding
`endpoint`	string	Yes	`""`	The Koofr API endpoint to use
`mountid`	string	No	`""`	Mount ID (omitted uses primary mount)
`password`	string	Yes	`""`	Application password from your Koofr service
`provider`	string	No	`""`	Storage provider (`koofr`, `digistorage`, `other`)
`setmtime`	boolean	No	`true`	Whether the backend supports setting modification time
`user`	string	Yes	`""`	Your user name

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "koofr-5a91d2cc",
    "type": "koofr",
    "backend_type": "koofr",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Koofr endpoint unreachable"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectKoofr({
  provider: 'koofr',
  endpoint: 'https://app.koofr.net',
  user: 'user@example.com',
  password: 'app-password'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/koofr" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "provider": "koofr",
    "endpoint": "https://app.koofr.net",
    "user": "user@example.com",
    "password": "app-password"
  }'

`POST /api/v1/backends/mailru`

Connect a Mail.ru Cloud backend.

Request Body

Name	Type	Required	Default	Description
`auth_url`	string	No	`""`	Auth server URL (blank uses provider default)
`check_hash`	boolean	No	`true`	What to do when file checksum is mismatched or invalid
`client_credentials`	boolean	No	`false`	Use OAuth2 client credentials flow
`client_id`	string	No	`""`	OAuth Client Id
`client_secret`	string	No	`""`	OAuth Client Secret
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"50440078"`	Backend encoding
`pass`	string	Yes	`""`	Mail.ru app password
`quirks`	string	No	`""`	Comma-separated internal maintenance flags
`speedup_enable`	boolean	No	`true`	Skip full upload if a file with the same hash already exists
`speedup_file_patterns`	string	No	`".mkv,.avi,.mp4,.mp3,.zip,.gz,.rar,.pdf"`	Filename patterns eligible for speedup
`speedup_max_disk`	string	No	`"3221225472"`	Disable speedup for files larger than this
`speedup_max_memory`	string	No	`"33554432"`	Files larger than this are hashed on disk
`token`	string	No	`""`	OAuth Access Token as JSON blob
`token_url`	string	No	`""`	Token server URL (blank uses provider default)
`user`	string	Yes	`""`	Mail.ru user name (usually email)
`user_agent`	string	No	`""`	HTTP user agent

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "mailru-e21b4f8c",
    "type": "mailru",
    "backend_type": "mailru",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Mail.ru requires an app password"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectMailru({
  user: 'user@mail.ru',
  pass: 'app-password',
  speedup_enable: true
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/mailru" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "user": "user@mail.ru",
    "pass": "app-password"
  }'

Enterprise and team storage

`POST /api/v1/backends/filescom`

Connect a Files.com backend.

Request Body

Name	Type	Required	Default	Description
`api_key`	string	No	`""`	Files.com API key
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"60923906"`	Backend encoding
`password`	string	No	`""`	Files.com password
`site`	string	No	`""`	Site subdomain or custom domain
`username`	string	No	`""`	Files.com username

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "filescom-7f3a9b01",
    "type": "filescom",
    "backend_type": "filescom",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Files.com API key rejected"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectFilescom({
  site: 'mysite',
  username: 'user@example.com',
  api_key: 'filescom-api-key'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/filescom" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "site": "mysite",
    "api_key": "filescom-api-key"
  }'

`POST /api/v1/backends/hidrive`

Connect a HiDrive (IONOS) backend.

Request Body

Name	Type	Required	Default	Description
`auth_url`	string	No	`""`	Auth server URL (blank uses provider default)
`chunk_size`	string	No	`"50331648"`	Chunk size for chunked uploads
`client_credentials`	boolean	No	`false`	Use OAuth2 client credentials flow
`client_id`	string	No	`""`	OAuth Client Id
`client_secret`	string	No	`""`	OAuth Client Secret
`description`	string	No	`""`	Description of the remote
`disable_fetching_member_count`	boolean	No	`false`	Do not fetch number of objects in subdirectories
`encoding`	string	No	`"33554434"`	Backend encoding
`endpoint`	string	No	`"https://api.hidrive.strato.com/2.1"`	API endpoint URL
`root_prefix`	string	No	`"/"`	Root folder for all paths (`/`, `root`, or empty)
`scope_access`	string	No	`"rw"`	Access permissions (`rw` or `ro`)
`scope_role`	string	No	`"user"`	User level (`user`, `admin`, `owner`)
`token`	string	No	`""`	OAuth Access Token as JSON blob
`token_url`	string	No	`""`	Token server URL (blank uses provider default)
`upload_concurrency`	integer	No	`4`	Concurrency for chunked uploads
`upload_cutoff`	string	No	`"100663296"`	Cutoff for chunked uploads

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "hidrive-2c8e5d77",
    "type": "hidrive",
    "backend_type": "hidrive",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "HiDrive endpoint unreachable"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectHidrive({
  client_id: 'your-hidrive-client-id',
  client_secret: 'your-hidrive-client-secret',
  endpoint: 'https://api.hidrive.strato.com/2.1'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/hidrive" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "https://api.hidrive.strato.com/2.1",
    "client_id": "your-hidrive-client-id",
    "client_secret": "your-hidrive-client-secret"
  }'

`POST /api/v1/backends/sharefile`

Connect a Citrix Sharefile backend.

Request Body

Name	Type	Required	Default	Description
`auth_url`	string	No	`""`	Auth server URL (blank uses provider default)
`chunk_size`	string	No	`"67108864"`	Upload chunk size (power of 2, >= 256k)
`client_credentials`	boolean	No	`false`	Use OAuth2 client credentials flow
`client_id`	string	No	`""`	OAuth Client Id
`client_secret`	string	No	`""`	OAuth Client Secret
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"57091982"`	Backend encoding
`endpoint`	string	No	`""`	API endpoint (auto-discovered during OAuth)
`root_folder_id`	string	No	`""`	Root folder ID (`""`, `favorites`, `allshared`, `connectors`, `top`)
`token`	string	No	`""`	OAuth Access Token as JSON blob
`token_url`	string	No	`""`	Token server URL (blank uses provider default)
`upload_cutoff`	string	No	`"134217728"`	Cutoff for multipart upload

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "sharefile-9d41a2f8",
    "type": "sharefile",
    "backend_type": "sharefile",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Sharefile endpoint not discovered"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectSharefile({
  client_id: 'your-sharefile-client-id',
  client_secret: 'your-sharefile-client-secret',
  endpoint: 'https://myorg.sharefile.com'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/sharefile" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "endpoint": "https://myorg.sharefile.com",
    "client_id": "your-sharefile-client-id",
    "client_secret": "your-sharefile-client-secret"
  }'

`POST /api/v1/backends/quatrix`

Connect a Quatrix by Maytech backend.

Request Body

Name	Type	Required	Default	Description
`api_key`	string	Yes	`""`	API key for accessing Quatrix
`description`	string	No	`""`	Description of the remote
`effective_upload_time`	string	No	`"4s"`	Wanted upload time for one chunk
`encoding`	string	No	`"50438146"`	Backend encoding
`hard_delete`	boolean	No	`false`	Permanently delete files instead of sending to trash
`host`	string	Yes	`""`	Host name of Quatrix account
`maximal_summary_chunk_size`	string	No	`"100000000"`	Max summary size for all chunks
`minimal_chunk_size`	string	No	`"10000000"`	Minimal size for one chunk
`skip_project_folders`	boolean	No	`false`	Skip project folders in operations

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "quatrix-3f8c2e15",
    "type": "quatrix",
    "backend_type": "quatrix",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Quatrix API key invalid"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectQuatrix({
  host: 'myorg.quatrix.it',
  api_key: 'quatrix-api-key',
  minimal_chunk_size: '10000000'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/quatrix" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "host": "myorg.quatrix.it",
    "api_key": "quatrix-api-key"
  }'

`POST /api/v1/backends/filefabric`

Connect an Enterprise File Fabric backend.

Request Body

Name	Type	Required	Default	Description
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"50429954"`	Backend encoding
`permanent_token`	string	No	`""`	Permanent Authentication Token from your File Fabric dashboard
`root_folder_id`	string	No	`""`	ID of the root folder to start from
`token`	string	No	`""`	Session token (auto-set by Hoody)
`token_expiry`	string	No	`""`	Token expiry (auto-set by Hoody)
`url`	string	Yes	`""`	File Fabric URL (`https://storagemadeeasy.com`, `https://eu.storagemadeeasy.com`, `https://yourfabric.smestorage.com`)
`version`	string	No	`""`	File Fabric version (auto-set by Hoody)

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "filefabric-b61f0c92",
    "type": "filefabric",
    "backend_type": "filefabric",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "File Fabric permanent token rejected"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectFilefabric({
  url: 'https://storagemadeeasy.com',
  permanent_token: 'long-lived-token-from-dashboard'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/filefabric" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://storagemadeeasy.com",
    "permanent_token": "long-lived-token-from-dashboard"
  }'

`POST /api/v1/backends/seafile`

Connect a Seafile backend.

Request Body

Name	Type	Required	Default	Description
`2fa`	boolean	No	`false`	Whether 2FA is enabled on the account
`auth_token`	string	No	`""`	Authentication token
`create_library`	boolean	No	`false`	Create a library if it doesn’t exist
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"16850954"`	Backend encoding
`library`	string	No	`""`	Name of the library (blank for all non-encrypted libraries)
`library_key`	string	No	`""`	Library password (encrypted libraries only)
`pass`	string	No	`""`	Seafile password
`url`	string	Yes	`""`	Seafile host URL (`https://cloud.seafile.com/`)
`user`	string	Yes	`""`	Seafile username (usually email)

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "seafile-1d9a4f3e",
    "type": "seafile",
    "backend_type": "seafile",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Seafile library not found"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectSeafile({
  url: 'https://cloud.seafile.com/',
  user: 'user@example.com',
  pass: 'seafile-password'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/seafile" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "url": "https://cloud.seafile.com/",
    "user": "user@example.com",
    "pass": "seafile-password"
  }'

`POST /api/v1/backends/zoho`

Connect a Zoho WorkDrive backend.

Request Body

Name	Type	Required	Default	Description
`auth_url`	string	No	`""`	Auth server URL (blank uses provider default)
`client_credentials`	boolean	No	`false`	Use OAuth2 client credentials flow
`client_id`	string	No	`""`	OAuth Client Id
`client_secret`	string	No	`""`	OAuth Client Secret
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"16875520"`	Backend encoding
`region`	string	No	`""`	Zoho region (`com`, `eu`, `in`, `jp`, `com.cn`, `com.au`)
`token`	string	No	`""`	OAuth Access Token as JSON blob
`token_url`	string	No	`""`	Token server URL (blank uses provider default)
`upload_cutoff`	string	No	`"10485760"`	Cutoff for large file upload API (min 10 MiB)

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "zoho-0b7d8e23",
    "type": "zoho",
    "backend_type": "zoho",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Zoho region mismatch"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectZoho({
  client_id: 'your-zoho-client-id',
  client_secret: 'your-zoho-client-secret',
  region: 'com'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/zoho" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "region": "com",
    "client_id": "your-zoho-client-id",
    "client_secret": "your-zoho-client-secret"
  }'

`POST /api/v1/backends/opendrive`

Connect an OpenDrive backend.

Request Body

Name	Type	Required	Default	Description
`chunk_size`	string	No	`"10485760"`	Chunk size for uploads (buffered in memory)
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"62007182"`	Backend encoding
`password`	string	Yes	`""`	OpenDrive password
`username`	string	Yes	`""`	OpenDrive username

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "opendrive-4f2a9e18",
    "type": "opendrive",
    "backend_type": "opendrive",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "OpenDrive credentials rejected"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectOpendrive({
  username: 'user@example.com',
  password: 'opendrive-password'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/opendrive" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "username": "user@example.com",
    "password": "opendrive-password"
  }'

`POST /api/v1/backends/box`

Connect a Box backend.

Request Body

Name	Type	Required	Default	Description
`access_token`	string	No	`""`	Box App Primary Access Token (leave blank normally)
`auth_url`	string	No	`""`	Auth server URL (blank uses provider default)
`box_config_file`	string	No	`""`	Path to Box App `config.json`
`box_sub_type`	string	No	`"user"`	Box sub-type (`user` or `enterprise`)
`client_credentials`	boolean	No	`false`	Use OAuth2 client credentials flow
`client_id`	string	No	`""`	OAuth Client Id
`client_secret`	string	No	`""`	OAuth Client Secret
`commit_retries`	integer	No	`100`	Max retries for committing a multipart file
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"52535298"`	Backend encoding
`impersonate`	string	No	`""`	Impersonate a user with a JWT service account
`list_chunk`	integer	No	`1000`	Listing chunk size 1-1000
`owned_by`	string	No	`""`	Only show items owned by this email
`root_folder_id`	string	No	`"0"`	Non-root folder to start from
`token`	string	No	`""`	OAuth Access Token as JSON blob
`token_url`	string	No	`""`	Token server URL (blank uses provider default)
`upload_cutoff`	string	No	`"52428800"`	Cutoff for multipart upload (min 50 MiB)

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "box-a5c81d92",
    "type": "box",
    "backend_type": "box",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Box JWT key not found"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectBox({
  box_sub_type: 'user',
  client_id: 'your-box-client-id',
  client_secret: 'your-box-client-secret'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/box" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "box_sub_type": "user",
    "client_id": "your-box-client-id",
    "client_secret": "your-box-client-secret"
  }'

`POST /api/v1/backends/fichier`

Connect a 1Fichier backend.

Request Body

Name	Type	Required	Default	Description
`api_key`	string	No	`""`	API key from 1fichier.com/console/params.pl
`cdn`	boolean	No	`false`	Use CDN download links
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"52666494"`	Backend encoding
`file_password`	string	No	`""`	Password for a shared file
`folder_password`	string	No	`""`	Password for a shared folder
`shared_folder`	string	No	`""`	Shared folder identifier

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "fichier-2e7b09f5",
    "type": "fichier",
    "backend_type": "fichier",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "1Fichier API key rejected"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectFichier({
  api_key: '1fichier-api-key',
  cdn: true
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/fichier" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "1fichier-api-key",
    "cdn": true
  }'

`POST /api/v1/backends/gofile`

Connect a Gofile backend.

Request Body

Name	Type	Required	Default	Description
`access_token`	string	No	`""`	API access token from the web control panel
`account_id`	string	No	`""`	Account ID (auto-filled by Hoody)
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"323331982"`	Backend encoding
`list_chunk`	integer	No	`1000`	Items per listing call
`root_folder_id`	string	No	`""`	Root folder ID (auto-filled by Hoody)

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "gofile-1b9c4f62",
    "type": "gofile",
    "backend_type": "gofile",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Gofile access token expired"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectGofile({
  access_token: 'gofile-access-token'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/gofile" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "access_token": "gofile-access-token"
  }'

`POST /api/v1/backends/linkbox`

Connect a Linkbox backend.

Request Body

Name	Type	Required	Default	Description
`description`	string	No	`""`	Description of the remote
`token`	string	Yes	`""`	Token from linkbox.to/admin/account

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "linkbox-5d82e1a7",
    "type": "linkbox",
    "backend_type": "linkbox",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Linkbox token missing or invalid"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectLinkbox({
  token: 'linkbox-account-token'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/linkbox" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "token": "linkbox-account-token"
  }'

`POST /api/v1/backends/pixeldrain`

Connect a Pixeldrain Filesystem backend.

Request Body

Name	Type	Required	Default	Description
`api_key`	string	No	`""`	API key from pixeldrain.com/user/api_keys
`api_url`	string	Yes	`"https://pixeldrain.com/api"`	Pixeldrain API endpoint
`description`	string	No	`""`	Description of the remote
`root_folder_id`	string	No	`"me"`	Root filesystem (`me` or a shared directory ID)

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "pixeldrain-3a08c4f1",
    "type": "pixeldrain",
    "backend_type": "pixeldrain",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Pixeldrain API key invalid"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectPixeldrain({
  api_url: 'https://pixeldrain.com/api',
  api_key: 'pixeldrain-api-key',
  root_folder_id: 'me'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/pixeldrain" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "api_url": "https://pixeldrain.com/api",
    "api_key": "pixeldrain-api-key"
  }'

`POST /api/v1/backends/pikpak`

Connect a PikPak backend.

Request Body

Name	Type	Required	Default	Description
`chunk_size`	string	No	`"5242880"`	Multipart upload chunk size
`description`	string	No	`""`	Description of the remote
`device_id`	string	No	`""`	Device ID used for authorization
`encoding`	string	No	`"56829838"`	Backend encoding
`hash_memory_limit`	string	No	`"10485760"`	Cache files larger than this on disk for hashing
`no_media_link`	boolean	No	`false`	Use original file links instead of media links
`pass`	string	Yes	`""`	PikPak password
`root_folder_id`	string	No	`""`	Root folder ID (blank uses default)
`trashed_only`	boolean	No	`false`	Only show trashed files
`upload_concurrency`	integer	No	`5`	Multipart upload concurrency
`use_trash`	boolean	No	`true`	Send files to trash instead of permanent delete
`user`	string	Yes	`""`	PikPak username
`user_agent`	string	No	`"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:129.0) Gecko/20100101 Firefox/129.0"`	HTTP user agent for PikPak

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "pikpak-6e2b1d4c",
    "type": "pikpak",
    "backend_type": "pikpak",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "PikPak captcha required"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectPikpak({
  user: 'user@example.com',
  pass: 'pikpak-password',
  upload_concurrency: 5
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/pikpak" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "user": "user@example.com",
    "pass": "pikpak-password"
  }'

`POST /api/v1/backends/premiumizeme`

Connect a premiumize.me backend.

Request Body

Name	Type	Required	Default	Description
`api_key`	string	No	`""`	API key (use OAuth instead if possible)
`auth_url`	string	No	`""`	Auth server URL (blank uses provider default)
`client_credentials`	boolean	No	`false`	Use OAuth2 client credentials flow
`client_id`	string	No	`""`	OAuth Client Id
`client_secret`	string	No	`""`	OAuth Client Secret
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"50438154"`	Backend encoding
`token`	string	No	`""`	OAuth Access Token as JSON blob
`token_url`	string	No	`""`	Token server URL (blank uses provider default)

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "premiumizeme-8a07f5c1",
    "type": "premiumizeme",
    "backend_type": "premiumizeme",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "premiumize.me API key rejected"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectPremiumizeme({
  client_id: 'your-premiumize-client-id',
  client_secret: 'your-premiumize-client-secret'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/premiumizeme" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "client_id": "your-premiumize-client-id",
    "client_secret": "your-premiumize-client-secret"
  }'

`POST /api/v1/backends/putio`

Connect a Put.io backend.

Request Body

Name	Type	Required	Default	Description
`auth_url`	string	No	`""`	Auth server URL (blank uses provider default)
`client_credentials`	boolean	No	`false`	Use OAuth2 client credentials flow
`client_id`	string	No	`""`	OAuth Client Id
`client_secret`	string	No	`""`	OAuth Client Secret
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"50438146"`	Backend encoding
`token`	string	No	`""`	OAuth Access Token as JSON blob
`token_url`	string	No	`""`	Token server URL (blank uses provider default)

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "putio-71d3a8e4",
    "type": "putio",
    "backend_type": "putio",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Put.io token rejected"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectPutio({
  client_id: 'your-putio-client-id',
  client_secret: 'your-putio-client-secret'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/putio" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "client_id": "your-putio-client-id",
    "client_secret": "your-putio-client-secret"
  }'

`POST /api/v1/backends/sugarsync`

Connect a Sugarsync backend.

Request Body

Name	Type	Required	Default	Description
`access_key_id`	string	No	`""`	Sugarsync Access Key ID (blank uses Hoody’s)
`app_id`	string	No	`""`	Sugarsync App ID (blank uses Hoody’s)
`authorization`	string	No	`""`	Sugarsync authorization (auto-configured by Hoody)
`authorization_expiry`	string	No	`""`	Authorization expiry (auto-configured by Hoody)
`deleted_id`	string	No	`""`	Sugarsync deleted folder id (auto-configured by Hoody)
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"50397186"`	Backend encoding
`hard_delete`	boolean	No	`false`	Permanently delete files instead of moving to deleted folder
`private_access_key`	string	No	`""`	Sugarsync Private Access Key (blank uses Hoody’s)
`refresh_token`	string	No	`""`	Sugarsync refresh token (auto-configured by Hoody)
`root_id`	string	No	`""`	Sugarsync root id (auto-configured by Hoody)
`user`	string	No	`""`	Sugarsync user (auto-configured by Hoody)

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "sugarsync-0a9d4e21",
    "type": "sugarsync",
    "backend_type": "sugarsync",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Sugarsync App ID rejected"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectSugarsync({
  access_key_id: 'your-sugarsync-access-key',
  private_access_key: 'your-sugarsync-private-key',
  app_id: 'your-sugarsync-app-id'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/sugarsync" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "access_key_id": "your-sugarsync-access-key",
    "private_access_key": "your-sugarsync-private-key",
    "app_id": "your-sugarsync-app-id"
  }'

`POST /api/v1/backends/uptobox`

Connect an Uptobox backend.

Request Body

Name	Type	Required	Default	Description
`access_token`	string	No	`""`	Uptobox access token from uptobox.com/my_account
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"50561070"`	Backend encoding
`private`	boolean	No	`false`	Make uploaded files private

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "uptobox-2c9b7f04",
    "type": "uptobox",
    "backend_type": "uptobox",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Uptobox access token rejected"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectUptobox({
  access_token: 'uptobox-access-token',
  private: false
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/uptobox" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "access_token": "uptobox-access-token"
  }'

`POST /api/v1/backends/ulozto`

Connect a Uloz.to backend.

Request Body

Name	Type	Required	Default	Description
`app_token`	string	No	`""`	Uloz.to app token (API key)
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"50438146"`	Backend encoding
`list_page_size`	integer	No	`500`	Listing page size (1-500)
`password`	string	No	`""`	Uloz.to user password
`root_folder_slug`	string	No	`""`	Root folder slug
`username`	string	No	`""`	Uloz.to username

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "ulozto-4d6c2f81",
    "type": "ulozto",
    "backend_type": "ulozto",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Uloz.to app token invalid"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectUlozto({
  username: 'user@uloz.to',
  password: 'ulozto-password',
  app_token: 'ulozto-app-token'
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/ulozto" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "username": "user@uloz.to",
    "password": "ulozto-password",
    "app_token": "ulozto-app-token"
  }'

Regional and other providers

`POST /api/v1/backends/jottacloud`

Connect a Jottacloud backend.

Request Body

Name	Type	Required	Default	Description
`auth_url`	string	No	`""`	Auth server URL (blank uses provider default)
`client_credentials`	boolean	No	`false`	Use OAuth2 client credentials flow
`client_id`	string	No	`""`	OAuth Client Id
`client_secret`	string	No	`""`	OAuth Client Secret
`description`	string	No	`""`	Description of the remote
`encoding`	string	No	`"50431886"`	Backend encoding
`hard_delete`	boolean	No	`false`	Permanently delete files instead of sending to trash
`md5_memory_limit`	string	No	`"10485760"`	Cache files larger than this on disk for MD5 calculation
`no_versions`	boolean	No	`false`	Avoid server-side versioning
`token`	string	No	`""`	OAuth Access Token as JSON blob
`token_url`	string	No	`""`	Token server URL (blank uses provider default)
`trashed_only`	boolean	No	`false`	Only show trashed files
`upload_resume_limit`	string	No	`"10485760"`	Files larger than this can resume a failed upload

Responses

{
  "success": true,
  "message": "Backend connected successfully",
  "data": {
    "id": "jottacloud-9e2f4b8a",
    "type": "jottacloud",
    "backend_type": "jottacloud",
    "mount_paths": []
  }
}

{
  "success": false,
  "error": "Jottacloud token rejected"
}

SDK Usage

TypeScript SDK
cURL

import { HoodyClient } from 'hoody-sdk';

const client = new HoodyClient({ baseURL: 'https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com', token: process.env.HOODY_TOKEN });

await client.files.backends.connectJottacloud({
  client_id: 'your-jottacloud-client-id',
  client_secret: 'your-jottacloud-client-secret',
  hard_delete: false
});

curl -X POST "https://{projectId}-{containerId}-files-1.{server}.containers.hoody.com/api/v1/backends/jottacloud" \
  -H "Authorization: Bearer <token>" \
  -H "Content-Type: application/json" \
  -d '{
    "client_id": "your-jottacloud-client-id",
    "client_secret": "your-jottacloud-client-secret"
  }'