Despia vs Capacitor: The Real Cost Over 10 Years
What Despia and Capacitor actually cost at 1,000 MAU over 1, 5 and 10 years, including Capgo, store fees, and the developer you have to hire.
Capacitor is free and Despia costs $249 per app per OS. That comparison is true for about ten minutes, which is roughly how long it takes to discover that Capacitor is a library, not a delivery pipeline. The question worth answering is what each route costs once you add the store accounts, the over-the-air service, the build machine, and the person who has to keep a native project alive for a decade.
Here is the full arithmetic, with every number sourced and every assumption stated.
The scenario
Fixing the scenario matters more than the pricing pages, because both tools get cheap or expensive depending on who you are.
You already have a web app. React, Vue, Svelte, or something a no-code tool generated. It is built and hosted.
You ship it to both the App Store and Google Play.
It has 1,000 monthly active users.
You release web changes maybe six times a year.
You are not an iOS or Android developer, and you do not want to become one.
That last line is the one that moves the total by thousands of dollars, and it is the line most cost comparisons leave out.
Costs both routes pay
These are identical either way, so they are not the argument. Listing them anyway, because a total that hides them is not a total.
| Line item | Cost |
|---|---|
| Apple Developer Program | $99 per year |
| Google Play Console | $25 one time |
| Web hosting | Whatever you already pay |
Both routes ship under your own developer accounts. Neither tool holds your listing.
What Capacitor actually costs
Capacitor itself is MIT licensed and free forever. That is real and worth saying plainly. What is not free is everything Capacitor deliberately leaves to you.
Over-the-air updates. Capacitor has no update service. The standard answer is Capgo, and it is a good product. At 1,000 MAU you need the Solo plan, which is $12 a month billed annually at $146, and includes 2,000 MAU, 100 GiB of bandwidth, unlimited live updates, and one build hour a month. There is also a credits-only pay-as-you-go option at $0.003 per MAU plus $0.06 per GiB, which for a small app lands closer to $40 to $60 a year if you are willing to manage prepaid credits instead of a plan. Either way it is a subscription, and it is metered on how many people use your app.
A build machine. Historically this meant buying a Mac. It no longer has to. Capgo Native Build runs macOS M4 machines and includes App Store publishing on every plan, so the Mac requirement is gone if you are already paying for Capgo. Solo includes one build hour a month, with overage at $0.08 per build minute. For a two-platform release cycle that is roughly two to four full builds a month, which is enough for most small apps.
The person who maintains the native project. This is the line item that does not go away, and it is where the money is.
Capacitor generates ios/ and android/ folders that are yours to keep. That is the whole design. It means you own the Podfile, the Gradle config, the Info.plist, the Android manifest, the plugin versions, and the target SDK. Capgo's own documentation is explicit about the boundary: changes to capacitor.config.ts, native plugin configuration, native package installs or upgrades, and anything requiring npx cap sync all need a native app release, not a live update.
Two of those releases are mandatory every year whether your product changes or not:
Since April 28, 2026, every upload to App Store Connect must be built with Xcode 26 and the iOS 26 SDK. Apple resets this baseline annually.
From August 31, 2026, new Google Play submissions and updates must target Android 16 (API 36), and apps that fall below API 35 stop being discoverable to new users on newer devices. Google runs this on an annual clock too.
If you cannot do that work, you hire it. Rates for Capacitor finalization and store submission run roughly like this:
| Who you hire | Typical range | What it covers |
|---|---|---|
| Offshore freelancer | $150 to $350 | Native folders generated, icons and splash screens, base store config, binary upload |
| Experienced Capacitor freelancer | $400 to $800 | Native plugin setup, provisioning profiles, certificates, keystores, review guidance |
| Boutique agency or senior US/EU dev | $900 to $1,500+ | CI/CD pipeline, OTA service wiring, dedicated support through rejections |
Mobile developers generally bill $30 to $100 an hour, and a first store deployment is 4 to 12 hours of work. That is the setup fee. The part people do not budget for is that you come back to the same developer for two specific reasons, indefinitely.
Native plugin changes. Adding Bluetooth, swapping push providers, wiring in a new SDK, or even changing the app icon all modify the native project and require a rebuilt binary. Expect $50 to $200 per update. This is not a bug in Capacitor's design, it is the design: the native project is yours, so changing it is your job.
Annual OS breakers. Every year Apple and Google raise the submission floor and change privacy rules, and every year some plugin in your dependency tree stops compiling against the new SDK. Keeping a Capacitor app compiling and compliant runs $150 to $500 a year in general maintenance, and that is before you have shipped a single new feature.
Neither of those disappears in year three. They are the running cost of holding a native project you do not maintain yourself.
What Despia actually costs
$249 per app per OS, one time. One app on both stores is $498, paid once, for the life of the app.
Each license includes 200 cloud credits, and a build costs 5 credits, so that is 40 native builds per app per OS. A two-platform app starts with 80. At the release cadence in this scenario, two mandatory compliance rebuilds a year across both platforms plus the occasional icon or permission change, that is roughly a decade of releases before you buy a single build. If you do run out, builds come in packs of 10 for $25.
Some Despia users do burn through the whole allowance inside a year. That is almost always a workflow problem rather than a pricing one, because a build is for native changes and a web change that gets rebuilt instead of deployed over the air is a build spent for nothing. The table below still assumes a $25 pack every two years, which is deliberately pessimistic against an allowance that should cover the decade.
Builds are also flat rate. A build is a build: it is not metered by the minute, so a slow one costs the same as a fast one and there is no per-minute overage to model. Over-the-air updates are unlimited with no MAU metering. There is no plan, no renewal, and no line that scales with how many people open your app.
Web changes ship over the air the moment you deploy. Native changes still need a rebuild, exactly like Capacitor, because that is a store rule and not a tool limitation. The difference is what the two re-hire scenarios above cost you here.
A native plugin change, meaning a new capability, a different push provider, or a new icon, is a toggle in the dashboard and one build. That build spends 5 of the 200 credits your license came with, against $50 to $200 on the other route.
The annual OS breaker is not your line item at all. There is no ios/ folder in your repo to migrate to Xcode 26 and no targetSdk in a Gradle file you own. Keeping the runtime compiling against the current Apple and Google SDKs is the thing you bought, and it is covered for the life of the license.
Adding a native capability does not touch a native project either:
const isDespia = navigator.userAgent.toLowerCase().includes('despia')
if (isDespia) despia('successhaptic://')
No npm install, no npx cap sync, no native release to add a feature that was already compiled into the runtime.
The ten-year totals
Assumptions: one app on both stores, 1,000 MAU, six web releases a year, two mandatory native compliance rebuilds a year, Capgo Solo at the annual rate. Freelancer pricing taken at the middle of each range above: $600 for initial setup, $300 a year for OS compliance maintenance, and one native plugin change a year at $125. The Despia column assumes a $25 build pack every two years, which is conservative given two licenses already cover 80 builds. That is $425 a year in developer time, which is a conservative read of a $150 to $500 maintenance band plus $50 to $200 per native change.
| Despia | Capacitor, you own the native project | Capacitor, you hire it out | |
|---|---|---|---|
| Year 1 | $622 | $270 | $870 |
| 5 years | $1,068 | $1,250 | $3,550 |
| 10 years | $1,638 | $2,475 | $6,900 |
| Recurring per year after setup | $99 store fee, plus about $13 a year in builds | $245 | $670 |
| Your hours, year one | Under 2 | 20 to 30 | 0 |
| Your hours, per year after | Under 2 | 8 to 12 | 0 |
Three things fall out of that table.
The Capacitor DIY column is genuinely cheap in cash and expensive in hours. If you already write code, own the native project, and do not mind a yearly Xcode migration, Capacitor at $245 a year is a defensible number. Price your own 8 to 12 hours a year at anything above $30 an hour and the cash advantage disappears, but that is your call to make, not a number anyone can make for you.
The hired column is the one most no-code builders actually land in, because the whole reason they chose a web stack is that they do not write Swift. At $6,900 over ten years, the free library is the most expensive option on the table, and it stays expensive because the maintenance never ends.
Despia's cost is front-loaded and then nearly flat. After the license, the recurring lines are the $99 Apple fee that every route pays and about $13 a year in builds, and that build figure is a pessimistic placeholder rather than a bill you should expect.
The line that actually diverges: growth
The 1,000 MAU comparison is the friendly one for a metered service. Watch what happens when the app works.
| Monthly active users | Capgo annual | Despia annual |
|---|---|---|
| 1,000 | $146 (Solo) | $0 |
| 10,000 | $396 (Maker) | $0 |
| 100,000 | $998 (Team) | $0 |
| 1,000,000 | $2,490+ (Enterprise) | $0 |
Capgo counts MAU as distinct devices contacting Capgo in a rolling 30-day window, and the same device counts separately per native app ID. Despia does not meter update delivery at all. Over ten years, that is the difference between a cost that grows with your success and a cost that was fixed the day you bought it.
Why Despia costs more on day one
Two reasons, and neither is margin.
The first is that you are buying a runtime, not a library. Despia ships a compiled native layer with 50-plus device capabilities already in it, so the price includes the work that Capacitor pushes to plugin selection, native project maintenance, and your yearly SDK migration. You are paying up front for the job you would otherwise pay a freelancer to do twice a year.
The second is that it is a license, not a subscription. The $249 is the whole software cost, decided once, at a price that does not move when your user count does. That is a worse deal for someone who ships an app, gets 40 users, and abandons it. It is a much better deal for anyone whose app survives.
The obvious objection stands: a Despia app runs your web code in WKWebView and the Android WebView, and that is not SwiftUI. True. The answer is the 50-plus native capabilities exposed through one JavaScript call, and the fact that the full Xcode and Android Studio projects export whenever you want them. The license is not a cage.
When Capacitor is the right call
Plainly, because a comparison that never concedes anything is an ad.
You have an in-house mobile developer, or you are one. The native project is an asset in that case, not a liability, and the cash cost is low.
You need custom native code or a specific plugin that is not in Despia's feature set. Capacitor's plugin ecosystem is large and open, and writing your own plugin is a supported path.
You want the entire stack auditable and self-hostable. Capacitor is MIT, and Capgo's plugin and backend are open source under MIT and MPL-2.0, which matters in regulated environments.
You are already on Capacitor and shipping fine. Migration is a cost too, and "it works" is a real reason.
Common questions
Does Despia charge for each store update? No. Web changes ship over the air with no store review and no per-update fee. Native changes need a rebuild on any route, and on Despia it spends 5 credits from the 200 each license includes, which is 40 builds per app per OS. Beyond that, builds are $25 per pack of 10, flat rate with no per-minute metering. Annual OS compliance is covered by the license rather than billed as maintenance.
Is Capgo required with Capacitor? No, but something is. Capacitor has no update mechanism of its own, so without an OTA service every web change becomes a store release with a review wait.
Can I leave Despia later? Yes. The Xcode project and Android Studio project export at any time, and the app is registered under your own Apple and Google accounts throughout.
Does the 1,000 MAU assumption favor Despia? It favors Capgo, actually. Solo is the cheapest tier and 1,000 users sits at half its cap. The Despia advantage widens at every tier above it.
What if I already own a Mac and know Xcode? Then run the middle column. Capacitor at $245 a year is a fair price for a route where the maintenance is already inside your skill set.
Ship one app, not two
If you are going to keep building in your web stack, keep building there. Despia ships that app to the App Store and Google Play, gives it native device access, and updates it over the air, from the one codebase you already have.
Learn more about Despia in the docs or start building at despia.com.
