zipline.diced.sh

What is Zipline?

Zipline is a self-hosted file upload and URL-shortening server you run on your own hardware. It is aimed at people who want a private alternative to public image hosts and link shorteners: you upload images, videos and other files to your own instance, get shareable links back, and manage everything from a web dashboard. Its documentation and project site live at Zipline.

What it actually does

The core loop is upload, store, share. According to the project's own feature list, Zipline handles images, videos and general files, generates embeds for uploaded files so they render nicely in apps like Discord, and shortens URLs with custom links. Around that core it adds organisation and administration: folders, tags, a gallery of all uploads, a list of shortened URLs, and metrics with historical upload data.

For a small team or a community server, the administration features matter as much as the uploads. Zipline describes invite links, per-user quotas, OAuth2 login through Discord, GitHub, Google or any OIDC provider, two-factor authentication, passkeys, and password protection on individual files and URLs. There are Discord and HTTP webhooks for notifications, a full API for programmatic access, and a PWA mode so the dashboard can be installed like an app.

Who it suits

• Community and Discord server owners who want image links that won't expire or get rate-limited by a third-party host, and who want upload notifications piped into a channel.
• Small teams that need a shared drop point for screenshots, clips and documents with per-person quotas rather than a free-for-all.
• Developers who want an API and webhooks to wire uploads into their own tooling.

It suits you less if you don't want to run a server. Zipline is software you deploy and maintain, so you need somewhere to host it, storage for the files, and a plan for backups and updates. The project says setup takes minutes, but ongoing care is still yours.

Practical considerations

Two features are worth calling out because they affect cost and speed. Image compression on the fly saves storage, and video thumbnails are generated automatically, which is convenient but adds processing load on the machine running the instance. Partial or "chunked" uploads help with large files, particularly over flaky connections.

Authentication breadth is a genuine strength here: supporting OIDC means you can plug Zipline into an existing identity provider instead of creating yet another set of accounts.

A concrete starting scenario

Say you run a Discord community and want a self-hosted screenshot host. You deploy Zipline, connect Discord OAuth2 so members log in with accounts they already have, set a quota per user, create an invite link, and add a Discord webhook so uploads announce themselves in a channel. Members upload through the dashboard or a desktop uploader, and you review everything in the gallery.

A reasonable next step is to compare Zipline against other self-hosted upload servers before committing, since the choice usually comes down to which upload clients and authentication methods you need. If you already use ShareX-style tooling, check that your preferred uploader is supported, then decide based on storage, hosting and how much administration you want.

How does Zipline integrate with ShareX for uploading files?

Zipline is built to act as the server side of a ShareX workflow: you run the Zipline instance, point ShareX at it, and ShareX sends each capture or file to Zipline, which stores it and returns a link. The page describes Zipline as a file upload server that "supports your favorite uploaders," which in practice means ShareX is treated as a client rather than something Zipline replaces.

What the integration looks like in practice

• ShareX handles capture and triggering on Windows: screenshots, screen recordings, clipboard images, dragged files, or any custom task you configure.
• Zipline handles storage, organization and delivery: the upload lands in your instance, appears in the gallery, and can be sorted into folders or tagged.
• The link comes back from Zipline, so ShareX can copy it to the clipboard, open it, or pass it to another action such as posting in Discord.

Features that matter for this setup

Setting it up

The usual path is: deploy Zipline, create a user or token in the dashboard, then in ShareX add a custom uploader with Zipline's upload endpoint and your credentials. Zipline's documentation at Zipline is the place to confirm the exact endpoint, header and response format, since those details vary by version. Once configured, a single hotkey can capture, upload and copy the resulting link.

Who this suits

This is a good fit if you already use ShareX and want your screenshots and clips to live on infrastructure you control, with folders, tags and metrics instead of an anonymous public host. It is less appealing if you want zero maintenance, since you are responsible for running and updating the instance. If you would rather not self-host at all, a hosted service such as Imgur removes the server work but also the control over retention and organization.

Can I set up my own self-hosted Zipline instance, and what are the requirements?

Yes. Zipline is designed as a self-hosted file upload server, and its own documentation is the place to confirm the current install steps and required services for your chosen version.

What the product itself covers

The page describes setup as fast — "Setup your own Zipline instance in minutes" — and says configuration happens inside the dashboard rather than by editing files. It also lists the capabilities you would expect from a ShareX-compatible upload server:

• Uploading images, videos and other files, with syntax highlighting for text files
• Folders and tags for organising uploads
• URL shortening with custom links
• Embeds, so uploaded files render in apps such as Discord
• Discord and HTTP webhooks for upload and short-link events
• Authentication via Discord, GitHub, Google or any OIDC provider, plus 2FA, passkeys and password-protected files
• On-the-fly image compression, automatic video thumbnails, chunked uploads for large files
• A full API, PWA install, invite links, per-user quotas and custom themes

What the page does not state

The introduction page does not list minimum CPU, RAM, disk or the exact database and runtime versions. Treat anything you see elsewhere as version-specific and verify it in the official docs before you commit to a host.

Practical requirements to plan for

Self-hosting Zipline in practice means providing:

A small VPS is a reasonable starting point for personal use, but if you enable video uploads and public sharing, storage and bandwidth — not CPU — will be your first constraint.

A sensible next step

Open the official docs at Zipline and read the installation page for the version you intend to run, then set up OAuth credentials if you plan to use Discord, GitHub or Google login. If you only need occasional file sharing and would rather not run a server, a hosted alternative such as Imgur removes the maintenance burden at the cost of control over your data.

How do I configure OAuth2 authentication with Discord, GitHub, Google, or OIDC in Zipline?

Zipline supports OAuth2 sign-in through Discord, GitHub, Google and any generic OIDC provider, and the configuration lives in the dashboard rather than in a config file you hand-edit. The practical flow is: register an OAuth application with the provider, copy its client ID and secret into Zipline's authentication settings, then set the callback/redirect URL to your own instance's domain.

What you need from each provider

The steps that matter

1. Create the OAuth app at the provider and note the generated credentials.
2. In Zipline, open the dashboard settings for authentication and enable the provider you want, pasting in the client ID and secret.
3. Set the redirect/callback URL at the provider to point at your Zipline instance. This is the step people most often get wrong: the value must match exactly, including scheme and any subpath, or the provider will reject the sign-in with a redirect mismatch.
4. Save, then test by logging out and signing in through that provider in a private browser window.

Choosing between them

Discord and GitHub are the quickest to set up and suit communities already living on those platforms. Google is convenient for a broad, general audience. OIDC is the flexible option: point it at an existing identity provider and you get single sign-on across your other services, at the cost of more configuration and a dependency on that provider being reachable.

Practical notes

OAuth2 pairs with the other account features Zipline lists, so you can combine provider sign-in with two-factor authentication, passkeys or invite-only registration. If you are running a private instance, enabling one provider plus invites keeps access controlled without managing passwords yourself. For a first setup, start with a single provider, confirm a full login round-trip works, then add others.

For exact field names and the current redirect path, follow the provider setup in the official documentation at Zipline.

What options does Zipline provide for organizing and managing uploaded files, such as folders and tags?

Zipline's dashboard is built around a gallery that shows every upload in one place, with folders and tags as the two main organizing tools. Folders give you a hierarchical structure, while tags add a second, cross-cutting layer for labeling and searching. The site also lists metrics for tracking uploads and historical activity, and a separate view for managing shortened URLs, so links and files are handled in the same interface rather than in different tools.

Organizing options

Because tags are independent of folders, the practical pattern is to use folders for stable structure and tags for anything that changes often. A screenshot might live in a "Product/Launch" folder but carry tags like draft, needs-alt-text or client-a.

Other management controls

Beyond folders and tags, the page lists password protection for files and URLs, configurable quotas per user, invite links for sharing the instance, and a fully featured API for programmatic access. Custom themes and a wide range of settings let you tune the dashboard's appearance and behavior. Uploads themselves accept images, videos and other file types, with syntax highlighting for text files, and large files can be sent in chunks.

Practical scenario

A small team running a self-hosted Zipline instance might create folders per client, tag files by status and type, set quotas so no single member fills the disk, and use the metrics view to decide when to enable image compression. The shortened-URL list keeps campaign links next to the assets they reference.

Next step

Start with folders for the structure you already know you need, then add tags only for categories that cross folder boundaries. If you expect many contributors, decide on a tag naming convention before inviting anyone, since inconsistent tags are harder to fix later than misplaced folders.

How can I use Zipline's API to programmatically upload files or shorten URLs?

Zipline's API is designed for exactly that kind of automation: its documented feature set includes a fully featured API for programmatic access, so you can drive uploads and URL shortening from scripts, bots or your own apps rather than through the dashboard. The same API is what lets supported uploaders push files to your instance, and it also exposes event data through HTTP webhooks if you would rather react to activity than poll for it.

What you need before writing code

• A running Zipline instance you control, or an account on one that allows API access.
• An API token created in your account settings (the dashboard is where configuration and user management happen).
• The base URL of the instance, since every endpoint lives under your own domain.
• An uploader or HTTP client: curl, a small Python/Node script, or a ShareX-style tool if you prefer a GUI.

Typical flow for a script

1. Create a token in the dashboard and store it as an environment variable rather than hard-coding it.
2. Send a POST with the file as multipart form data to the upload endpoint, including the token in an Authorization header.
3. Read the JSON response — it contains the URL of the stored file, which you can then log, post to chat, or embed.
4. For links, call the URL-shortening endpoint with the destination URL; Zipline supports custom links, so you can request a readable slug where the instance allows it.

Practical considerations

• Auth options are broad. Zipline supports Discord, GitHub, Google and any OIDC provider for authentication, plus 2FA and passkeys for user accounts. API tokens are the right mechanism for machines; OAuth flows are for interactive logins.
• Large files: Zipline supports chunked "partial uploads", which matters if you are pushing videos or large archives over an unreliable connection.
• Privacy: files and shortened URLs can be password-protected, so a script can upload something and hand the recipient a password separately.
• Storage pressure: image compression on the fly and automatic video thumbnails reduce what you actually store, which is useful if you run a shared instance.
• Quotas: if you set quotas on users, your automation must handle rejection responses rather than assuming every upload succeeds.
• Events: Discord webhooks give you notifications with no code; HTTP webhooks give you the full event payload when you need to trigger your own pipeline.

A concrete scenario

Suppose you run a small community instance and want a bot that mirrors screenshots from a chat channel. The bot listens for attachments, posts each one to Zipline's upload endpoint with its token, stores the returned URL, and optionally calls the shortening endpoint to produce a tidy link. When an upload fails because the user hit their quota, the bot reports that instead of silently dropping the file. If you also subscribe to HTTP webhooks, you can log every upload centrally without querying the API afterwards.

Where to go next

Read the project's own documentation for the exact endpoint paths, request fields and response shapes — those details change between versions and should come from the source, not from guesswork. The official site is Zipline. If you want a ready-made client instead of writing one, look at the uploader integrations the project lists, and for general API practice, the HTTP semantics described by MDN Web Docs apply directly to Zipline's endpoints.