Tauri updater: auto updates for Tauri apps

The Tauri updater plugin lets your app check a URL for a new version, verify its signature, and install it. Here's the full setup for Tauri 2, the two feed formats, and how to send updates only to licensed customers.

A paper plane carrying a small parcel

The Tauri updater is an official plugin that adds in-app updates to a Tauri app on macOS, Windows and Linux. Your app asks an endpoint whether there's a newer version. If there is, it downloads the update, checks its signature against a public key built into the app, installs it, and restarts.

Setting it up takes five steps: add the plugin, generate a signing key, configure the endpoint, write the few lines that check for updates, and publish a feed. This guide follows the Tauri 2 documentation as it stood on November 17, 2026.

1. Add the plugin

From your project folder:

npm run tauri add updater

That adds the Rust crate, registers the plugin and installs the JavaScript bindings. To restart the app after an update you'll also want the process plugin:

npm run tauri add process

If you'd rather do it by hand, add the crate from the src-tauri folder and register it in lib.rs:

cargo add tauri-plugin-updater --target 'cfg(any(target_os = "macos", windows, target_os = "linux"))'
tauri::Builder::default()
    .setup(|app| {
        #[cfg(desktop)]
        app.handle().plugin(tauri_plugin_updater::Builder::new().build());
        Ok(())
    })

Then allow the plugin's commands in src-tauri/capabilities/default.json. Plugin commands are blocked by default, and forgetting this is why check() fails with a permissions error:

{
  "permissions": ["updater:default", "process:allow-restart"]
}

2. Generate a signing key

Every Tauri update is signed. The documentation is clear that this can't be turned off. It's separate from code signing with Apple or Microsoft: this signature is how your installed app knows an update really came from you.

npm run tauri signer generate -- -w ~/.tauri/myapp.key

You get two things:

  • A public key, which goes into tauri.conf.json and ships inside the app
  • A private key, which signs each update and must stay secret

Look after the private key. If you lose it, you can't publish updates to the people who already have your app installed, because their copy only trusts updates signed with that key. Put it in your password manager and in your CI secrets on day one.

When you build, the private key has to be in the environment. .env files aren't read:

export TAURI_SIGNING_PRIVATE_KEY="Path or content of your private key"
export TAURI_SIGNING_PRIVATE_KEY_PASSWORD=""

3. Configure tauri.conf.json

{
  "bundle": {
    "createUpdaterArtifacts": true
  },
  "plugins": {
    "updater": {
      "pubkey": "CONTENT FROM PUBLICKEY.PEM",
      "endpoints": [
        "https://releases.myapp.com/{{target}}/{{arch}}/{{current_version}}"
      ]
    }
  }
}
  • createUpdaterArtifacts tells the bundler to produce the update files and their signatures when you build
  • pubkey is the content of the public key. It can't be a file path
  • endpoints is a list of URLs to ask. HTTPS is enforced in production builds. Tauri only moves on to the next URL if the previous one returned an error status

The URL can contain three variables that Tauri fills in at runtime:

Variable Value
{{target}} linux, windows or darwin
{{arch}} x86_64, i686, aarch64 or armv7
{{current_version}} The version of the app that's asking

With createUpdaterArtifacts on, a build produces these alongside your normal installers:

Platform Update file Signature
macOS myapp.app.tar.gz myapp.app.tar.gz.sig
Windows myapp-setup.exe or myapp.msi the same name with .sig
Linux myapp.AppImage myapp.AppImage.sig

On Windows and Linux the update file is the same installer your customers first download. On macOS it's a separate archive of the .app.

4. Check for updates in your app

In JavaScript:

import { check } from '@tauri-apps/plugin-updater';
import { relaunch } from '@tauri-apps/plugin-process';

const update = await check();
if (update) {
  console.log(`found update ${update.version} with notes ${update.body}`);
  await update.downloadAndInstall();
  await relaunch();
}

check() returns null when the app is already current. downloadAndInstall() also takes a callback with Started, Progress and Finished events if you want a progress bar, and you can call update.download() and update.install() separately to download in the background and install when the user agrees.

The same thing in Rust:

use tauri_plugin_updater::UpdaterExt;

async fn update(app: tauri::AppHandle) -> tauri_plugin_updater::Result<()> {
  if let Some(update) = app.updater()?.check().await? {
    update.download_and_install(|_, _| {}, || {}).await?;
    app.restart();
  }
  Ok(())
}

Two things to know. On Windows the app exits by itself when the install step runs, which is a limitation of Windows installers, so save the user's work before you call it. And nothing checks on a schedule for you: call check() at launch, and again on a timer if your app stays open for days.

5. Publish a feed

The endpoint can answer in one of two ways.

A static JSON file

One file that lists the latest version for every platform. You can host it anywhere that serves files, such as GitHub Releases or a storage bucket.

{
  "version": "1.4.0",
  "notes": "Export to PDF, and a fix for the sync crash.",
  "pub_date": "2026-11-17T10:00:00Z",
  "platforms": {
    "darwin-aarch64": {
      "signature": "CONTENT OF myapp.app.tar.gz.sig",
      "url": "https://releases.myapp.com/1.4.0/myapp_aarch64.app.tar.gz"
    },
    "windows-x86_64": {
      "signature": "CONTENT OF myapp-setup.exe.sig",
      "url": "https://releases.myapp.com/1.4.0/myapp_x64-setup.exe"
    }
  }
}

version, and a url and signature for each platform, are required. The signature is the content of the .sig file pasted in, not a link to it. Tauri validates the whole file before it looks at the version, so one malformed platform entry breaks updates for every platform.

If you build with the official tauri-action on GitHub, it generates this file for you.

A dynamic update server

Here the server decides. The app sends its platform, architecture and current version in the URL, and the server replies:

  • 204 No Content if there's no update
  • 200 OK with a JSON body if there is
{
  "version": "1.4.0",
  "pub_date": "2026-11-17T10:00:00Z",
  "url": "https://releases.myapp.com/1.4.0/myapp_aarch64.app.tar.gz",
  "signature": "CONTENT OF myapp.app.tar.gz.sig",
  "notes": "Export to PDF, and a fix for the sync crash."
}

A dynamic server is more work, and it's what makes staged rollouts, beta channels and per-customer rules possible, because the server sees who's asking before it answers.

Updates only for licensed customers

If you sell your app, you may not want everyone with an old copy to receive every new version for ever. The usual cases are a subscription that lapsed, a refund, or a paid upgrade to a new major version.

The updater can send request headers with the update check, so the app can identify the customer:

const update = await check({
  timeout: 30000,
  headers: {
    Authorization: `Bearer ${licenseKey}`,
  },
});

The server then has to check that license on each request and answer 204 or 200 accordingly. That's a dynamic update server that knows about your licenses, and building one means building license storage, per-platform release management and file hosting.

LicenseSeat provides it. You upload each release, and it serves the Tauri feed for your product in both forms:

{
  "plugins": {
    "updater": {
      "pubkey": "<the pubkey from your dashboard>",
      "endpoints": [
        "https://licenseseat.com/p/<product-slug>/tauri/{{target}}/{{arch}}/{{current_version}}"
      ]
    }
  }
}

With the feed set to licensed, a request without a valid license key gets no update, while the version the customer has keeps working. The same license key also gates the app itself, with device limits and offline validation; the guide to licensing Tauri apps covers that side, and the guide to shipping desktop updates covers the feed in detail. LicenseSeat charges a flat monthly fee and takes 0% of your revenue.

Windows install modes

On Windows you can choose how the installer behaves during an update:

{
  "plugins": {
    "updater": {
      "windows": {
        "installMode": "passive"
      }
    }
  }
}
Mode What the user sees
passive A small window with a progress bar, and no clicks needed. The default, and the recommended one
basicUi A basic installer window that needs the user to click through
quiet Nothing. The installer can't ask for admin rights in this mode, so it only works for per-user installs. Generally not recommended

Common problems

check() always returns null. Make sure the version in the feed is higher than the version in tauri.conf.json, and that the feed has an entry for the platform key the app is asking for, such as darwin-aarch64. Downgrades are blocked by default.

Signature verification fails. The pubkey in the installed app doesn't match the private key that signed the update, or the signature in the feed is a path or URL when it should be the content of the .sig file. The signature also changes with every build, so a feed that points at a rebuilt file with an old signature fails.

No .sig files after building. createUpdaterArtifacts isn't set, or TAURI_SIGNING_PRIVATE_KEY wasn't in the environment when you ran the build.

"Not allowed" or a permissions error. updater:default is missing from your capabilities file.

It works in development and fails for customers on macOS. The updater's signature and Apple's code signature are different things, and you need both. The updater signature gets an update accepted by your app; your Developer ID signature and notarization are what let macOS open the app when a customer first downloads it. The page on the "app is damaged" message explains how to check a build, and on Windows the equivalent is signing with SignTool.

Common questions about the Tauri updater

Does Tauri have auto update?

Yes, through the official updater plugin. It isn't on by default: you add the plugin, generate a signing key, set an endpoint, and call check() from your app.

Can I disable signature checking in the Tauri updater?

No. Tauri's documentation says the updater needs a signature to verify that an update is from a trusted source, and that this can't be disabled.

What happens if I lose the Tauri signing key?

You can't publish updates to existing installs. Their copy of the app only trusts updates signed with the matching private key, so customers would have to download and install a new build by hand.

Is the Tauri updater signature the same as code signing?

No. The updater signature is checked by your own app. Code signing and notarization are checked by macOS and Windows. A release needs both.

Do I need a server for Tauri updates?

Not necessarily. A static JSON file on GitHub Releases or any file host works. You need a dynamic server only if you want the response to depend on who's asking, for example for staged rollouts or licensed updates.

How do I migrate updates from Tauri 1 to Tauri 2?

Set createUpdaterArtifacts to "v1Compatible" so Tauri 2 builds produce update files that Tauri 1 apps can install. Once your users are on version 2, change it to true. Tauri's documentation says the compatibility setting will be removed in version 3.

Can the Tauri updater send a license key or token?

Yes. check() accepts a headers option in JavaScript, and the Rust builder has a header method, so you can send an Authorization header that your update server validates.