Zipline vs ShareX-Upload-Server vs Flowinity: Self-Hosted File Upload & Screenshot Server Guide 2026

Why Self-Host a File Upload and Screenshot Server?

Uploading screenshots, files, and text snippets to third-party services like Imgur, Pastebin, or Google Drive means giving up control over your data. A self-hosted file upload server puts you in full control — you decide retention policies, access permissions, and who can view your files. Whether you are a developer sharing code snippets, a team collaborating on design assets, or someone who wants private screenshot hosting without telemetry, a self-hosted solution is the answer.

Key benefits of self-hosting your file upload server include:

• Complete data ownership — files never leave your infrastructure
• Custom domain branding — use your own domain for short URLs
• No upload limits — constrained only by your storage capacity
• Integration with desktop tools — configure ShareX, Flameshot, or custom scripts to upload directly
• URL shortening — many upload servers include built-in link shortening
• Gallery management — browse and organize your uploads through a web interface

In this guide, we compare three open-source self-hosted file upload servers: Zipline, ShareX-Upload-Server (ShareS), and Flowinity (formerly PrivateUploader). Each offers a different approach to the problem, and we will help you choose the right one.

Quick Comparison Table

Zipline — The Feature-Rich Upload Server

Zipline is the most popular open-source file upload server, with over 3,000 GitHub stars. Built with TypeScript using Next.js and the Mantine UI framework, it offers a polished web interface and extensive features.

Key Features

• Multiple upload types: files, images, code snippets, text, and URLs
• URL shortening with custom domains and vanity URLs
• OAuth2 authentication with Discord, GitHub, and OIDC providers
• Chunked uploads for large files with resume support
• Image processing including format conversion and optimization via FFmpeg
• Discord webhook integration for upload notifications
• User management with per-user quotas and roles
• Theme support — customize the web UI with custom themes
• Invertible embeds — embed files with custom preview images

Installing Zipline with Docker Compose

Zipline provides an official docker-compose.yml that bundles PostgreSQL and the application:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

services:
  postgresql:
    image: postgres:16
    restart: unless-stopped
    env_file:
      - .env
    environment:
      POSTGRES_USER: ${POSTGRESQL_USER:-zipline}
      POSTGRES_PASSWORD: ${POSTGRESQL_PASSWORD:?POSTGRESQL_PASSWORD is required}
      POSTGRES_DB: ${POSTGRESQL_DB:-zipline}
    volumes:
      - pgdata:/var/lib/postgresql/data
    healthcheck:
      test: ['CMD', 'pg_isready', '-U', 'zipline']
      interval: 10s
      timeout: 5s
      retries: 5

  zipline:
    image: ghcr.io/diced/zipline:latest
    restart: unless-stopped
    ports:
      - '3000:3000'
    env_file:
      - .env
    environment:
      - DATABASE_URL=postgres://${POSTGRESQL_USER}:${POSTGRESQL_PASSWORD}@postgresql:5432/${POSTGRESQL_DB:-zipline}
    depends_on:
      postgresql:
        condition: service_healthy
    volumes:
      - './uploads:/zipline/uploads'
      - './public:/zipline/public'
      - './themes:/zipline/themes'
    healthcheck:
      test: ['CMD', 'wget', '-q', '--spider', 'http://0.0.0.0:3000/api/healthcheck']
      interval: 15s
      timeout: 2s
      retries: 2

volumes:
  pgdata:

Create a .env file in the same directory:

1
2
3
4
5

POSTGRESQL_USER=zipline
POSTGRESQL_PASSWORD=your_secure_password_here
POSTGRESQL_DB=zipline
CORE_SECRET=your_random_secret_here
CORE_HOSTNAME=0.0.0.0

Then start the stack:

1

docker compose up -d

Zipline will be available at http://localhost:3000. The default admin credentials are administrator / password — change them immediately after first login.

Configuring ShareX to Upload to Zipline

After deploying Zipline, configure ShareX (Windows) or Flameshot (Linux) to upload directly:

1. Log into Zipline and go to Dashboard → Copy ShareX Config
2. Download the .sxcu configuration file
3. Open ShareX → Import → From file → select the downloaded config
4. Test with a screenshot — it will upload to your server and copy the URL to clipboard

For manual uploads via curl:

1
2
3

curl -X POST http://localhost:3000/api/upload \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -F "file=@screenshot.png"

ShareX-Upload-Server (ShareS) — The Lightweight Option

ShareX-Upload-Server, also known as ShareS, is a Node.js-based upload server designed specifically around the ShareX workflow. It supports images, videos, code, text, markdown rendering, password-protected uploads, URL shortening, and Discord-based administration.

Key Features

• ShareX-native design — .sxcu config files generated automatically
• Discord bot administration — manage the server entirely through Discord commands
• Discord webhook logging — log all uploads to a Discord channel
• Password-protected uploads — share files with access control
• URL shortening — built-in link shortener with custom slugs
• Markdown rendering — text uploads render as formatted markdown
• Multiple content types — images, videos, code, text, and URLs
• EJS templating — customizable frontend with EJS views

Installing ShareX-Upload-Server with Docker

ShareX-Upload-Server provides a Dockerfile but no official docker-compose. Here is a production-ready setup:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

services:
  shares:
    image: node:18-alpine
    working_dir: /app
    restart: unless-stopped
    ports:
      - '3001:3001'
    volumes:
      - ./data/uploads:/app/src/public/uploads
      - ./data/db:/app/src/db
      - ./config:/app/src/config
    command: >
      sh -c "
        apk add --no-cache git &&
        git clone https://github.com/TannerReynolds/ShareX-Upload-Server.git /app/src &&
        cd /app/src &&
        npm install &&
        node index.js
      "
    environment:
      - PORT=3001

Or, for a more permanent setup, clone and build manually:

1
2
3
4
5
6

git clone https://github.com/TannerReynolds/ShareX-Upload-Server.git
cd ShareX-Upload-Server
npm install
cp config.json.example config.json
# Edit config.json with your settings
node index.js

The server runs on port 3001 by default. Edit config.json to customize the domain, Discord bot token, and upload directory.

Discord Bot Administration

One unique feature of ShareS is Discord-based administration. After configuring a Discord bot token in config.json, you can manage the server with commands like:

1
2
3
4

!stats        # Show server statistics
!uploads      # List recent uploads
!clear        # Clear uploads older than X days
!block        # Block a user by IP

This makes it ideal for solo operators who want to manage their upload server without logging into a web panel.

Flowinity — The Modern All-in-One Suite

Flowinity (formerly PrivateUploader) is the newest of the three, built with TypeScript and Vue.js. It positions itself not just as an upload server but as a complete cloud suite with file storage, chat, and collaboration features.

Key Features

• Modern Vue.js frontend with Vuetify UI components
• File upload and storage with drag-and-drop interface
• Redis caching for improved performance
• MariaDB backend for reliable data storage
• AGPL-3.0 license — strong copyleft protection
• Chat integration — built-in messaging alongside file sharing
• Self-hosted cloud suite — more than just uploads

Installing Flowinity with Docker Compose

Flowinity ships with an official docker-compose.yml:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

services:
  flowinity:
    image: "troplo/privateuploader:latest"
    ports:
      - "34582:34582"
      - "34583:34583"
    volumes:
      - /var/lib/flowinity/config:/app/app/config
      - /var/lib/flowinity/storage:/app/storage
      - /var/lib/flowinity/frontend_build:/app/frontend_build
    depends_on:
      - redis
      - mariadb
    restart: unless-stopped

  redis:
    image: "redis/redis-stack"
    volumes:
      - /var/lib/flowinity/redis:/data
    restart: unless-stopped

  mariadb:
    image: "mariadb:10.6"
    volumes:
      - /var/lib/flowinity/mariadb:/var/lib/mysql
    environment:
      - MYSQL_DATABASE=flowinity
      - MYSQL_USER=flowinity
      - MYSQL_PASSWORD=your_secure_password
      - MYSQL_ROOT_PASSWORD=your_root_password
    restart: unless-stopped

Start the stack:

1
2

mkdir -p /var/lib/flowinity/{config,storage,frontend_build,redis,mariadb}
docker compose up -d

Access the web interface at http://localhost:34582. The dual-port setup (34582 for web, 34583 for API) allows separation of frontend and backend traffic.

Deployment Considerations

Reverse Proxy Setup

All three servers should be placed behind a reverse proxy for production use. Here is an Nginx configuration example for Zipline:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

server {
    listen 443 ssl http2;
    server_name upload.example.com;

    ssl_certificate /etc/letsencrypt/live/upload.example.com/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/upload.example.com/privkey.pem;

    location / {
        proxy_pass http://127.0.0.1:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        client_max_body_size 500M;
    }
}

For large file uploads, increase client_max_body_size to match your expected maximum upload size.

Storage Backend

For servers handling large files, consider using a dedicated storage volume or object storage (like MinIO self-hosted S3) rather than local disk. Zipline supports external storage backends, while ShareX-Upload-Server and Flowinity currently use local filesystem storage.

Related Reading

For related guides on self-hosted file sharing and transfer, see our Chibisafe vs Pingvin Share vs Lufi comparison for one-time file sharing services, and the PsiTransfer vs Wormhole vs FileShelter guide for ephemeral file transfers.

Backup Strategy

Back up both the database and the uploaded files directory:

1
2
3
4
5
6
7
8

# Backup PostgreSQL database (Zipline)
pg_dump -U zipline zipline > zipline_backup.sql

# Backup uploaded files
tar czf uploads_backup.tar.gz ./uploads/

# Backup SQLite database (ShareS)
cp ./src/db/database.db ./db_backup_$(date +%Y%m%d).db

Which One Should You Choose?

Choose Zipline if you want the most feature-complete upload server with OAuth, chunked uploads, theme support, and an active development community. It is the best choice for teams and power users who need a professional-grade solution.

Choose ShareX-Upload-Server if you want a lightweight, ShareX-focused server with Discord bot administration. It is ideal for solo operators who want to manage everything through Discord without a web panel. Note that the project has not been updated since early 2024.

Choose Flowinity if you want a modern, all-in-one cloud suite that combines file uploads with chat and collaboration features. It is the best choice if you are looking for more than just an upload server — but be aware that it has a smaller community and fewer stars compared to the other two options.

FAQ

What is a self-hosted file upload server?

A self-hosted file upload server is a web application you deploy on your own infrastructure that accepts file uploads via HTTP and serves them back through URLs. Instead of using third-party services like Imgur or Google Drive, you control the entire pipeline — storage, access control, and retention policies.

Can I use Zipline with ShareX on Windows?

Yes. Zipline is designed to work seamlessly with ShareX. After deploying Zipline, log into the web dashboard and use the “Copy ShareX Config” button to download a pre-configured .sxcu file. Import it into ShareX and your screenshots will automatically upload to your server.

Which upload server supports the largest file sizes?

Zipline supports chunked uploads, which allows it to handle very large files (multi-gigabyte) reliably by splitting them into smaller chunks that can be resumed if interrupted. ShareX-Upload-Server and Flowinity use standard single-request uploads, which can be limited by your reverse proxy’s client_max_body_size setting.

Do these servers support password-protected file sharing?

Yes, all three support password protection for individual uploads. Zipline and ShareX-Upload-Server also support expiring links and download count limits. This is useful for sharing sensitive files that should only be accessible to specific recipients.

Can I use a custom domain with these upload servers?

Yes. All three servers can be placed behind a reverse proxy (Nginx, Caddy, or Traefik) with SSL termination. This allows you to use your own domain (e.g., upload.example.com) for both the web interface and the short URLs generated for uploaded files.

Which server has the most active development?

Zipline is by far the most actively maintained, with over 3,000 GitHub stars and commits pushed as recently as April 2026. ShareX-Upload-Server’s last update was in February 2024, and Flowinity’s most recent commit was in December 2025. For long-term projects, Zipline is the safest choice.

How do I back up my upload server data?

You need to back up two things: the database (PostgreSQL for Zipline, MariaDB for Flowinity, SQLite for ShareS) and the uploaded files directory. Use standard database dump tools (pg_dump, mysqldump) and archive the files directory with tar. Store backups on a separate machine or in object storage.