Best Self-hosted Alternatives to DocSend

Papermark is an open-source document sharing platform and virtual data room alternative to DocSend. It lets teams upload documents, share them via secure links, and track engagement with built-in analytics and branding controls.

Key Features

• Secure shareable document links with revocation and access controls
• Custom domains and branding for viewer experience
• Document tracking and engagement analytics (including page-by-page insights)
• Data room-style organization for sharing multiple documents
• Authentication features such as 2FA and SSO (availability depends on deployment/plan)

Use Cases

• Sales and partnerships: share decks and proposals and measure engagement
• Fundraising and investor relations: run a data room with controlled access
• Secure client document delivery with branded links and audit-friendly tracking

Limitations and Considerations

• Some analytics and integrations may rely on third-party services depending on configuration
• Requires external object/blob storage and a PostgreSQL database for typical deployments

Papermark is a strong fit for teams that want DocSend-style sharing with more control over hosting, branding, and data. It combines link-based document delivery with practical analytics for understanding how recipients engage with shared files.

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.

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.

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.

Cryptgeon is a secure note and file sharing service inspired by PrivNote. Notes are encrypted in the browser before upload, so the server stores only ciphertext and cannot decrypt the content.

Key Features

• Client-side encryption using AES-GCM; encryption keys are not sent to the server
• Share both text notes and files
• Expiration controls via maximum views and time-based expiry
• In-memory storage with Redis, designed to avoid disk persistence
• Web UI plus a CLI client for creating and sharing secrets
• Health endpoint for basic service monitoring

Use Cases

• Share one-time secrets (passwords, tokens) with a view limit
• Send sensitive notes with an expiration time for temporary access
• Share files securely without the server being able to read them

Limitations and Considerations

• View-count enforcement can be imperfect in multi-instance deployments due to race conditions
• HTTPS is required for browser cryptography features
• In-memory storage means data can be evicted depending on Redis memory policies

Cryptgeon is a practical option for teams and individuals who need simple, temporary secret sharing with strong privacy properties. Its minimal server trust model and expiring links make it well-suited for operational workflows and ad-hoc secure exchanges.

Hemmelig is an encrypted secret-sharing service designed to keep sensitive information out of chat logs and email threads. It uses a zero-knowledge approach where encryption happens in the browser, and the server only stores encrypted data.

Key Features

• Client-side AES-256-GCM encryption (zero-knowledge storage)
• Self-destructing secrets with configurable expiration and view limits
• Optional password protection for an additional security layer
• IP restrictions to limit access to specific IP ranges
• Encrypted file uploads for authenticated users
• Rich text editor for formatting secrets
• QR codes for easier sharing on mobile devices
• Webhook notifications for secret viewed/burned events
• REST API with OpenAPI specification, plus CLI for automation

Use Cases

• Securely sharing one-time credentials, API keys, and recovery codes
• Exchanging sensitive notes or documents with expiring access
• Automating secret creation and sharing in CI/CD pipelines via CLI/API

Limitations and Considerations

• The license is a modified MIT-style license that restricts offering the software as a competing hosted SaaS

Hemmelig is a practical alternative to sending secrets through persistent channels, combining strong client-side cryptography with expiration controls. It fits well for teams and individuals who need simple, auditable secret handoff workflows with optional automation.

OTS is a one-time secret sharing platform designed to keep the server from learning the plaintext. Secrets are encrypted client-side using symmetric AES-256, then stored server-side only in encrypted form and deleted after the first successful read.

Key Features

• Client-side AES-256 encryption; the decryption password is never sent to the server
• Secrets are deleted immediately after the first read
• Optional secret expiry (TTL) configuration
• Multiple storage backends, including in-memory and Redis
• Simple HTTP API for creating secrets and retrieving them
• Optional CLI tool for creating and fetching secrets (useful for scripts)

Use Cases

• Sharing passwords, tokens, or recovery codes securely with a single recipient
• Sending sensitive information via chat/email without long-lived exposure
• Automation and scripting workflows to distribute short-lived secrets

Limitations and Considerations

• In-memory storage backend loses secrets on service restart
• Security relies on clients handling the generated URL (containing secret ID and password in the fragment) safely

OTS provides a minimal, practical workflow for one-time sharing while reducing trust in the server by keeping encryption and decryption on the client. It is well-suited for teams and homelabs that need a lightweight, self-hosted alternative for sharing sensitive strings and small payloads.

Pastefy is an open-source, self-hostable Pastebin-style application for sharing and storing code snippets, text files, and lightweight media previews. It provides a web UI and a RESTful API for creating, forking, organizing and retrieving pastes.

Key Features

• Web UI built with Vue and a Java-based backend for creating, forking and managing pastes
• REST API for programmatic paste creation, retrieval and client integrations
• OAuth2 login providers support (multiple providers and custom OIDC configuration)
• Folder and user paste management with admin panel for site administration
• Raw preview, copy button, syntax-aware previews for Markdown, Mermaid, SVG, CSV, GeoJSON, diffs and asciinema recordings
• File upload support and curl-compatible upload endpoint
• Extensions and client libraries (Java, Go, JavaScript/TypeScript) and editor integrations

Use Cases

• Quickly share code snippets, config files or logs with teammates or public audiences
• Store and replay terminal recordings or structured data (asciinema, GeoJSON, CSV) for troubleshooting and demos
• Integrate paste creation into developer tools, CI scripts or editor extensions via the REST API

Limitations and Considerations

• Backend is JVM-based and typically deployed with Maven/Java; requires a Java runtime and a relational database (MySQL commonly used)
• Admin role assignment may require direct database changes for initial setup as noted in administration instructions
• Authentication is primarily OAuth/OIDC based; enterprise directory integrations beyond OAuth may require custom configuration

Pastefy is suitable for teams and individuals who need a lightweight, extensible paste service with API access and rich previews. It balances a modern web frontend with a Java backend and supports common deployment patterns including Docker and Docker Compose.

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.

Flare is a modern file sharing platform designed for self-hosted deployments. It provides fast uploads, universal previewing, and first-class integrations with popular screenshot tools to streamline sharing workflows.

Key Features

• Universal screenshot integration with ShareX, Flameshot, KDE Spectacle and script upload support
• Role-based permissions, private files, and password protection for access control
• Flexible storage backends: local filesystem and S3-compatible object storage
• Universal preview for images, videos, PDFs and code with syntax highlighting
• Smart search supporting filename and OCR-extracted text, with date filters
• Built-in admin dashboard for usage metrics, user management and system settings
• URL shortener with custom short URLs and click tracking
• Pastebin-style code/text sharing with syntax highlighting
• Theme customization, custom CSS/HTML injection, and configurable user quotas
• OCR processing to extract text from uploaded images

Use Cases

• Team or personal screenshot and file sharing server integrated with desktop tools
• Hosting quick pastes, code snippets and media previews for internal collaboration
• Private short-link service with tracking and role-based access for controlled sharing

Limitations and Considerations

• Requires a PostgreSQL database as the supported relational backend
• OCR processing and rich previews may increase resource usage and require additional runtime resources
• Storage backends are local filesystem or S3-compatible; advanced CDN or multi-backend orchestration is not provided out of the box

Flare provides a polished, performant experience for self-hosted file sharing with tight screenshot-tool integrations and administrative controls. It is well suited for individuals and teams that need private, searchable file and paste hosting with flexible storage options.

not-th.re is a lightweight paste and file sharing platform focused on simplicity and client-side encryption. It provides a modern editor experience and tools to host a private instance or use the public UI.

Key Features

• Client-side end-to-end encryption: data is encrypted in the browser before being sent to the server
• Monaco-based editor with syntax highlighting and dark mode
• Simple paste sharing and encrypted file transfers
• CLI and SDK to upload, download, encrypt, decrypt and query notes programmatically
• Can run as a minimal API-only service or as a full stack (API + UI) via Docker images
• Integration with Excalidraw for drawings and planned features like peer-to-peer sessions and note bundles
• No tracking, no cookies, and no ads by design

Use Cases

• Securely share code snippets or notes that remain encrypted until opened by recipients
• Transfer and store small encrypted files between collaborators without third-party storage
• Integrate paste and secret-sharing into automation or developer tooling using the CLI/SDK

Limitations and Considerations

• No built-in user accounts or server-side key recovery; if encryption keys are lost, data cannot be recovered
• Micro deployment mode does not include a hosted UI; it requires either the public UI or hosting the UI separately
• Intended for short-lived pastes and small file transfers rather than large-scale file storage or full collaboration suites

not-th.re is best suited for users and teams that need a minimal, privacy-first paste and file sharing tool with client-side encryption and programmatic access. It is easy to deploy with Docker and offers a CLI and SDK for automation and integration.

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.

Jirafeau is a lightweight, self-hosted web application for uploading and sharing files via unique links. It focuses on simplicity and privacy-friendly sharing, with minimal external dependencies and straightforward administration.

Key Features

• Upload files through a simple web interface and share them via generated links
• Optional one-time download links to reduce unintended redistribution
• Expiration controls (time-based and/or download-count based, depending on configuration)
• Optional password protection for shared files
• Basic administration features such as managing uploads and storage settings
• Designed to run with common web stacks without requiring a database

Use Cases

• Share large files with colleagues or clients without using third-party services
• Provide one-off delivery links for sensitive documents
• Run a small internal “dropbox-style” upload portal for a team or organization

Limitations and Considerations

• Feature set is intentionally minimal compared to full sync-and-share platforms
• Storage and retention behavior depends on server configuration and available disk space

Jirafeau is a good fit when you need a small, dependable file-sharing tool that is easy to deploy and operate. Its link-based model and optional one-time downloads make it particularly useful for controlled, temporary file delivery.