If you're adding authentication to a Capacitor app, one of the first questions you'll probably run into is: which approach should I use?
There are quite a few options: native Sign in with Apple/Google, Firebase Auth, OAuth/OIDC, passkeys, Better Auth, among many others, and the best choice depends on your backend, platforms, security requirements, existing infrastructure, and how much native code you want to maintain.
We put together a practical guide comparing the different approaches, including some of the platform-specific gotchas that are easy to miss when building for iOS and Android.
Hopefully it saves someone some time when deciding which direction to take:
Capacitor Grafana Faro v0.1.0 — a new unofficial Capacitor plugin for Grafana Faro observability. Cross-platform (Android, iOS, Web) with native crash reporting, ANR detection, and web auto-instrumentation.
First of all, thank you for creating such a well-crafted purchases plugin. The lightweight approach and direct StoreKit 2 / Google Play Billing integration is exactly what we need.
Our Use Case:
We're implementing a paywall that displays immediately when the app launches. On this paywall, we need to show users whether they're eligible for a free trial before they tap the purchase button. For example:
Eligible users see: "7 days free, then $9.99/month"
Ineligible users see: "$9.99/month"
This is crucial for setting proper user expectations and improving conversion rates.
Technical Considerations:
I understand the complexity here: iOS: StoreKit 2 provides Product.subscription.isEligibleForIntroOffer which checks eligibility based on the user's Apple ID purchase history. This is relatively straightforward to implement. Android: Google Play Billing doesn't provide a direct client-side eligibility check. The purchase history is limited to 12 months, making client-side determination less reliable.Questions:
Are you planning to add a checkTrialEligibility() method to the plugin?
If not currently planned, would you be open to adding this feature?
From your perspective, is there a technical reason not to expose iOS's isEligibleForIntroOffer API through the plugin?
Generating, showing and signing PDFs comes up a lot in business apps: invoices, contracts, reports, consent forms. Most end up with a WebView workaround that produces blurry, non-selectable PDFs.
We have 3 free, open source Capacitor plugins that cover the whole flow natively on Android and iOS:
📄 PDF Generator: turn HTML or a URL into a paginated, vector PDF with real page breaks (A4, Letter, landscape). Output goes to a file, so large reports don't exhaust memory.
👀 PDF Viewer: open the file in a native fullscreen viewer with zoom, paging and password-protected document support.
✍️ PDF Annotator: let the user draw, highlight and sign on top of it with the native markup tools. Apple Pencil on iPad. The original file is never modified, annotations are saved to a copy.
A typical flow: generate a contract, let your customer review and sign it on their phone or tablet, keep the signed copy.
All three use only official platform APIs, support CocoaPods and SPM, and track the latest Capacitor version.
If you're using any of these, tell us what you're building with them and what's missing.
We built Capver to solve a problem we kept running into: keeping version numbers in sync across iOS, Android, and web in Capacitor projects.
Every Capacitor project stores versions in multiple files — project.pbxproj on iOS, build.gradle on Android, and package.json on web. Updating them manually is tedious and easy to mess up, especially as your release cadence picks up.
Capver is a lightweight CLI that handles all of it with a single command. Here's what it can do:
Bump major, minor, or patch versions across all platforms at once
Sync all platforms to the highest version found automatically
Push mobile-only hotfixes without changing the semantic version
Generate build numbers from your version using a configurable pattern
It's open source (MIT) and available on npm as @capawesome/capver.
We just released @capawesome/capacitor-apple-sign-in, a Capacitor plugin that brings Apple Sign-In to Android, iOS, and Web.
On iOS it uses native AuthenticationServices, and on Android it implements the Apple OAuth flow via a WebView — no external dependencies needed. The Web implementation loads Apple's JS SDK automatically.
Key features:
Cross-platform: Android, iOS, and Web
Scope support for email and full name
Nonce for replay protection and state for CSRF protection
Lightweight with zero unnecessary bloat
If you're building a Capacitor app that needs Apple Sign-In (which is required on iOS if you offer any third-party login), this should save you from rolling your own implementation.
Hey everyone! We just published a complete guide to integrating Firebase Authentication in a Capacitor app. It's a long one because it covers the whole journey, not just the happy path:
Full setup: Firebase project, plugin installation, native config files for both platforms
Sign-in implemented end to end: email/password and Google (the two that exercise every part of the setup), plus pointers for Apple, phone, passwordless email, and custom tokens
Framework wiring: working authStateChange examples for Angular (including the NgZone gotcha), React, and Vue
User management: ID tokens for your backend, email verification, password reset, anonymous sign-in with account linking
Best practices: Firebase Emulator for development, server-side token verification, the ATT prompt if you use Facebook Login, and why fetchSignInMethodsForEmail() no longer works on new projects (Email Enumeration Protection returns an empty array since Sept 2023)
Troubleshooting: the classics, including Google Sign-In working in dev but failing after release (Play Store re-signs your app — you need the Play Console SHA-1 too)
There's also a working demo repo linked in the guide if you want to jump straight to code.
If you hit an auth issue that isn't covered, please tell us here, the troubleshooting section is exactly the kind of thing we want to keep growing with real cases.
As of April 28, 2026, every app or app update submitted to App Store Connect must be built with Xcode 26 and the iOS 26 SDK (or matching SDKs for iPadOS, tvOS, visionOS, watchOS). Apps already on the store keep working, but the next update has to be on the new toolchain.
For Capacitor apps, this is purely a toolchain change. Capacitor itself works fine with Xcode 26 — there's no app-side migration needed.
I just published a short write-up on what the change means and how Capawesome Cloud customers are affected. Both default build stacks (macos-sequoia and macos-tahoe) already ship Xcode 26 by default, so most builds are already compliant. The only case where action is needed is if you've pinned XCODE_VERSION=16.x via a reserved environment variable — in that case, remove the override or bump it to 26.x.
We just published a guide on integrating Better Auth into Ionic and Capacitor apps. Better Auth is an open-source, framework-agnostic authentication framework for TypeScript.
Since Capacitor apps run in a native WebView, the Better Auth JavaScript SDK works out of the box for standard auth flows like email and password — no plugins or special configuration needed. You only need Capacitor plugins for social login flows that require native functionality.
The guide covers:
- Setting up the Better Auth client in your Capacitor app
- Email and password authentication using the SDK directly
- Apple Sign-In using the native Capacitor plugin
- Google Sign-In using the native Capacitor plugin
- Using the OAuth plugin for other providers like Microsoft, LinkedIn, or Facebook
The general approach for social login is: use a Capacitor plugin to handle the native sign-in flow and get an ID token, then pass that token to Better Auth's signIn.social() method. Better Auth handles user management and sessions on the server side.
If you have questions or run into issues setting this up, happy to help.
Hey everyone! We just published a new guide about protecting sensitive content in your Capacitor app with the Privacy Screen plugin.
Quick test before you click: open your phone's app switcher. See your banking app? Your chats? Any private information? That snapshot the OS takes when you switch apps is exactly the problem this solves.
What the guide covers:
The app switcher fix: one enable() call swaps in a blank/branded screen the instant your app goes to background. Works on both platforms.
Screen capture blocking: on Android, enable() blocks screenshots and recordings outright. On iOS, Apple doesn't allow blocking the OS-level gesture, so there's an opt-in preventScreenshots option that uses an unofficial technique (test carefully before production).
Screenshot detection: the screenshotTaken event lets your app react when someone captures the screen, the pattern Snapchat built its reputation on. Works on iOS and Android 14+.
There's a runnable demo app: you can clone and try on iOS and Android to see the switcher blur in action.
If your app shows balances, chats, health data, OTP codes, or anything users consider private, this one's worth 10 minutes.
Anyone already using Privacy Screen in production? Would love to hear what you're protecting and if you hit any platform quirks, tell us here, that feedback goes straight into improving the plugin and its docs.
We just published a guide on background downloads, and it answers the question we get all the time: why does my download die when the user locks the phone?
Short version: a fetch runs in the web view, inside your app's process. iOS suspends that process a few seconds after backgrounding, and the download goes with it. Background-mode plugins don't help, the download still lives in the same process.
The Capacitor File Transfer plugin hands the transfer to the OS instead: a background URLSession on iOS, a dataSync foreground service on Android.
What survives what:
Backgrounded: keeps running on both.
OS kill for memory: iOS finishes it and delivers on relaunch. Android interrupts it, resumable from the bytes on disk.
Force-quit: canceled on both. iOS retries on relaunch if maxRetries > 0.
The guide also covers the AppDelegate hook you need on iOS, why listeners belong at app startup, and how to rebuild your download list after a relaunch.
We just released Capacitor Firebase 8.3.0. Most of the work landed in two plugins.
Cloud Firestore:
More supported data types — DocumentReference and Bytes now have dedicated classes, and NaN/Infinity values survive the Capacitor bridge instead of collapsing to null
getCountFromServer() now accepts compositeFilter and queryConstraints, so you can count a filtered subset without downloading the documents
A new serverTimestamps option ('estimate' / 'previous' / 'none') on snapshot listeners controls how pending server timestamps are returned
Remote Config:
New setDefaults() and getAll() methods
The source field (Static / Default / Remote) now works on Web too
No breaking changes — bump the packages and run npx cap sync.
Full write-up with code examples in the link. Happy to answer any questions.
You already know Live Updates let you ship fixes to your app in real time, no app store review. But do you actually know how it works? It's simpler than most people think, and understanding it will help you use it better.
The two layers
Every Capacitor app has two layers. The web layer: your HTML, CSS, and JS, loaded into the web view. The native layer: the compiled code (Java/Kotlin, Swift) plus your native plugins.
Here's the key detail: your web files are never compiled into the app binary. They ship inside the app package (the classic www/ folder), but they stay plain files. And plain files can be replaced.
Where your app actually loads from
The web view doesn't load your app from the internet. It loads it from a local origin served out of the app bundle, on Android via WebViewAssetLoader (https://localhost/), on iOS via WKURLSchemeHandler (app://localhost/). By default, that content is the www/ folder that was bundled when the binary was built.
What a Live Update actually does
A live update simply changes which folder those requests are served from:
The SDK downloads a new bundle from the server
Writes it to a local directory inside the app's sandbox
Registers it as the next bundle to use
On the next launch (or immediately, if you prefer), the web view serves your app from the new bundle instead of the built-in www/
That's it. No binary patching, no code injection. Just swapping the folder the web view reads from.
The constraint that is also the feature
Because only the web layer changes, live updates are limited to binary-compatible changes: HTML, CSS, JS, and assets. Add a plugin or touch native code, and you need a store release. But that same constraint is why it's fully compliant with both stores: Apple explicitly permits downloading interpreted code that doesn't change the app's primary purpose, and Google Play exempts code running in a webview from its self-update restrictions.
What the platform adds on top
The mechanism is simple. Running it in production is where it gets interesting: bundles delivered via global CDN, channels so the right devices get the right version, staged rollouts, one-click rollbacks when something goes wrong, and code signing so only you can publish updates to your app (the SDK verifies the signature before applying a bundle).