Migrate from Capgo

A Capacitor app leaves Capgo by replacing @capgo/capacitor-updater with @hotcodepush/capacitor-live-updates at its next store release. The store build that carries the new SDK is the switch, and the builds before it keep taking Capgo updates until their users move. What differs, side by side, is on the site's Capgo alternative page.

HotCodePush serves no Capgo-compatible endpoint, so the plugin's updateUrl cannot be pointed at it. Three things Capgo has are not here: end-to-end encryption of bundles, a default channel set on the server, and self-hosting. Bundles are signed and verified, not encrypted, the channel is in the build, and there is no self-hosted edition.

AI-assisted migration (recommended)Copy Anchor Link

Install the HotCodePush skills:

npx skills add hotcodepush-team/skills

Then paste the prompt into your coding agent:

Migrate this app from Capgo to HotCodePush: install the skills with `npx skills add hotcodepush-team/skills`, then run the hotcodepush-migrate skill, following https://hotcodepush.com/docs/migrate/capgo.

The agent removes the Capgo plugin, runs init, maps channels, config keys, SDK calls and binary ranges, and reports a checklist for the store release. It never touches Capgo, and the first release waits for the store build. Agent skills explains what the agent does.

PrerequisitesCopy Anchor Link

• You have a HotCodePush account and an organization. npx hotcodepush init creates both, as the quickstart shows.
• The app is a Capacitor app on a supported major. The minimum versions are on Supported versions, and Capgo serves older ones that HotCodePush does not.
• A store release lies ahead: the swap ships in a native build, so plan an App Store and a Play Store submission.
• Node.js is on every machine that makes a native build, since the build step runs the CLI from an Xcode phase and a Gradle task.

StepsCopy Anchor Link

If you already removed the plugin and ran init, skip to step 4.

1. Freeze a branch for the old buildsCopy Anchor Link

git branch capgo-fleet

A bundle built from the migrated code imports a native module the old binaries lack. Hotfixes for them come from a branch that keeps the old client.

2. Remove the Capgo pluginCopy Anchor Link

npm uninstall @capgo/capacitor-updater

Delete the CapacitorUpdater block from plugins in capacitor.config.ts. Delete the CapacitorUpdater.notifyAppReady() call and its import from the entry file, or from plugins/capacitorUpdater.client.ts in a Nuxt app. Replace every call and listener per the SDK calls below, then run npx cap sync.

Keep .capgo_key_v2 where the Capgo hotfix job reads it: the branch of step 1 still uploads with it.

3. Run initCopy Anchor Link

npx hotcodepush init

init signs you in, picks or creates the organization and the app with its production channel, installs @hotcodepush/capacitor-live-updates and writes hotcodepush.json. It wires the build step, an Xcode phase and one apply from line in android/app/build.gradle. The Capacitor SDK's Installation page shows the manual steps for a project it could not edit.

It asks whether to generate a signing key, which Sign your bundles explains, while Capgo's encryption key stays with Capgo. Decline the first release for now.

Then import the package in the app's entry file, where notifyAppReady() was, even when no call follows:

import '@hotcodepush/capacitor-live-updates';

The import reports the first render, which is what notifyAppReady() did. An app that imports the package late, or not at all, confirms no update, and every one is rolled back after readyTimeoutSeconds.

4. Create the channels your Capgo channels hadCopy Anchor Link

production exists. Each further Capgo channel becomes one here, with a name of letters, digits, - and _:

npx hotcodepush channel create --name beta --discoverable

--discoverable is Capgo's "Allow device self-assignment": setChannel({ name }) resolves the name on the device, as Channels describes. Without it the channel is reachable by its id alone. A build that set defaultChannel sets channel in hotcodepush.json or HOTCODEPUSH_CHANNEL in its build environment instead, as Set up environments and tenants shows.

5. Ship the store release that carries the SDKCopy Anchor Link

Build and submit the release as before, an Xcode archive and a Gradle release variant. The build step runs binary create inside the build and registers it with its fingerprint, so the machine needs npx hotcodepush login or HOTCODEPUSH_TOKEN. Under CI a store build without a token fails. npx hotcodepush binary list shows the registered builds, and there is no native version to compare against afterwards.

6. Release from your pipelineCopy Anchor Link

npm run build && npx hotcodepush release create --bundle-version "$(git rev-parse --short HEAD)" --yes

This line replaces npx @capgo/cli bundle upload --channel production --apikey "$CAPGO_TOKEN". With HOTCODEPUSH_TOKEN and, for a signing app, HOTCODEPUSH_SIGNING_KEY in the environment, it is the whole pipeline step. The command reads webDir from capacitor.config. Ship every commit is the pipeline it sits in.

Open the app on a device that runs the new store build: the release applies within about a minute (How an update reaches a device). If nothing happens, see Troubleshooting.

7. Run both until the fleet movesCopy Anchor Link

A binary carries one plugin: a Capgo bundle never reaches a HotCodePush build, and the reverse. Keep the Capgo plan and pipeline while old builds have users. Capgo's MAU shows how many still check in. Capgo has no free plan after its trial, so stop once the old builds are below the share you leave behind, then cancel Capgo.

CLI commandsCopy Anchor Link

Capgo's bundle versions were unique semver. Here a bundle is numbered per app, and its version label is free text (Bundles and releases). Capgo calls a store binary a release, while here a release is a bundle put on a channel, numbered per channel. The CLI reference lists every command.

What maps to whatCopy Anchor Link

The Capacitor SDK's Configuration page lists every key with its type and default.

SDK callsCopy Anchor Link

The Capacitor SDK's API page has every method, event and type. On the web every method rejects with Capacitor's UNIMPLEMENTED error, where Capgo answered unavailable, so guard the calls with Capacitor.isNativePlatform().

Before and afterCopy Anchor Link

The CapacitorUpdater block leaves capacitor.config.ts:

import type { CapacitorConfig } from '@capacitor/cli';

const config: CapacitorConfig = {
  appId: 'com.example.app',
  appName: 'Example',
  webDir: 'dist',
  plugins: { 
    CapacitorUpdater: { 
      autoUpdate: 'atBackground', 
      defaultChannel: 'production', 
    }, 
  }, 
};

export default config;

hotcodepush.json takes its place at the project root. Capgo applied an update when the app went to the background, while the default next_start waits for a cold start. The closest moment is next_resume with no minimum background time:

{
  "appId": "<your app id>",
  "channel": "production",
  "applyStrategy": "next_resume",
  "nextResumeMinimumBackgroundSeconds": 0
}

notifyAppReady() goes, and the import takes its place in the entry file:

import { CapacitorUpdater } from '@capgo/capacitor-updater'; 
import '@hotcodepush/capacitor-live-updates'; 

CapacitorUpdater.notifyAppReady(); 

What differsCopy Anchor Link

• Testers switch on the device: Capgo's console overrides and forced device mappings have no counterpart. A tester calls setChannel() or opens a link, as Switch channels by link sets up, and release create --device <id> targets one device.
• The fingerprint replaces the version comparison: no --disable-auto-update and no --min-update-version. A release never lands on a build whose native code differs, and a --binary-version range narrows it to store versions. A release older than the binary is never served. See Compatibility.
• Rollouts are deterministic: a device's bucket is a hash of its id and the release id, not a random pick cached for 30 days. Auto-pause runs on every release, 5 percent over 50 applied updates by default. See Roll out gradually.
• Rollback is a release: release rollback publishes an earlier bundle as a new release, mandatory by default. release revoke ends a release, and channel pause is Capgo's unlink. See Roll back a release.
• Deltas need no flag: a device fetches the files it lacks as one pack, with nothing to set per upload or channel.
• Debug builds take updates by default, where Capgo had a toggle per channel. isEnabledInDebugBuilds: false turns it off per build, and there is no emulator switch.
• listChannels() has no counterpart: name the channels in the app or serve them from your backend.

Next stepsCopy Anchor Link

• Roll out gradually: start a release at a small percentage, let it progress and let auto-pause stop a bad one.
• Sign your bundles covers the key init offered, and the store build that refuses an unsigned release.
• Test with preview channels gives every pull request an expiring channel and a QR code for testers, in place of get-qr.
• Capacitor SDK reference documents every hotcodepush.json key, method, event, type and reason of the SDK you installed.