Ship auto-updates straight from your release pipeline. Your application asks BinDist for the latest version, compares it to what is installed, and pulls a secure download link, all over a simple REST API.
Adding an update mechanism to a desktop application usually means standing up a release server, expiring download links, and keeping per-customer access straight. BinDist gives you a release distribution API that handles all of it, so your app only needs to make two requests. (Running the open-source edition on your own domain and cloud lets you point any kind of client at it, but the hosted service is built for desktop app updates.)
The flow is the same whether you are pushing a routine patch or an urgent fix:
Every request is authenticated with a per-customer API key, so each customer only ever sees the releases they are licensed for. Here is the whole update check using the official Rust client:
use bindist::{Client, GetDownloadInfoOptions, ListVersionsOptions};
use semver::Version;
let client = Client::new("https://api.bindist.eu", &std::env::var("BINDIST_API_KEY")?)?;
// 1. Ask BinDist for the latest release (the API returns them newest-first)
let versions = client
.list_versions("myapp", &ListVersionsOptions::default())
.await?;
let Some(latest) = versions.items.first() else {
return Ok(()); // no releases published yet, nothing to do
};
// 2. Only update if the published release is newer than this build
if Version::parse(&latest.version)? > Version::parse(CURRENT_VERSION)? {
// 3. Get a short-lived, pre-signed download link
let info = client
.get_download_info("myapp", &latest.version, &GetDownloadInfoOptions::default())
.await?;
// info.url is a direct download that expires in 30 minutes
start_update(&info.url);
}
That example uses our Rust client, but you are not tied to Rust. The same handful of calls works from any language, and we maintain ready-made clients for the most common ones.
We publish official, open-source API clients so you can drop the update check into your app with a few lines. Prefer something else? The API is plain REST and JSON, so you can wrap it yourself.
Build auto-updating apps in Rust. Published on crates.io.
Build auto-updating apps and CLIs in Go.
Native client for auto-updating Delphi desktop apps.
For writing release and upload tooling, and as a reference implementation.
For build scripts and web frontends, and as a reference implementation.
No client for your stack? Authenticate with one header and call two endpoints. The docs include the raw HTTP for every call.
Whichever route you take, the full endpoint reference and request and response shapes live in the documentation. You can also import our Postman collection to try every Customer API call straight away.
The version-checking and download endpoints carry the metadata you need to drive update logic, not just a list of files.
Keep a stable channel for everyone and a test channel for early adopters. New versions stay disabled until you promote them, and clients opt into pre-release builds with a single request header.
Download URLs are pre-signed and expire after 30 minutes. Customers pull the file directly from object storage, so updates stay fast no matter how large the build.
Every release stays queryable with its notes, file size, and download count, so rollbacks and update prompts can reference any prior version.
Updates are scoped by API key. Each customer only ever sees and downloads the releases they are entitled to.
Publish new versions from the same pipeline that builds them, then let every customer's installer pick the release up automatically.
Start free with the open-source version, or let us run the release infrastructure for you.
View Pricing