I Compared 4 Self-Destructing Sharing Tools — Then Self-Hosted the Only One That's Mine

Everything You Send Online Outlives the Moment You Sent It

Here's an uncomfortable truth about how most of us share sensitive stuff: it doesn't go away. That password you texted a coworker? Sitting in a chat backup somewhere. That one-time API key you emailed yourself as a reminder? Archived forever in a mailbox you'll forget to clean out. Cloud drives quietly accumulate files we meant to send once and never look at again.

Every so often you actually want the opposite — something that shows up, gets read once, and then is just... gone. No archive, no backup, no "oh wait, I still have that from three years ago" moment.

There's a small family of tools built exactly for that job. I went down a rabbit hole comparing four of them — Pastebin.com, Privnote, file.io, and MicroBin — because I wanted to know which one I could actually trust with something sensitive, and which one I could run myself. Spoiler: only one of the four lets you do the second part.

A quick naming note: "Pastebin" is also used generically to describe a whole category of tools (open-source clones like PrivateBin, hastebin, and friends). When I say Pastebin.com in this post, I mean the original commercial site.

The Lineup

• Pastebin.com — the granddaddy of text sharing, since 2002
• Privnote — self-destructing, encrypted notes, since 2008
• file.io — self-destructing file sharing, since 2015
• MicroBin — a pastebin, file share, and note-burner rolled into one, since 2022, and the only one you can self-host

They all promise a version of the same thing: share something sensitive for a short window, then make sure it's actually gone. But they were born in different eras, written in different stacks, and only one of them can ever truly be yours.

A Brief History: Who Came First?

This story starts in IRC chatrooms and ends with a self-hosted Rust binary running on a Raspberry Pi somewhere. Laid out by launch date, you can watch the idea of "ephemeral sharing" get refined generation by generation.

1. Pastebin.com — September 3, 2002. British developer Paul Dixon built it to stop people from dumping giant blocks of code and error logs straight into IRC channels — paste the text once, share a link instead. Dixon ran it himself until 2010, when he sold it to its current owner, who modernized the interface and grew it into the hacker-adjacent institution it is today.
2. Privnote — 2008. Originally built by the team at Insophia as a way to send something sensitive — a password, a root credential — without it sitting in a browser's plaintext history. The pitch was simple: encrypt in the browser, share a link, and destroy the note the moment it's opened. The service is now operated by Ikatu (legal entity Gletin S.A.), and it's been enough of a target for phishing lookalikes that "is this really privnote.com?" has become its own small genre of security blog post.
3. file.io — 2015. A "Show HN" side project built as a Mr Cowboy LLC project out of Philadelphia — described on its own site as something built "simply out of the joy of trying to build cool things on the internet." Upload up to 4GB, share the link, and the file gets shredded after the first download or an optional expiry. It grew into a genuinely useful free ephemeral transfer service with a REST API bolted on.
4. MicroBin — 2022. Open-source developer Dániel Szabó combined everything: a pastebin, a file share, and a URL shortener, in one small executable. First published to crates.io in mid-2022, and unlike the three services above, it's BSD-3-Clause licensed and built specifically to be self-hosted.

What Each One Actually Does

Once you get past the shared "it disappears" pitch, these four split cleanly into text vs. files, and timer-based vs. read-once destruction.

The distinction that actually matters here is expiration vs. burn-after-read:

• Expiration = delete after a set amount of time (Pastebin, file.io, MicroBin)
• Burn-after-read = delete the instant someone opens it (Privnote, and optionally MicroBin)

That difference changes both your threat model and your convenience. A timer is forgiving — you can share the same link with a small group before it expires. Burn-after-read is strict — one person, one view, done — which is exactly what you want for a password or an API key, and exactly what you don't want if you're not sure the recipient will click the link before it disappears.

Tech Stack Teardown

Pastebin.com — PHP, and a long memory

Classic PHP on a LAMP-style stack, fronted by Cloudflare. Pastes are stored server-side, unencrypted — a public paste is readable by anyone, and frequently scraped by security researchers and, less pleasantly, threat actors looking for leaked credentials. Free-tier pastes can also get deleted for inactivity. It's a great tool for what it was built for; it's not really a privacy tool by today's standards.

Privnote — client-side first

The clever part of Privnote's design is that the note is encrypted before it ever leaves your browser. The encryption key lives in the URL fragment (the part after the #), which browsers never send to the server — so the server only ever sees ciphertext, and the plaintext and the key are never in the same place at once. When the recipient opens the link, the note self-destructs and the URL stops working. It's a genuinely zero-knowledge design; Privnote itself can't read the notes it stores.

file.io — simple, encrypted transfer

A hosted service that stores each upload encrypted at rest. It's reachable through both a web UI and a dead-simple REST API (POST / to upload, get JSON back), which makes it the easiest of the three hosted tools to script with curl. Files get wiped on first download or on the expiry you set.

MicroBin — the whole bundle in a single Rust binary

This is the one that got my attention, because the stack is the most modern of the four and it's fully open:

• Language: Rust
• Web framework: Actix Web 4 — async HTTP server
• Templating: Askama (compile-time-verified HTML), plus a little vanilla JS and water.css for styling
• Storage: SQLite by default (via rusqlite), or flat JSON files if you'd rather skip the database entirely
• Encryption: AES-256 via the magic-crypt crate, with both server-side and end-to-end client-side modes
• Syntax highlighting: syntect
• Deployment: a single self-contained binary, a few MB, happy running in a low-memory container or on a Pi, configured entirely through environment variables

It also ships "animal-name" links (/file/sloth-ant-lion instead of a random hash) — a small touch, but it makes a link something you can actually read out loud over the phone.

The Self-Hosting Fork in the Road

This is the single biggest decision point in the whole comparison, and it's not close:

With Pastebin.com, Privnote, and file.io, your data lives on someone else's server under their retention policy. That's not a knock on any of them — Privnote's zero-knowledge design in particular means they genuinely can't read your notes either — but you're still trusting infrastructure you don't control, uptime you don't control, and a deletion promise you can't verify from the outside.

MicroBin is the only one where the answer to "who has this data" is just... you.

Where They Overlap: Same Purpose, Different Axes

Strip away the branding, and all four tools exist to solve one problem: hand someone a piece of data through a link that, by design, stops working. Where they genuinely diverge is across four practical questions:

1. What's being shared? Text/code → Pastebin, Privnote. Files → file.io, MicroBin. All of it → MicroBin.
2. How permanent should it be? Deadline-based → Pastebin, file.io, MicroBin. Event-based (read once) → Privnote, MicroBin.
3. Who's the intended reader? The public → Pastebin's archive. One specific person → Privnote, file.io, MicroBin.
4. Who controls the data? A third-party host → Pastebin, Privnote, file.io. You → MicroBin.

MicroBin is functionally the union of the other three: Pastebin's text sharing, file.io's file transfer, and Privnote's burn-after-read behavior, minus the "trust someone else's server" part.

Which Should You Use?

• Share code or a log, don't care much about privacy? Pastebin.com is fast and frictionless.
• Send a single-view secret — a password, a key — to one person? Privnote is zero-knowledge and purpose-built for exactly that.
• Transfer a large file that should vanish after one download? file.io, via UI or a quick curl call.
• Want text, files, and short URLs, with total control over when the data disappears? Self-hosted MicroBin. It covers almost everything the other three do, and the data is actually yours the whole time.

If you only pick one, MicroBin is the one worth running yourself — it's the Swiss-army knife of the group, and it's the only one where "self-destructing" doesn't require trusting someone else's promise that it actually happened.

Wrap-Up

Four tools, three hosted services, one open-source binary, all built around the same idea: this shouldn't outlive the moment you needed it. Pastebin created the paste-and-share pattern back in 2002. Privnote added real client-side encryption and true burn-after-read. file.io brought the same idea to files. And MicroBin, in 2022, packed all of it into something you can run on a box you own.

Given how much of this stack I've already got running — VPS, Docker, Caddy, — adding a self-hosted ephemeral-sharing tool felt less like a new project and more like filling a gap I didn't realize I had. If you're running a similar setup, this is a genuinely easy one to bolt on.