MicroBin

Self-hosted file sharing and text pasting, honestly reviewed. No marketing copy, just what you get when you run it yourself.

TL;DR

• What it is: A self-hosted paste bin and file sharing tool written in Rust — text snippets, file uploads, URL shortening, and E2E encryption packed into a single executable [README].
• Who it’s for: Developers who paste config files and error traces, remote teams bumping into Slack/Discord file size limits, and privacy-conscious individuals who need to share a password without routing it through someone else’s server [website].
• Cost savings: Pastebin.com’s paid tiers lock basic features behind subscriptions. WeTransfer’s free tier was recently updated to train AI on your uploads. MicroBin self-hosted runs on any VPS for $5–6/month with no file limits imposed by a vendor [README][4].
• Key strength: Single Rust binary, sub-minute Docker install, three levels of encryption, and a feature list (expiry, QR codes, raw serving, URL shortening, postbox mode) that most hosted paste services charge for or don’t offer at all [README].
• Key weakness: 4,146 GitHub stars is respectable but not a large community. At least one commenter has flagged security concerns around access rights. The managed hosting at my.microbin.eu exists but pricing is not publicly listed, making it harder to compare against hosted alternatives [1][README].

---

What is MicroBin

MicroBin is a paste bin — but that undersells it. The README calls it a “super tiny, feature-rich, configurable, self-contained and self-hosted paste bin web application,” and the website frames it as somewhere between a cloud storage service and a secure sharing tool [README][website].

What it actually does: you create an “upload,” which can be a text paste, one or more file attachments, or a URL redirect. Each upload gets a readable animal-name identifier (e.g. server.com/file/pig-dog-cat) instead of a random hash. You set whether it’s public or private, whether it expires (by time or by read count), whether it’s editable or locked, and what level of encryption it uses. The whole thing ships as a single compiled Rust binary with an optional SQLite or JSON backend — no database server required [README].

The project was created by Danika Szabo and lives at github.com/szabodanika/microbin with 4,146 stars under the BSD-3-Clause license, which is permissive — you can embed, rebrand, or redistribute without the commercial restrictions that some open-source licenses impose [merged profile].

Three use cases come up repeatedly across the sources: developers moving files between machines, teams working around the 8MB Discord or 25MB email attachment caps, and individuals sharing secrets that shouldn’t live in Slack logs forever [website][3].

---

Why people choose it

MicroBin sits in a specific gap: it does more than a minimalist paste bin but doesn’t require the setup overhead of a full file storage system like Nextcloud or Seafile.

Versus Pastebin.com. The original is public-by-default, ad-heavy, increasingly focused on upselling paid tiers, and doesn’t offer file uploads or expiry-on-read. MicroBin handles all three, self-hostedly, with no per-paste fees [5]. TechnicalUstad’s roundup of Pastebin alternatives notes that Pastebin’s “public-by-default model” has caused enough real-world credential leaks that security teams now recommend against it for anything remotely sensitive [5].

Versus PrivateBin. The LinuxLinks roundup places both in the same category, and at least one commenter explicitly prefers MicroBin for personal use: “I personally prefer MicroBin over PrivateBin for personal use” [1]. The distinction is features — PrivateBin is deliberately zero-knowledge and minimalist, which is ideal if you only need encrypted text sharing. MicroBin adds file attachments, URL shortening, editable pastes, and the postbox mode that PrivateBin doesn’t have. The trade-off is surface area: more features means more potential attack surface. A LinuxLinks commenter (“Danie”) flagged this directly: “MicroBin does have some security concerns around access rights — which hopefully gets sorted out first” [1].

Versus WeTransfer. The July 2025 story where WeTransfer updated its terms to allow using uploaded files for AI training pushed a visible wave of users toward self-hosted alternatives. A French tech outlet (Les Numériques) covered this shift in depth, cataloguing alternatives from SwissTransfer to small French services [4]. MicroBin fits this need well for technical users — the Docker setup is a one-liner, and you get a feature set comparable to WeTransfer’s free tier (shareable links, expiry, password protection) without routing your files through a vendor’s training pipeline [4][README].

As a pastebin-plus-text-editor replacement. One home lab user documented replacing MicroBin with VS Code server precisely because MicroBin, while useful for paste-and-share, doesn’t handle the edit-locally-from-multiple-devices workflow that a code editor does [3]. This is a useful signal about where MicroBin’s limits are — it’s not a collaborative editor or a file manager, it’s a share-and-expire tool.

---

Features

Based on the README and website:

Core sharing engine:

• Text pastes with raw serving (server.com/raw/pig-dog-cat) — useful for hosting config files or test fixtures at a stable URL [README]
• File uploads with multiple attachments per upload [README]
• URL shortening and redirection [README]
• Animal-name identifiers — readable, memorable, harder to enumerate than sequential IDs [README]
• Editable and uneditable uploads — you can lock a paste or leave it open for updates [README]
• Private and public visibility [README]
• Expiry by time or by read count — set “delete after one view” for secrets [README][website]
• “Postbox” mode: users can submit files or pastes to you without seeing each other’s submissions [README][website]

Security:

• Server-side encryption [README]
• Client-side E2E encryption [README]
• Three levels of encryption total (none / server-side / client-side E2E) [website]
• Password protection on individual uploads [README]

Usability:

• QR code generation for any upload — one click to share to a phone [README]
• Dark mode (automatic) [README]
• Custom CSS support with minimal JavaScript [README]
• Clean, minimal UI built on water.css [README]

Infrastructure:

• Single compiled Rust binary — no runtime, no dependencies [README]
• SQLite or flat JSON backend — no separate database server [README]
• Docker support with a one-liner setup script [README]
• Very low memory footprint — “a few megabytes” per the README [README]
• Cargo install available for non-Docker deployments [README]

What’s not there: no user accounts (guests create uploads without logging in by default), no folder structure, no preview rendering for most file types, no collaborative editing. MicroBin is not trying to be Nextcloud — it’s a “create link, share link, it expires” tool.

---

Pricing: SaaS vs self-hosted math

MicroBin self-hosted:

• Software: $0 (BSD-3-Clause, no usage restrictions) [README]
• VPS: $5–10/month on Hetzner, Contabo, or DigitalOcean

MicroBin managed (my.microbin.eu):

• Pricing not publicly listed on the website. You need to visit my.microbin.eu to see current plans. This makes direct comparison harder — data not available from sources reviewed.

Pastebin.com for comparison:

• Free: public pastes, limited paste history, ads
• Pro ($49.95/year): private pastes, no ads, unlimited history
• The free tier is sufficient for casual public sharing but unusable for sensitive content

WeTransfer for comparison:

• Free: 2GB per transfer, files available for 7 days, ads, and as of July 2025, your files may be used for AI model training [4]
• Pro (~$12/month): 200GB transfers, 1TB storage, password protection

Concrete math for a typical team use case:

A small team of 5–10 people that routinely shares large files, config snippets, and the occasional password. WeTransfer Pro at $12/month = $144/year, with your files on WeTransfer’s servers. MicroBin on a $6 Hetzner VPS = $72/year, files on your server, no AI training clause, no 200GB transfer cap (you set your own limits). That’s roughly $72/year saved plus full data control — not the dramatic savings of replacing a $300/month SaaS bill, but meaningful when the privacy angle is the actual concern.

The real cost comparison isn’t just money — it’s the WeTransfer ToS situation. If your team shares anything even marginally sensitive (client files, internal documents, credentials), the self-hosted math wins on risk, not just dollars.

---

Deployment reality check

The README’s claim of “a couple minutes” is plausible for a Docker-comfortable user. The install path is either a one-line Docker script or cargo install microbin for a native binary [README].

Docker path:

bash <(curl -s https://microbin.eu/docker.sh)

That’s it for a basic instance. Default configuration uses JSON file storage, so you don’t even need SQLite set up immediately.

What you actually need:

• A Linux VPS with 512MB–1GB RAM (Rust binaries are lean)
• Docker, or a Rust toolchain for native install
• A domain and reverse proxy (Caddy or nginx) for HTTPS
• No database server required by default

What can go sideways:

• The “security concerns around access rights” flagged by a LinuxLinks commenter [1] were noted roughly a year ago. The project has been updated since, but if you’re deploying MicroBin as a shared service for a team, audit the access control settings carefully before opening it up.
• The documentation on microbin.eu is noted as “actively being worked on. Some information might be missing or incomplete” [docs page] — so for edge cases, you’re reading the source or the GitHub issues.
• File size limits are configurable by the operator. The default isn’t enormous — you’ll want to tune MICROBIN_MAX_FILE_SIZE for large attachments.
• The flat JSON backend is fine for low volume but not designed for concurrent write-heavy workloads. For a team of 10–20, switch to SQLite.

Realistic time estimate: 5–15 minutes for a Docker-comfortable developer. 30–60 minutes including domain and reverse proxy configuration. For someone who’s never touched a Linux server, plan for a full afternoon or get help.

---

Pros and cons

Pros

• Single binary, minimal footprint. Rust means you get a self-contained executable with no JVM, no Python environment, no Node runtime. Memory use is measured in megabytes, not hundreds [README].
• BSD-3-Clause license. Permissive — embed it, rebrand it, include it in a commercial product without a vendor relationship [merged profile].
• Unusually wide feature set for its size. URL shortening, postbox mode, QR codes, expiry-on-read, E2E encryption, editable pastes — this covers use cases that would require three separate tools if you were stitching together hosted services [README][website].
• E2E encryption. Client-side encryption means the server operator (including you, if you’re sloppy) can’t read the content without the password [README][website].
• One-liner Docker install. Setup friction is genuinely low compared to most self-hosted tools [README].
• No mandatory database server. JSON or SQLite, your choice. Fewer moving parts = fewer things to break [README].
• Animal-name identifiers. Slightly whimsical, practically useful — readable URLs are easier to share verbally or over a noisy channel [README].

Cons

• Security concerns flagged in the wild. At least one reviewer mentioned “security concerns around access rights” without fully detailing them [1]. The project has been iterated on since that comment, but the due diligence is on you to verify before deploying for a team.
• Documentation incomplete. The official docs page notes they’re still being built out [docs page]. For non-obvious configuration, you’ll be reading source code or GitHub issues.
• Managed pricing opaque. No public pricing on my.microbin.eu makes it impossible to recommend or dismiss the managed option without a direct visit.
• Not a collaborative tool. No user accounts in the typical sense, no version history, no real-time editing. If you need Notion-style shared notes or Google Docs-style collaboration, this isn’t it.
• Relatively small community. 4,146 GitHub stars [merged profile] is solid for a niche tool but small compared to PrivateBin or the major paste services. Fewer eyes on the code, fewer maintained integrations, slower issue resolution.
• No preview rendering. Files are served for download, not previewed in-browser (beyond text/code). Not a blocker, but worth knowing.
• File size limits require tuning. The default configuration isn’t tuned for large file transfers — you’ll need to configure limits explicitly if you’re using it as a WeTransfer replacement for multi-GB files.

---

Who should use this / who shouldn’t

Use MicroBin if:

• You’re a developer who regularly pastes config files, logs, or scripts and wants a self-hosted URL instead of pasting into Slack.
• Your team needs to share files that exceed email or Discord limits, and you don’t want those files on a third-party server.
• You share passwords or secrets and want them to auto-delete after one read, end-to-end encrypted.
• You want a URL shortener bundled in without running a separate service.
• You’re already running a Docker host and want a tool that’s up in under 10 minutes.

Skip it if:

• You need collaborative editing — use HedgeDoc or Etherpad instead.
• You need cloud storage with folder structure, sharing permissions, and mobile apps — use Nextcloud.
• You need zero-knowledge encryption with a stripped-down interface and no extras — PrivateBin is more focused on that single use case.
• You’re not comfortable configuring a reverse proxy and environment variables. The install is simple, but “simple” still requires basic Linux literacy.
• You need enterprise features like LDAP, SSO, or audit logs — MicroBin doesn’t have them.

---

Alternatives worth considering

• PrivateBin — Zero-knowledge encrypted paste bin. The server never sees the content. More focused, fewer features, better for the single use case of “share a secret, it disappears.” Active project, widely deployed. Choose this if E2E encryption for text is the only thing you need [1].
• Opengist — Self-hosted paste bin backed by Git. Every paste is a Git repository, so you get version history and the ability to clone. Good for developers who want their snippets version-controlled [1][2].
• Hastebin — Minimal, fast, no encryption, no file uploads. Good for “just paste code quickly” with no other requirements [5].
• GitHub Gist — Not self-hosted, but the gold standard for developer code sharing. Version-controlled, shareable, searchable. Use this if you don’t need self-hosting and your content is non-sensitive [5].
• Nextcloud — If your actual need is file storage rather than temporary sharing, Nextcloud is the full-featured self-hosted option. Much heavier to run, but covers collaboration, calendar, contacts, and a proper file manager alongside sharing [website context].
• Pastebin.com — Still viable for fully public, non-sensitive text snippets. Avoid for anything sensitive given the public-by-default model and historical credential leak incidents [5].
• SwissTransfer — If you specifically need large file transfer (up to 50GB) without self-hosting, Infomaniak’s SwissTransfer is a clean hosted alternative that doesn’t train AI on your files [4].

For the “escape WeTransfer and Pastebin with one self-hosted tool” use case, the realistic shortlist is MicroBin vs PrivateBin. MicroBin if you want file uploads, URL shortening, postbox mode, and QR codes alongside text pasting. PrivateBin if you want pure zero-knowledge text sharing with the smallest possible attack surface.

---

Bottom line

MicroBin is the rare self-hosted tool that delivers more than its name suggests. It’s called a paste bin but it replaces Pastebin, WeTransfer, and a URL shortener simultaneously — all from a single Rust binary that runs in under 15 minutes on any Docker host. The BSD-3-Clause license is genuinely permissive, the E2E encryption is real, and the “delete after one read” feature alone is worth the setup for anyone who’s ever sent a password over Slack and immediately felt slightly wrong about it.

The trade-offs are real: the community is small, the documentation is incomplete, there’s at least one historical security concern around access controls that deserves scrutiny before team deployment, and the tool has no path toward collaboration or file management beyond temporary sharing. But for its actual use case — share something, set an expiry, trust that it disappears — MicroBin does exactly what it says on the tin, costs nothing to run, and gets out of your way.

If the Docker setup is the blocker, that’s exactly what upready.dev deploys for clients. One-time fee, you own it.

---

Sources

1. LinuxLinks — “9 Best Free and Open Source Self-Hosted Pastebin Alternatives”. https://www.linuxlinks.com/best-free-open-source-self-hosted-pastebin-alternatives/
2. LinuxLinks — “Pastebin Archives”. https://www.linuxlinks.com/tag/pastebin/
3. Dom Corriveau, blog.ctms.me — “Notes - Self-hosting VSCode code-server and researching various text editors” (Apr 1, 2025). https://blog.ctms.me/posts/2025-04-01-notes-code-server/
4. Antoine Roche, Les Numériques — “Les meilleures alternatives à WeTransfer pour envoyer des fichiers” (Jul 15, 2025). https://www.lesnumeriques.com/appli-logiciel/les-meilleures-alternatives-a-wetransfer-pour-envoyer-des-fichiers-a239841.html
5. TechnicalUstad — “9 Best Pastebin Alternatives - Secure and Versatile [2026]”. https://technicalustad.com/pastebin-alternatives/

Primary sources:

• GitHub repository and README: https://github.com/szabodanika/microbin (4,146 stars, BSD-3-Clause license)
• Official website: https://microbin.eu
• Documentation: https://microbin.eu/docs/intro
• Managed hosting: https://my.microbin.eu
• Public demo: https://pub.microbin.eu