Best Self-hosted Alternatives to SendSafely

SFTPGo is a full-featured, highly configurable managed file transfer (MFT) server that provides SFTP, FTPS, HTTPS, and WebDAV access to local and cloud storage. It includes web-based administration and a browser file client, plus automation via a REST API.

Key Features

• Multi-protocol server: SFTP, FTPS, HTTPS, and WebDAV for broad client compatibility
• Pluggable storage backends: local filesystem, encrypted local filesystem, S3-compatible object storage, Google Cloud Storage, Azure Blob Storage, and remote SFTP backends
• WebAdmin UI for managing users, groups, permissions, quotas, and virtual folders
• WebClient for browser-based file browsing, uploads, and downloads
• Secure sharing via time-limited HTTPS links with optional passwords and download limits
• Security controls including granular permissions, audit logs, and data-at-rest encryption
• Authentication options including OpenID Connect (SSO) and built-in two-factor authentication
• Event-driven architecture with automation and integration via REST API

Use Cases

• Replace legacy file transfer servers while using modern object storage as the backend
• Provide secure partner file exchange with per-user isolation, quotas, and auditing
• Offer browser-based file access and controlled public sharing without external clients

SFTPGo is well suited for organizations that need a secure file transfer gateway with modern storage backends, strong administration tooling, and API-driven automation while keeping compatibility with standard protocols.

OnionShare is an open-source application that enables secure, anonymous file transfers, temporary website hosting, and private chat by running services as Tor onion services. It provides both a desktop GUI and a command-line tool plus mobile clients developed with partner projects.

Key Features

• Share files via an ephemeral Tor onion service with one-time or time-limited access.
• Host a static website over an onion address for private, temporary publishing.
• Private chat mode that runs as an onion-hosted web chat session.
• Desktop GUI and CLI interfaces; platform packaging for Windows, macOS, and Linux (Flatpak/Snap).
• Mobile clients developed in collaboration with partner projects for Android and iOS.
• Integrates with the Tor control interface and uses Tor-related libraries and tooling for onion services.

Use Cases

• Send large files privately between two people without relying on third-party cloud storage.
• Publish an internal or temporary static website to a small, private audience via an onion address.
• Run an ephemeral, private chat session reachable only by users with the onion URL.

Limitations and Considerations

• Performance and responsiveness are constrained by the Tor network (latency and throughput) and are not comparable to clearnet transfers.
• Packaging and dependency constraints have affected some platforms (for example, ARM/armhf packaging challenges related to Qt/PySide availability).
• The project uses Python web components where upstream changes can require maintenance (e.g., noted framework deprecations/warnings).

OnionShare is a mature, actively maintained open-source project focused on privacy-preserving file sharing and short-lived hosting using Tor. It is well-suited for users who need ad-hoc private exchanges without using centralized services, while accepting Tor-related performance and packaging trade-offs.

PicoShare is a minimalist, open-source service for uploading and sharing files. It provides direct download links for uploaded files, preserves original filenames and metadata, and avoids re-encoding or resizing media.

Key Features

• Direct download links for uploaded files, with no ads or required signups for recipients
• Supports arbitrary file types and sizes; no automatic re-encoding or resizing of media
• Simple admin interface protected by a shared secret for managing uploads and links
• Multiple deployment options: run from source or run an official container image
• Optional data replication support using a WAL-based replication tool for cloud backups
• Uses an embedded SQL database for file metadata and storage index to minimize operational complexity

Use Cases

• Quick one-off file sharing between collaborators without creating accounts
• Private media distribution where original file fidelity must be preserved (images, audio, video)
• Lightweight internal file drop service for small teams or personal servers

Limitations and Considerations

• Not designed for multi-writer clustered deployments: concurrent writes across multiple instances are not synchronized
• Maintained as a hobby/open-source project; scope is intentionally limited and some feature requests may be declined due to maintainer bandwidth
• For large-scale or enterprise use, additional monitoring, backup planning, and storage provisioning will be required

PicoShare is best suited where a simple, privacy-conscious, and low-overhead file sharing service is needed. It is straightforward to deploy and integrates into standard container-based workflows for small-scale production or personal use.

Gokapi is a lightweight, self-hosted file sharing server designed for sharing files via expiring download links. It focuses on controlled uploads (no public upload) and supports encryption and optional S3-compatible storage for flexible deployments.

Key Features

• Expiring file shares based on time and/or number of downloads
• User management with role-based permissions; only registered users can upload
• Built-in encryption support, including end-to-end encrypted uploads
• File deduplication to reduce storage usage for identical uploads
• Optional storage backend support for AWS S3 and S3-compatible providers
• OpenID Connect (OIDC) authentication integration for SSO
• REST API for automation and integration
• Customizable web UI via custom CSS and JavaScript

Use Cases

• Secure one-off file delivery with automatic link and file expiration
• Internal team file drop for controlled sharing without public uploads
• Automated file distribution workflows using the REST API

Limitations and Considerations

• Designed for simple file sharing rather than full sync/collaboration (not a cloud drive)
• Some advanced features (S3 backends, SSO) require additional configuration

Gokapi is a strong choice when you need an easy-to-run, privacy-focused file sharing service with expiring links and modern authentication options. Its lightweight Go-based implementation and optional S3 storage make it suitable for both homelabs and small teams.

Yopass is an open-source service for securely sharing sensitive information. It encrypts secrets client-side using OpenPGP, stores only ciphertext on the server, and returns a one-time expiring URL to the sender.

Key Features

• Client-side end-to-end encryption using OpenPGP; server never receives plaintext or the decryption key.
• One-time or time-limited access: secrets can be configured to self-destruct after first view or after a set expiry.
• Small web UI plus a command-line client for automation and scripting use cases.
• Configurable storage backends: supports Memcached or Redis for ephemeral secret storage.
• Optional limited file upload support (files are encrypted before upload and can be disabled).
• Deployment ready: includes Docker/Compose and Kubernetes examples, plus reverse-proxy guidance for TLS and proxy trust configuration.

Use Cases

• Sharing short-lived credentials or secrets (passwords, API keys) between teammates without exposing plaintext in chat or tickets.
• Exchanging program output or sensitive configuration from automation scripts via the CLI.
• Sending single-use tokens or files that must not persist on the server once consumed.

Limitations and Considerations

• File upload functionality is limited; large-file workflows are not the primary focus and may require external tools.
• Default deployments do not enforce rate limiting; administrators should add rate limiting or WAF rules if exposed publicly.
• URLs containing the decryption key can be stored in browser history or logs; post-access cleanup and secure channels for delivering the URL are recommended.
• Security depends on correct TLS/reverse-proxy configuration and on administrators keeping dependencies and the server up to date.

Yopass is designed to be small, transparent, and security-focused: it minimizes server-side knowledge of secrets while providing simple UX and automation interfaces. It is useful for teams and automation that need quick, ephemeral secret sharing without accounts or long-term storage.

Palmr. is an open-source file sharing and transfer platform designed as a self-hosted alternative to services like WeTransfer. It focuses on privacy and security, providing a web interface and API to upload, manage, and share files without tracking.

Key Features

• Upload, manage, and share files via a modern web interface
• Share links with access control features such as password protection
• Custom share links for easier distribution
• Folder organization to group and share content
• User management and account features (including password recovery)
• Storage options including local filesystem storage and optional S3-compatible object storage
• Lightweight setup using SQLite for metadata storage

Use Cases

• Securely share large files with clients or teammates using password-protected links
• Replace third-party file transfer services for internal or privacy-sensitive workflows
• Provide a simple upload portal to receive files from external users

Limitations and Considerations

• The project is labeled as beta and is not recommended for production environments yet

Palmr. is a practical choice for teams and individuals who want full control over file transfers, with straightforward deployment and optional scalable storage when needed.

Pydio Cells is a self-hosted, enterprise-grade content collaboration platform designed for organizations that need secure file sharing, collaboration, and document management without relying on SaaS services.

Key Features

• Self-hosted deployment with data control and hybrid cloud readiness
• High-performance large file transfers up to 5TB
• No-code automation via Cells Flows for complex workflows
• Granular access control, SSO, 2FA, and ACL-based permissions
• Digital Asset Management and Document Management capabilities
• Web-based collaboration with an integrated UI and REST/CLI APIs
• Private data rooms for sensitive transactions and audits

Use Cases

• Enterprises requiring on-prem data sovereignty and regulated access controls
• Organizations consolidating document workflows across departments and partners
• Private-cloud deployments replacing SaaS with centralized governance

Limitations and Considerations

• Windows support in the latest development branch is not fully mature; Linux/macOS are the recommended targets

Conclusion

Pydio Cells combines self-hosted control with scalable collaboration features, making it suitable for organizations needing secure document sharing, workflow automation, and governance.

Enclosed is a minimalistic web application for sending private notes and file attachments using end-to-end encryption. Notes are encrypted in the browser so the server stores only ciphertext and cannot read the content.

Key Features

• Client-side end-to-end encryption with AES-GCM and keys derived via PBKDF2
• Zero-knowledge storage: server only receives encrypted payloads plus limited metadata
• Optional password protection in addition to the secure link key
• Expiration (TTL) and delete-after-reading (self-destruct) options
• Secure file attachments alongside notes
• Optional email/password authentication for creating notes
• Responsive minimal UI with dark mode and internationalization
• CLI for creating and viewing notes from the terminal

Use Cases

• Securely share credentials, recovery codes, or sensitive snippets with expiring links
• Send confidential one-time notes to teammates or clients
• Share private files quickly without giving the server access to contents

Limitations and Considerations

• Losing the note link (and password, if set) makes the content unrecoverable by design
• The service stores metadata such as TTL and whether a note is password-protected

Enclosed is well-suited for teams or individuals who need quick, secure, ephemeral sharing with a simple interface. Its zero-knowledge design and optional self-destruct controls help reduce exposure when exchanging sensitive information.

ProjectSend is a clients-oriented file sharing web application designed for securely distributing and collecting files through a simple portal. It focuses on privacy and control, with client accounts, access restrictions, and detailed activity tracking.

Key Features

• Client accounts and client groups for targeted file delivery
• Role-based permissions with granular access controls and custom roles
• Detailed logging and statistics for user/client actions and file access
• Optional server-side file encryption at rest (AES-256-GCM)
• Upload controls such as auto-expiration, disk quotas, and download limits
• Optional client uploads to allow two-way file exchange
• External storage support including S3-compatible destinations
• Multi-language interface with extensive community translations
• Theming and customizable email templates (with editor integration)

Use Cases

• Securely sharing project deliverables and documents with external clients
• Collecting files from customers with controlled access and audit trails
• Replacing ad-hoc email attachments with an organized client portal

Limitations and Considerations

• Requires a PHP-compatible web server and a MySQL database
• Some deployment options (such as community Docker images) may be unofficial and differ from the upstream support model

ProjectSend is a practical choice for teams that need a straightforward, self-managed client file portal with strong permissioning and traceability. It fits well for small businesses and agencies that want controlled file exchange without relying on third-party file sharing services.

Plik is a scalable temporary file upload and sharing service, similar to WeTransfer, designed for quick uploads and controlled file distribution. It provides a web interface, a command-line client, and an HTTP API, with flexible storage and metadata backends.

Key Features

• Web UI for uploading and sharing files
• Cross-platform CLI client for scripted and terminal-based uploads
• HTTP API for managing uploads and downloading files
• Multiple data backends (local filesystem, S3-compatible object storage, OpenStack Swift, Google Cloud Storage)
• Multiple metadata backends (SQLite, PostgreSQL, MySQL)
• Expiration controls (custom TTL), OneShot downloads, streaming mode, and uploader-controlled removal
• Optional protection features such as Basic Auth, upload tokens, and source IP restrictions
• Admin CLI and admin web UI for user and upload management

Use Cases

• Share large files with time-limited download links
• Provide a simple internal “drop” service for teams and automation scripts
• Create controlled one-time or stream-only transfers for sensitive handoffs

Limitations and Considerations

• Security headers may prevent browser rendering of certain content (for example PDF/audio/video) unless adjusted in configuration
• Built-in third-party authentication options depend on external providers (for example Google)

Plik fits well for organizations that need a lightweight, self-managed file sharing portal with strong operational flexibility. Its combination of UI, CLI, and API makes it suitable for both end users and automated workflows.

Sharry is a self-hosted web application that provides simple, privacy-conscious file sharing. It offers both send and receive workflows, resumable uploads, and a web client plus a REST API for automation and integration.

Key Features

• Resumable uploads implemented via the tus protocol, enabling reliable large-file uploads and resume after network interruptions.
• Bidirectional workflows: authenticated users can publish download links; anonymous users can upload to user-managed alias pages.
• Multiple storage backends: supports storing files on the filesystem, inside the database, or in S3-compatible object storage.
• Relational database support for metadata and optional file storage: PostgreSQL, MariaDB, and H2 are supported.
• Download-friendly behavior using ETag and HTTP range requests to enable partial downloads and in-browser video seeking.
• REST API exposing core functionality for scripting and integration with other systems.
• Access controls for public shares: configurable lifetime, optional password protection, and download limits.
• Web-based management UI and email notification capabilities when configured.
• Packaging and deployment options including Debian packages, Docker, and Nix/NixOS integrations.

Use Cases

• Team file exchange: share large artifacts, logs, or media with coworkers via short-lived, password-protected links.
• External collection: allow customers or partners to upload files to a named alias page without requiring accounts.
• Automated workflows: integrate Sharry into CI, backup, or content pipelines using the REST API and supported storage backends.

Sharry combines a resilient upload stack with multiple storage and database options to fit varied infrastructure needs. Its focus is on straightforward file exchange, resumability, and integration points for automation and self-hosted deployments.

Erugo is a self-hosted, open-source file-sharing platform that provides a simple web interface for sending and managing files. It combines a Laravel-based backend with a Vue.js frontend and is designed for easy Docker deployment and minimal system requirements.

Key Features

• Multiple-file and folder uploads with progress tracking and large-file resume support
• Human-friendly, memorable share URLs (readable slugs instead of opaque tokens)
• Password protection, expiration dates, and configurable download limits per share
• Built-in dashboard to track downloads, manage shares, revoke access, and view activity
• Customizable branding and theme support for logos, colors, and appearance
• Docker-first deployment with example docker-compose configuration and an included lightweight default database option

Use Cases

• Securely transfer design assets, large media files, or project bundles between teams without third-party services
• Temporary file drops for clients or collaborators with password and expiration controls
• Self-hosted alternative to consumer file-transfer sites where data sovereignty and auditability are required

Limitations and Considerations

• The public demo instance has uploads disabled (demo only shows recipient/download view); full functionality requires running your own instance
• Administrators are responsible for configuring storage limits, moderation, security, and compliance for their deployment

Erugo is intended for organisations and individuals who prefer self-hosted file sharing with control over data and customization. It is open-source (MIT) and designed to run on modest resources while scaling up for larger deployments.

GoMFT is a web-based managed file transfer (MFT) application built with Go and powered by rclone to move data between many storage providers. It provides a central UI to configure transfer jobs, schedule them, and monitor progress with logs and file-level history.

Key Features

• Create and manage transfer jobs with configurable source/destination settings
• Cron-based scheduling for recurring transfers
• Real-time job monitoring with detailed logs and transfer statistics
• Broad storage backend support via rclone (S3-compatible, WebDAV, SFTP/FTP, SMB/CIFS, local, and more)
• File metadata tracking with history, status, filtering, and retention controls
• Optional archiving of transferred files for compliance/traceability
• Notifications via email and webhooks, plus integrations such as ntfy and Gotify
• Role-based access control and admin-managed user accounts
• Supports external authentication via OpenID Connect/OAuth2 providers

Use Cases

• Scheduled syncs and backups between on-prem storage and cloud object storage
• Managed, auditable file delivery workflows between teams and systems
• Consolidated transfer monitoring and alerting for rclone-based operations

Limitations and Considerations

• Actively under development; configuration and database fields may change between releases
• Requires rclone to be installed and available for transfer execution

GoMFT fits teams that want a lightweight web UI around rclone for repeatable, scheduled transfers with visibility and notifications. It is suitable for both homelabs and small-to-medium environments needing basic MFT capabilities without heavy enterprise infrastructure.

QuickDrop is a self-hosted file sharing application that enables anonymous uploads with chunked transfers, configurable lifetimes, and per-file access controls. It provides an admin dashboard for managing storage, cleanup schedules, notifications, and privacy settings.

Key Features

• Anonymous uploads with chunked transfer support for reliable large-file uploads
• Folder uploads with preserved structure and manifest handling
• Per-file controls: passwords, hidden (link-only) files, keep indefinitely, and visibility toggles
• Token-based share links with expiration dates and download limits; QR code generation for links
• Optional encryption at rest for stored files and server-side session tokens for access control
• Built-in previews for images and text, plus extended previews for PDF/CSV/JSON with syntax highlighting
• Admin single-page UI for file list/history, search, pagination, extend/delete actions, and runtime settings
• Notifications via SMTP and Discord webhooks with batching and test actions
• Scheduled cleanup tasks for expired files, tokens, and DB maintenance

Use Cases

• Share large files temporarily without requiring user accounts for ad-hoc transfers
• Host a private file-drop service for teams to collect uploads with optional password protection and expiries
• Maintain a small-scale public file sharing endpoint with admin-managed retention and audit logging

Limitations and Considerations

• Default deployment uses SQLite which is convenient for small or single-node setups but can limit concurrency and horizontal scaling
• Designed primarily as a single-instance service; no built-in clustering or object-storage integration by default

QuickDrop is focused on simple, privacy-minded file sharing with granular per-file controls and an easy admin experience. It is well suited for small teams, labs, or personal self-hosted environments that need temporary file exchange and retention policies.

FerriShare is an open-source, self-hostable filesharing application that encrypts files and filenames in the user's browser before they are uploaded. The decryption key is embedded in the download-link fragment so the server never receives it, and the project provides a minimal, accessible frontend plus a Rust backend for metadata and administration.

Key Features

• Client-side encryption (AES-GCM) performed in the browser using the WebCrypto API; filenames and file contents are encrypted before upload.
• Decryption key stored in the download-link fragment so the server cannot decrypt stored files.
• Expiring uploads with configurable durations (examples: 1 hour, 1 day, 1 week).
• Two links returned to uploaders: a public download link and a private administration link with download statistics and early-delete capability.
• Built-in IP-based rate limiting with dual-stack handling (full IPv4 or /64 IPv6 subnet) and configurable request/upload limits.
• Configurable maximum filesize and storage quota controls.
• Password-protected site-wide administration panel for usage stats and manual deletion.
• Lightweight, memory-safe backend written in Rust with server-side templating; frontend uses minimal JavaScript only where required (encryption/upload pages).
• SQLite used for metadata so the application can run in a single container; prebuilt multi-architecture Docker images are provided for common platforms.
• Accessible frontend optimized for performance and best practices; Tailwind-based styling and server-rendered templates reduce client JS needs.

Use Cases

• Securely send files to external recipients without exposing plaintext to the server or storage host.
• Provide a temporary, privacy-preserving file drop for teams or communities with automatic expiry and admin controls.
• Host a small public or internal file-sharing endpoint that enforces quotas and rate limits to reduce abuse.

Limitations and Considerations

• The project author notes the cryptographic implementation has not been independently audited; users should review the code and exercise caution before storing highly sensitive data.
• The WebCrypto API imposes practical limits (e.g., browser-imposed maximum single-message size) that restrict maximum upload sizes; FerriShare enforces a configurable max filesize accordingly.
• FerriShare must be served via HTTPS (or run on localhost) and is intended to run behind a reverse proxy for TLS termination; proper TLS/reverse-proxy configuration is required for secure deployment.

FerriShare is suitable for users who need a simple, privacy-oriented file sharing service they can run themselves. It emphasizes browser-side encryption, straightforward deployment (Docker + single SQLite DB), and configurable limits to balance usability with operational safety.

015 is a self-hosted temporary file and text sharing platform designed for one-time and short-lived uploads. It combines a modern Vue/Nuxt frontend with a Go backend and supports chunked uploads, frontend file-hash detection for instant transfer, and background processing for file tasks.

Key Features

• Chunked, high-performance uploads with frontend hashing and instant-transfer detection to avoid duplicate uploads
• Concurrent processing using frontend web workers and a backend worker queue for asynchronous tasks
• Image processing including automatic compression and preview support for images, video, audio, and documents
• Share management with configurable password protection, download count limits, expiration times, and pickup codes
• Download access control using JWT-based tokens and Redis for caching share metadata
• Responsive UI built with Vue 3, Nuxt 3, TypeScript and Tailwind CSS; backend written in Go with an Asynq-based worker system

Use Cases

• Quickly share large files or snippets as one-time or temporary links with expiration and access limits
• Public or private file drops with password or pickup-code protection for ad-hoc collaboration
• Automatic image compression and preview for sending media without manual processing

Limitations and Considerations

• Default storage uses the local filesystem; cloud object storage adapters are not provided out of the box
• Resume-upload behavior has partial support; backend-side resumed-part enumeration is listed as a planned improvement

015 is suitable for teams and individuals needing ephemeral, controlled file sharing without a third‑party service. It emphasizes fast uploads, access controls, and simple lifecycle management for temporary content.

YeetFile is a privacy-focused file sending service and personal vault that encrypts content client-side so the server cannot decrypt stored or transferred data. It provides both a web UI and a CLI client, and is designed for easy self-hosting with Docker and standard infrastructure components.

Key Features

• Client-side end-to-end encryption for files and text so servers cannot decrypt content
• "Send" mode: create shareable links with configurable expiration and limited download counts
• "Vault" mode: file and password storage, folder organization, and per-user read/write sharing
• Optional password protection on shared links and text transfers (text up to 2000 characters)
• Multiple storage backends supported: local filesystem, S3-compatible object stores, and Backblaze B2
• Official CLI with parity to web client and a browser-based web UI
• Deployable via docker-compose or systemd; requires PostgreSQL for metadata
• Admin features for instance management, user administration, and logging suggestions

Use Cases

• Securely send sensitive files or one-off secrets with expiring, limited-download links
• Host a personal/team vault for encrypted file and password storage with folder-level sharing
• Run a privacy-preserving file transfer service for an organization that must retain control of storage

Limitations and Considerations

• Send transfers have configurable limits: maximum expiration is 30 days and maximum downloads per link is 10
• Server-side metadata (file size, owner ID, timestamps) is visible even though file contents and filenames are encrypted
• Some features (paid upgrades, payment recycling) rely on external payment providers and require additional configuration

YeetFile is well suited for users and teams that need a self-hosted, privacy-first file transfer and vault solution. It emphasizes strong client-side encryption and flexible deployment, while requiring a PostgreSQL database and standard container tooling for production deployments.

goploader is a lightweight project providing a Go-based server and command-line client to share files from the terminal or via curl-compatible tools. Files are streamed and encrypted server-side so the server never retains the decryption key.

Key Features

• Server and CLI client implemented in Go with a minimal footprint
• Server-side AES encryption performed while streaming uploads to disk
• Encryption key generated per upload and never persisted on the server
• Curl/httpie/wget compatible multipart upload API and stdin support for piping
• Simple metadata stored in an embedded key/value datastore (BoltDB)
• Designed for HTTPS deployments; commonly run behind Caddy with automatic certificates
• Small, scriptable client binary (gpldr) for terminal workflows
• Files are streamed to avoid buffering entire uploads in RAM

Use Cases

• Securely share files from the terminal or within shell scripts and CI pipelines
• Provide short-lived encrypted file links to collaborators without storing keys on server
• Build lightweight, privacy-oriented file drop services for teams or personal use

Limitations and Considerations

• Project is maintained as-is and some dependencies and approaches are dated; review before production use
• Uses an embedded BoltDB datastore which may require migration for heavy workloads or long-term maintenance
• No built-in user accounts, ACLs, or advanced access controls; link-based access only
• The default deployment relies on external HTTPS configuration (e.g., Caddy); secure deployment requires proper TLS setup
• The server may log uploader IPs depending on configuration; encryption keys are not retained

goploader is a pragmatic tool for terminal-first, privacy-focused file sharing, prioritizing streamed encryption and simplicity. It is suitable for personal or small-team use where short-lived encrypted links and scriptability are more important than advanced access control or enterprise features.

Lufin is a modern self-hosted file-sharing service that provides secure, temporary file sharing with rich client-side features. It offers optional end-to-end encryption, flexible storage backends, and a static frontend optimized for performance.

Key Features

• Optional client-side end-to-end encryption (AES-GCM) with zero-knowledge design
• Support for S3-compatible storage (MinIO, Cloudflare R2) and multiple databases (PostgreSQL, MongoDB, SQLite)
• Rich client-side previews for images, audio, video, PDFs, spreadsheets and archives
• Password protection, delete-after-first-download, and configurable retention rules
• Client-side utilities: EXIF metadata stripping, image compression, archive generation, and automatic renaming
• Fully static frontend built with React and Vite; backend is lightweight and deployable via Docker Compose with automatic HTTPS
• LocalStorage-based link management with import/export and cleanup of expired pages

Use Cases

• Share large files securely between team members or external collaborators with optional password protection
• Temporary public file hosting for event assets, press kits, or media previews with automatic expiration
• Integrate with S3/MinIO object storage for scalable hosting while keeping encryption and access controls on the client side

Limitations and Considerations

• Client-side end-to-end encryption requires JavaScript and will limit server-side processing or embedding unless users opt out of encryption
• Scalability and performance depend on chosen storage backend and database configuration; plan resources accordingly

Lufin is suitable for teams and self-hosting enthusiasts who need a privacy-focused, feature-rich file-sharing platform that integrates with S3-compatible storage and common databases. It emphasizes client-side privacy controls and a lightweight deployment model.

Send is a self-hostable file sharing service designed for sending files securely via shareable links. It encrypts files client-side so the server stores only encrypted data, and supports link expiration and download limits to reduce data exposure.

Key Features

• Client-side encryption for end-to-end encrypted file transfers
• Shareable links with configurable expiration time
• Download limits to automatically invalidate links after a set number of downloads
• Optional password protection for shared files
• Simple web interface focused on quick uploads and sharing

Use Cases

• Securely sharing sensitive documents with time-limited access
• Sending large files without giving recipients permanent storage access
• Temporary file exchange for teams or external collaborators

Limitations and Considerations

• Browser-based encryption means very large files may be constrained by client memory and device performance
• Requires JavaScript in the client for encryption and upload workflows

Send is well-suited for organizations and individuals who want a straightforward, privacy-focused alternative to traditional file sharing. It emphasizes minimizing server-side trust while keeping the sharing workflow simple and fast.