--- title: Migrating from Capgo to Capawesome Cloud description: Complete guide to migrating your live update setup from Capgo to Capawesome Cloud for better reliability and Capacitor features. date: created: 2025-08-29 updated: 2026-08-11 authors: - robingenz categories: - Cloud - Guides faq: true --- # Migrating from Capgo to Capawesome Cloud If you're currently using Capgo for live updates and considering a switch to a more reliable, feature-rich platform, Capawesome Cloud offers a seamless migration path. With superior uptime, faster response times, and more competitive pricing, Capawesome Cloud provides everything you need for robust Over-the-Air updates. ## Why Migrate from Capgo? While Capgo has served as a live update solution for Capacitor apps, there are several compelling reasons to consider migrating to Capawesome Cloud. The platform offers significantly better reliability with 99.99% uptime compared to Capgo's 99.65%, translating to just 10 minutes of downtime versus 7 hours over the past 90 days. Response times are notably faster at 267ms versus 441ms, ensuring your users receive updates more quickly. Beyond performance metrics, Capawesome Cloud provides a more stable platform with fewer bug reports and patch releases, indicating a more mature and tested codebase. The pricing structure is more accessible, starting at $9/month with a free tier available, compared to Capgo's $14/month minimum. You also gain access to unique features like EU hosting options, Git integration, and unlimited updates that aren't available with Capgo. Security is not a trade-off in this migration: with both platforms, updates are delivered over HTTPS and can be signed with a private key that only you hold, so devices only install bundles that verifiably come from you. For a breakdown of what HTTPS, code signing, and encryption each protect in a live update pipeline, read [Capacitor Live Updates: Signing vs Encryption](./capacitor-live-updates-end-to-end-encryption.md). The Capawesome team brings deep expertise in Capacitor plugin development, with official Ionic Developer Experts on staff who understand the intricacies of the Capacitor ecosystem. This expertise translates into better support and more thoughtful feature development that aligns with Capacitor best practices. ## Prerequisites Before starting your migration from Capgo to Capawesome Cloud, make sure you have these requirements in place: - A Capacitor app currently using Capgo for live updates - Node.js version 18 or higher installed on your development machine - Access to your current Capgo configuration and deployment settings - Your app's bundle IDs and channel configurations from Capgo Take a moment to document your current Capgo setup, including any custom update strategies or configurations you've implemented. This will help ensure a smooth transition to Capawesome Cloud. ## Migration Overview The migration process from Capgo to Capawesome Cloud follows a structured approach designed to minimize disruption to your existing users. You'll begin by setting up your Capawesome Cloud account and configuring your app. Then you'll install the Capawesome Live Update SDK, replacing the Capgo plugin in your project. After updating your code to use Capawesome's API methods, you'll configure your desired update strategies. Finally, you'll build and deploy your first update through Capawesome Cloud. Throughout this process, you can maintain your existing update cadence and user experience patterns. The APIs are designed to be familiar, making the code migration straightforward while giving you access to enhanced capabilities. !!! tip "AI-Assisted Migration" For a more guided experience, add the [Capawesome skills](https://github.com/capawesome-team/skills){:target="_blank"} to your project with `npx skills add capawesome-team/skills --skill capawesome-cloud` and use the following prompt with your preferred AI coding assistant: ``` Use the `capawesome-cloud` skill from `capawesome-team/skills` to help me set up Capacitor Live Updates in my project. ``` ## Step 1: Setting Up Capawesome Cloud ### Create Your Account Start by visiting the [Capawesome Cloud Console](https://console.cloud.capawesome.io/){:target="_blank"} to create your account. The registration process is quick and gives you immediate access to the platform. Unlike Capgo, Capawesome Cloud offers a generous free tier that lets you test all features before committing to a paid plan. Once logged in, you'll find an intuitive dashboard where you can manage your applications, monitor update deployments, and access detailed analytics about your user base and update performance. The interface is designed to be familiar to anyone who has used live update platforms before, while offering enhanced visibility into your deployment pipeline. ### Create Your App In the Capawesome Cloud Console, navigate to the Apps section and click "Create App" to set up your first application. Enter a descriptive name for your app that will help you identify it easily in your dashboard. The system will generate a unique App ID that serves as the primary identifier for your application in all API calls and configurations. You'll want to configure channels that match your existing Capgo setup. If you're using channels like "production", "staging", or "development" in Capgo, you can create equivalent channels in Capawesome Cloud. This ensures a smooth transition without disrupting your existing deployment workflows. ## Step 2: Installing the Capawesome Live Update SDK Remove the Capgo plugin from your project and install the Capawesome Live Update plugin: ```bash npm uninstall @capgo/capacitor-updater npm install @capawesome/capacitor-live-update npx cap sync ``` The Capawesome Live Update plugin is built from the ground up for Capacitor, ensuring optimal performance and compatibility. It's fully open-source under the MIT license, giving you transparency into how your updates are handled and the freedom to contribute improvements if needed. ## Step 3: Configuring Your App Replace your Capgo configuration with the Capawesome Cloud settings in your Capacitor configuration file: === "TypeScript" ```typescript title="capacitor.config.ts" import { CapacitorConfig } from "@capacitor/cli"; const config: CapacitorConfig = { plugins: { LiveUpdate: { appId: "00000000-0000-0000-0000-000000000000", // Your Capawesome App ID defaultChannel: "production", // Optional: Your default channel autoDeleteBundles: true // Optional: Automatically clean up old bundles } } }; export default config; ``` === "JSON" ```json title="capacitor.config.json" { "plugins": { "LiveUpdate": { "appId": "00000000-0000-0000-0000-000000000000", "defaultChannel": "production", "autoDeleteBundles": true } } } ``` The configuration is intentionally streamlined compared to Capgo, focusing on essential settings while handling advanced behaviors through code. This gives you more flexibility in implementing custom update logic specific to your app's needs. Here's a full comparison of the relevant configuration options between Capgo and Capawesome Cloud: | Capgo | Capawesome Cloud | Notes | | -------------------- | ------------------- | -------------------------------------------------------------- | | `appReadyTimeout` | `readyTimeout` | | | `autoDeletePrevious` | `autoDeleteBundles` | | | `autoSplashscreen` | Not needed | Handled in code, see [Step 4](#step-4-replacing-the-capgo-sdk) | | `autoUpdate` | Not needed | Handled in code, see [Step 4](#step-4-replacing-the-capgo-sdk) | | `appId` | `appId` | | | `defaultChannel` | `defaultChannel` | | | `directUpdate` | Not needed | Handled in code, see [Step 4](#step-4-replacing-the-capgo-sdk) | | `periodCheckDelay` | Not needed | Handled in code, see [Step 4](#step-4-replacing-the-capgo-sdk) | | `publicKey` | `publicKey` | | | `resetWhenUpdate` | Not needed | Automatically handled by the SDK | | `responseTimeout` | `httpTimeout` | | | `statsUrl` | Not needed | | | `updateUrl` | `serverDomain` | Same purpose, different value | | `version` | Not needed | Native version code is used by the SDK | ## Step 4: Replacing the Capgo SDK ### API The migration from Capgo's API to Capawesome Cloud's API involves updating your method calls and adjusting some patterns. Here's how to translate the most common operations: #### Get Latest In Capgo, you might check for the latest available bundle using the `getLatest` method. Capawesome Cloud provides this functionality through the [`fetchLatestBundle(...)`](../../sdks/capacitor/live-update.md#fetchlatestbundle) method: **Capgo**: ```typescript import { CapacitorUpdater } from '@capgo/capacitor-updater'; const checkForUpdate = async () => { const latest = await CapacitorUpdater.getLatest(); if (latest.url) { console.log('Update available:', latest.version); } }; ``` **Capawesome Cloud**: ```typescript import { LiveUpdate } from '@capawesome/capacitor-live-update'; const checkForUpdate = async () => { const result = await LiveUpdate.fetchLatestBundle(); if (result.downloadUrl) { console.log('Update available:', result.bundleId); } }; ``` #### Download Downloading the update bundle is done using the `download` method in Capgo, while Capawesome Cloud uses the [`downloadBundle(...)`](../../sdks/capacitor/live-update.md#downloadbundle) method: **Capgo**: ```typescript import { CapacitorUpdater } from '@capgo/capacitor-updater'; const downloadUpdate = async () => { const latest = await CapacitorUpdater.getLatest(); if (latest.url) { const bundle = await CapacitorUpdater.download({ url: latest.url, version: latest.version }); console.log('Bundle downloaded'); } }; ``` **Capawesome Cloud**: ```typescript import { LiveUpdate } from '@capawesome/capacitor-live-update'; const downloadUpdate = async () => { const result = await LiveUpdate.fetchLatestBundle(); if (result.downloadUrl) { await LiveUpdate.downloadBundle({ bundleId: result.bundleId, url: result.downloadUrl }); console.log('Bundle downloaded'); } }; ``` #### Next To set a specific bundle as the next one to be loaded, you have to use the [`setNextBundle(...)`](../../sdks/capacitor/live-update.md#setnextbundle) method in Capawesome Cloud. **Capgo**: ```typescript import { CapacitorUpdater } from '@capgo/capacitor-updater'; const setNextBundle = async () => { await CapacitorUpdater.next({ id: 'bundle-id-123' }); }; ``` **Capawesome Cloud**: ```typescript import { LiveUpdate } from '@capawesome/capacitor-live-update'; const setNextBundle = async () => { await LiveUpdate.setNextBundle({ bundleId: 'bundle-id-123' }); }; ``` #### Reload Finally, if you want to apply the downloaded update directly, you have to use the `reload` functionality which works the same way in both platforms. **Capgo**: ```typescript import { CapacitorUpdater } from '@capgo/capacitor-updater'; const applyUpdate = async () => { await CapacitorUpdater.reload(); }; ``` **Capawesome Cloud**: ```typescript import { LiveUpdate } from '@capawesome/capacitor-live-update'; const applyUpdate = async () => { await LiveUpdate.reload(); }; ``` ### Live Update Strategies Capawesome Cloud supports flexible update strategies that can replicate and enhance your existing Capgo update behaviors: #### Background The background strategy silently downloads updates while your app runs, applying them seamlessly on the next launch: ```typescript import { LiveUpdate } from '@capawesome/capacitor-live-update'; // Check for updates on app launch const initializeApp = async () => { await LiveUpdate.sync(); // Your app initialization code }; initializeApp(); // Call once at app startup ``` This approach mirrors Capgo's default behavior and offers additional flexibility in managing updates. #### Always Latest This approach is our recommended strategy for ensuring users always have the latest version of your app in a timely manner: ```typescript import { App } from '@capacitor/app'; import { LiveUpdate } from '@capawesome/capacitor-live-update'; App.addListener('resume', async () => { const result = await LiveUpdate.sync(); if (result.nextBundleId) { const shouldReload = confirm('A new update is available. Would you like to install it now?'); if (shouldReload) { await LiveUpdate.reload(); } } }); ``` This strategy balances keeping your app updated with respecting user choice, allowing them to defer updates if they're in the middle of something important. #### Force Update The force update strategy ensures users have the latest version **before** they can use the app. This is useful for critical updates: ```typescript import { SplashScreen } from '@capacitor/splash-screen'; import { LiveUpdate } from '@capawesome/capacitor-live-update'; const initializeApp = async () => { const result = await LiveUpdate.sync(); if (result.nextBundleId) { await LiveUpdate.reload(); // Apply the update } else { await SplashScreen.hide(); // Hide the splash screen } }; initializeApp(); // Call once at app startup ``` While this ensures all users are on the latest version, use this strategy judiciously as it can impact the user experience if updates are frequent or large. ## Step 5: Building and Distributing Updates ### Build Your App Generate your web assets using your standard build process: ```bash npm run build ``` Ensure your build output directory (typically `www` or `dist`) contains all necessary assets. Capawesome Cloud uses intelligent diffing to create delta updates, so even if your initial bundle is large, subsequent updates will be minimal. ### Install Capawesome CLI Install the Capawesome CLI tool to manage your deployments: ```bash npm install -g @capawesome/cli@latest ``` The CLI provides powerful commands for bundle management, including creation, upload, and rollback capabilities. It's designed to integrate seamlessly with CI/CD pipelines, supporting both interactive and automated workflows. ### Deploy a Live Update Create and deploy your first bundle to Capawesome Cloud: ```bash npx @capawesome/cli apps:liveupdates:upload --app-id YOUR_APP_ID --channel production --path www ``` This command packages your web assets into a bundle and uploads it to Capawesome Cloud. The bundle becomes immediately available to your users through the channel you specified. You can automate this process in your CI/CD pipeline just as you did with Capgo. ## Migration Timeline A well-planned migration ensures minimal disruption to your users while maintaining continuous update capability throughout the transition. Here's a recommended timeline that balances thoroughness with efficiency: Begin with a pilot phase where you set up Capawesome Cloud and test the integration with a development build of your app. This typically takes 1-2 days and allows you to familiarize yourself with the platform's features and validate that all your update scenarios work correctly. Next, implement the SDK replacement in a feature branch, thoroughly testing each update strategy your app uses. Allocate 3-5 days for this phase, including comprehensive QA testing. Pay special attention to edge cases like network interruptions during updates or app backgrounding during the update process. Roll out the Capawesome-enabled version to a small group of beta users or internal testers. Monitor this group for 5-7 days, tracking metrics like update success rates, download times, and any user-reported issues. This controlled rollout helps identify any unexpected behaviors before full deployment. Finally, release the updated app to all users through your standard app store deployment process. Continue monitoring for the first week after release to ensure stability. Once confirmed, you can safely sunset your Capgo subscription while maintaining full update capabilities through Capawesome Cloud. ## FAQ ### Does the actual code migration take a day, or does the whole switch take weeks? Both, depending on what you're measuring. The code-level migration — swapping the SDK, updating method calls, adjusting config — typically takes less than a day of development time, since the APIs map closely. The multi-week timeline in this guide covers the full rollout process: a pilot phase, QA on each update strategy, a controlled beta rollout, and a monitoring period before fully sunsetting Capgo. You can move faster than that timeline if your app and risk tolerance allow it. ### Do I need to keep both Capgo and Capawesome Cloud running during the transition? Only temporarily, and only if you want a controlled rollout. The recommended approach ships the Capawesome-enabled version to a subset of users first (via a beta or internal testing group) while your main user base stays on the existing Capgo-delivered version, then you cut over fully once you've confirmed update success rates and stability — you don't need both running indefinitely, just during the validation window. ### Which Capgo config options don't have a direct Capawesome Cloud equivalent? Several are handled in code instead of config: `autoSplashscreen`, `autoUpdate`, `directUpdate`, and `periodCheckDelay` don't have config-file equivalents — you implement the equivalent behavior directly in your app's initialization code using the update strategies shown in this guide (Background, Always Latest, Force Update). `resetWhenUpdate`, `statsUrl`, and `version` aren't needed at all, since the SDK handles those automatically. ### Is there an official side-by-side comparison of Capawesome Cloud versus Capgo beyond this migration guide? Yes — see the [Capgo alternative](https://capawesome.io/alternatives/capgo/){:target="_blank"} comparison page for uptime, pricing, and feature differences beyond the API migration steps covered here. ### Does switching away from Capgo mean losing delta/diff-based updates? No — Capawesome Cloud uses its own intelligent diffing to generate delta updates, so subsequent bundles after your initial one stay small even though the underlying mechanism differs from Capgo's. You don't lose delta-update efficiency by migrating; it just comes from a different update-delivery implementation. ## Related Posts - [Capawesome Cloud: Alternative to Ionic Appflow](./alternative-to-appflow.md) - [Best CI/CD Platforms for Capacitor Apps in 2026](./comparing-ci-cd-platforms-for-capacitor-apps.md) - [The Best CI/CD Platforms for Cordova Apps in 2026](./comparing-ci-cd-platforms-for-cordova-apps.md) - [Migrating from App Center to Capawesome Cloud](./migrating-from-app-center-to-capawesome-cloud.md) - [Capacitor Live Updates: Signing vs Encryption](./capacitor-live-updates-end-to-end-encryption.md) ## Conclusion Migrating from Capgo to Capawesome Cloud brings immediate benefits in reliability, performance, and cost-effectiveness. The platform's superior uptime, faster response times, and robust feature set ensure your live update infrastructure is built on a solid foundation. With delta updates reducing data transfer and transparent pricing that scales with your app's growth, Capawesome Cloud represents a significant upgrade for your Over-the-Air update strategy. The migration process, while requiring some code changes, is designed to be straightforward and can typically be completed in less than a day of development time. The familiar API patterns and comprehensive documentation make the transition smooth, while the enhanced capabilities provide room for future growth and optimization. For assistance during your migration, the Capawesome team offers dedicated support to ensure your transition is successful. Visit the [Capawesome Cloud documentation](../../cloud/index.md) for detailed technical guides, explore the [Live Update plugin reference](../../sdks/capacitor/live-update.md) for API details, or [contact the support team](mailto:support@capawesome.io) for personalized migration assistance. Take control of your app's update infrastructure today with Capawesome Cloud and join the growing community of developers who've made the switch to a more reliable, feature-rich live update platform.