A minimal file upload/pastebin service.
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Go to file
Orhun Parmaksız 695bb738cd
docs(license): update copyright years
4 weeks ago
.github chore(funding): enable GitHub Sponsors for funding 6 months ago
extra/systemd chore(systemd): add systemd service files (#22) 10 months ago
fixtures feat(server): add landing page (#26) 4 months ago
img docs(readme): add README.md 2 years ago
src fix(lints): apply clippy suggestions for tests 1 month ago
.dockerignore chore(docker): add Dockerfile 2 years ago
.env refactor(server): use .env for auth token 2 years ago
.gitignore test(fixtures): add a test framework along with test fixtures 8 months ago
CHANGELOG.md chore(release): prepare for v0.8.2 4 months ago
Cargo.lock chore(deps): remove unused clap dependency (#32) 4 weeks ago
Cargo.toml chore(deps): remove unused clap dependency (#32) 4 weeks ago
Dockerfile chore(build): strip the binary 10 months ago
LICENSE docs(license): update copyright years 4 weeks ago
README.md docs(readme): update contributing details 9 months ago
codecov.yml chore(codecov): add codecov config (#21) 11 months ago
config.toml fix(config): don't expose version endpoint in default config (#31) 4 months ago
docker-compose.yml chore(docker): share the config file between host and container 1 year ago


Rustypaste is a minimal file upload/pastebin service.

$ echo "some text" > awesome.txt

$ curl -F "file=@awesome.txt" https://paste.site.com

$ curl https://paste.site.com/safe-toad.txt
some text


  • File upload & URL shortening & upload from URL
    • supports basic HTTP authentication
    • random file names (optional)
      • pet name (e.g. capital-mosquito.txt)
      • alphanumeric string (e.g. yB84D2Dv.txt)
    • supports expiring links
      • auto-deletion of expired files (optional)
    • supports one shot links (can only be viewed once)
    • guesses MIME types
      • supports overriding and blacklisting
    • no duplicate uploads (optional)
  • Single binary
  • Simple configuration
    • supports hot reloading
  • Easy to deploy
  • No database
    • filesystem is used
  • Self-hosted
    • centralization is bad!
  • Written in Rust
    • blazingly fast!


From crates.io

cargo install rustypaste

Arch Linux

pacman -S rustypaste

Binary releases

See the available binaries on releases page.

Build from source

git clone https://github.com/orhun/rustypaste.git
cd rustypaste/
cargo build --release


# run unit tests
cargo test -- --test-threads 1


The standalone command line tool (rpaste) is available here.


function rpaste() {
  curl -F "file=@$1" -H "Authorization: <auth_token>" "<server_address>"

* consider reading authorization headers from a file. (e.g. -H @rpaste_auth)

# upload a file
$ rpaste x.txt

# paste from stdin
$ rpaste -


$ curl -F "file=@x.txt" -H "expire:10min" "<server_address>"

(supported units: ns, us, ms, sec, min, hours, days, weeks, months, years)

One shot

$ curl -F "oneshot=@x.txt" "<server_address>"

URL shortening

$ curl -F "url=https://example.com/some/long/url" "<server_address>"

Paste file from remote URL

$ curl -F "remote=https://example.com/file.png" "<server_address>"

Cleaning up expired files

Configure delete_expired_files to set an interval for deleting the expired files automatically.

On the other hand, following script can be used as cron for cleaning up the expired files manually:

#!/bin/env sh
now=$(date +%s)
find upload/ -maxdepth 2 -type f -iname "*.[0-9]*" |
while read -r filename; do
	[ "$(( ${filename##*.} / 1000 - "${now}" ))" -lt 0 ] && rm -v "${filename}"


To start the server:

$ rustypaste

If the configuration file is not found in the current directory, specify it via CONFIG environment variable:

$ CONFIG="$HOME/.rustypaste.toml" rustypaste

To enable basic HTTP auth, set the AUTH_TOKEN environment variable (via .env):

$ echo "AUTH_TOKEN=$(openssl rand -base64 16)" > .env
$ rustypaste

See config.toml for configuration options.


Following command can be used to run a container which is built from the Dockerfile in this repository:

$ docker run --rm -d \
  -v "$(pwd)/upload/":/app/upload \
  -v "$(pwd)/config.toml":/app/config.toml \
  --env-file "$(pwd)/.env" \
  -e "RUST_LOG=debug" \
  -p 8000:8000 \
  --name rustypaste \
  • uploaded files go into ./upload (on the host machine)
  • set the AUTH_TOKEN via -e or --env-file to enable auth

You can build this image using docker build -t rustypaste . command.

If you want to run the image using docker compose, simply run docker-compose up -d. (see docker-compose.yml)


Example server configuration with reverse proxy:

server {
    listen 80;
    location / {
        proxy_pass                         http://localhost:8000/;
        proxy_set_header Host              $host;
        proxy_set_header X-Forwarded-For   $remote_addr;
        proxy_set_header X-Forwarded-Proto $scheme;
        add_header X-XSS-Protection        "1; mode=block";
        add_header X-Frame-Options         "sameorigin";
        add_header X-Content-Type-Options  "nosniff";

If you get a 413 Request Entity Too Large error during upload, set the max body size in nginx.conf:

http {
    # ...
    client_max_body_size 100M;


Pull requests are welcome!

Consider submitting your ideas via issues first and check out the existing issues.


All code is licensed under The MIT License.