This guide was originally published on the Hailbell blog.
Short answer: Use a package that wraps a vendor's native iOS and Android SDKs, configure it once in
main(), and wire its reply push into thefirebase_messagingsetup you probably already have. Subscription app on RevenueCat or Superwall: Hailbell shows each customer's plan and purchases next to the chat (it's our product). Bug reports with console and network logs: Gleap (its mobile session replay is in beta). Already on Freshworks: Freshchat's package. Open source or self-hosted: Chatwoot's package, which shows the chat in a web view. Committed to Intercom, Crisp or Zendesk: their popular Flutter packages are community-made, so check who maintains them before you ship.
Disclosure up front: I build Hailbell, one of the options here. The steps below use Hailbell's Dart API as the example because I can vouch that it compiles, but each step is a decision you make with any SDK: where the button goes, how users are identified, how replies reach a closed app, and how the chat is deleted.
Native app instead? The same decisions in Swift and Kotlin are in the iOS guide and the Android guide.
What a Flutter app needs from a support chat
Flutter draws your UI, but a support chat leans on the parts of the phone Flutter doesn't own: push tokens, notification taps that launch the app, the photo picker, and background isolates. That's why the package matters more than the chat bubble design.
-
Both platforms from one Dart API. One
open()call, oneidentify(), with the platform code hidden in the plugin. - Native screen or web view. A chat drawn by the vendor's native SDK handles the keyboard, photo picker and dark mode like the rest of the phone. A web view is quicker for the vendor to ship and can feel like a web page inside your app.
- Reply push that works when the app is closed. On Android that's FCM. On iOS it's APNs, either directly or through FCM.
- Signed identity. A token from your backend, not a user ID the app sends in plain text.
- A delete call for account deletion, which both stores require.
Flutter support chat packages on pub.dev
"Has a Flutter SDK" on a vendor's site can mean an official plugin or a community one. pub.dev shows who published each package, and that's the first thing to check. Versions and publishers below were read from pub.dev on November 21, 2026.
| Tool | Package | Published by | Latest version | Notes |
|---|---|---|---|---|
| Hailbell | hailbell |
Hailbell (no verified publisher badge yet) | 1.0.4 | iOS and Android. Wraps Hailbell's native Swift and Kotlin SDKs, so the chat is a native screen. |
| Gleap | gleap_sdk |
gleap.io (verified) | 19.5.1 | Android, iOS and web. Support chat plus in-app bug reporting. |
| Freshchat | freshchat_sdk |
freshworks.com (verified) | 0.10.36 | Android and iOS. The package description calls it beta. |
| Chatwoot | chatwoot_client_sdk |
chatwoot.com (verified) | 0.1.0 | Depends on flutter_inappwebview: the website widget in a web view, or your own UI on Chatwoot's API. |
| Intercom | intercom_flutter |
A third-party developer, not Intercom | 9.6.38 | Community plugin around Intercom's SDKs. |
| Crisp | crisp_chat |
No verified publisher | 3.0.0 | Community plugin. Crisp's developer docs list iOS, Android and React Native SDKs. |
| Zendesk | zendesk_messaging |
No verified publisher | 3.7.1 | Community plugin around the Zendesk Messaging SDK. Zendesk's SDK page lists no official Flutter SDK. |
A community plugin can be fine. Many are well kept. The risk is timing: when the vendor ships a new native SDK, or Apple changes something, you wait on a volunteer. Look at the issue tracker and the date of the last release before you build on one.
1. Add the package and set the minimum versions
flutter pub add hailbell
Native-wrapping plugins inherit the native SDK's minimums. Hailbell's needs Flutter 3.27 or later, iOS 16 (platform :ios, '16.0' in ios/Podfile if you use CocoaPods, and the Runner's Minimum Deployments set to 16.0) and Android 8, so minSdk = 26 in android/app/build.gradle.kts. Check the equivalent lines in your vendor's README before you blame Flutter: a minimum version mismatch is a common first build error.
2. Configure once in main()
Configure before runApp, after WidgetsFlutterBinding.ensureInitialized(). A reply notification can launch your app cold, straight into the chat, so the SDK has to be ready before the first frame. iOS and Android usually get separate app IDs, so pick by platform:
import 'dart:io';
import 'package:flutter/material.dart';
import 'package:hailbell/hailbell.dart';
const _iosAppId = 'app_XXXXXXXX';
const _androidAppId = 'app_YYYYYYYY';
Future<void> main() async {
WidgetsFlutterBinding.ensureInitialized();
await Hailbell.configure(appId: Platform.isIOS ? _iosAppId : _androidAppId);
runApp(const YourApp());
}
Keep every chat call in one small class of your own. If you ever switch vendors, you change one file.
3. Put the entry points where people get stuck
A "Chat with us" row in Settings is where people look first. Add one near the paywall too: "does this sync to my iPad?" is a question people ask right before they pay, and an answer then is worth more than one a day later. Skip the floating bubble over your whole UI; on a phone it covers your own buttons.
An unread badge matters more than it looks. If someone denies notifications, the badge is how they find your reply:
ValueListenableBuilder<int>(
valueListenable: Hailbell.unreadCount,
builder: (context, unread, _) => IconButton(
onPressed: () => Hailbell.open(),
icon: Badge(
isLabelVisible: unread > 0,
child: const Icon(Icons.headset_mic_outlined),
),
),
)
4. Identify users with a signed token
If your app has no accounts, let the chat belong to the install and move on. If users sign in, you want one conversation across their phone and tablet, and the safe way is a token your backend signs. A user ID or email sent straight from the app can be swapped by anyone with a proxy, and then they read someone else's chat.
// After your own sign-in succeeds. Your backend signs an HS256 JWT
// with the app's identity secret, with sub set to your user id.
Future<void> onSignedIn(String jwtFromYourBackend) =>
Hailbell.identify(identityToken: jwtFromYourBackend);
// On sign-out, so the next person on this device starts clean.
Future<void> onSignedOut() => Hailbell.reset();
Apps on Firebase Auth can skip the backend: Hailbell's identify also takes a function that returns the current Firebase ID token, and checks it against your Firebase project. Never put a signing secret in the app. Anything in the binary can be pulled out.
5. Send context, including what they paid
The point of in-app chat over email is context you didn't have to ask for. App version, OS and locale usually come for free. Add the plan, and the ID your purchases tool knows the person by:
import 'package:purchases_flutter/purchases_flutter.dart';
Future<void> updateSupportContext({required bool isPro}) async {
await Hailbell.setMetadata({
'plan': isPro ? 'pro' : 'free',
'revenueCatUserId': await Purchases.appUserID, // or 'superwallUserId'
});
}
With the Superwall or RevenueCat webhook connected in the dashboard, that ID lets Hailbell show the customer's plan and purchase history beside the chat. "Restore isn't working" reads very differently when you can see they bought a yearly plan yesterday.
6. Deliver replies with push
A chat only works if people find out you answered. Most Flutter apps already use firebase_messaging, and the support SDK should plug into it rather than fight it. Two Flutter-specific rules:
-
The background handler has rules. Firebase's Flutter docs say it must be a top-level function, not anonymous and not a class method, and on Flutter 3.3.0 or later it needs
@pragma('vm:entry-point')(Firebase docs). It runs in its own isolate, so initialize Firebase inside it. -
iOS has two tokens.
getToken()returns an FCM token;getAPNSToken()returns the APNs one. A service that sends through APNs directly needs the APNs token. Hailbell is one of those, and its plugin picks up the APNs token by itself on iOS.
import 'dart:io';
import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'package:hailbell/hailbell.dart';
@pragma('vm:entry-point')
Future<void> _onBackgroundMessage(RemoteMessage message) async {
await Firebase.initializeApp();
final handled = await HailbellPush.handleMessage(message.data,
title: message.notification?.title, body: message.notification?.body);
if (handled) return;
// your own background pushes
}
Future<void> setUpPush() async {
FirebaseMessaging.onBackgroundMessage(_onBackgroundMessage);
FirebaseMessaging.onMessage.listen((message) async {
final handled = await HailbellPush.handleMessage(message.data,
title: message.notification?.title, body: message.notification?.body);
if (handled) return;
// your own foreground pushes
});
if (Platform.isAndroid) {
final token = await FirebaseMessaging.instance.getToken();
if (token != null) await Hailbell.setPushToken(token);
FirebaseMessaging.instance.onTokenRefresh.listen(Hailbell.setPushToken);
}
}
On iOS, also add the Push Notifications capability to the Runner target, and in AppDelegate.swift set UNUserNotificationCenter.current().delegate = self before calling super.application(...), so a tap that launched the app reaches the plugin. Ask for notification permission after the first message the user sends ("Want a notification when we reply?"), not on first launch.
7. Delete the chat with the account
If users can create an account, Apple's guideline 5.1.1(v) and Google Play's account deletion policy both require an in-app way to delete it, and support messages are part of that data. Call the SDK's delete method inside your deletion flow, and stop if it fails, so a retry deletes both:
Future<bool> deleteAccount() async {
try {
await Hailbell.deleteData();
} on HailbellException {
return false; // Hailbell unreachable: show an error and let the user retry.
}
await deleteAccountOnYourBackend(); // your own API call
return true;
}
8. Test the whole loop on real builds
- Open the chat from every entry point and send a message with a photo.
- Check the message arrives with version, device and plan attached.
- Close the app fully, reply from your side, and check the push arrives on both platforms.
- Tap the push with the app closed and check it opens the conversation, not the home screen.
- Deny notifications and check the unread badge shows your reply.
- Sign out, sign in as someone else, and check the old conversation is gone.
- Test iOS push twice: a build from Xcode uses the sandbox APNs environment, TestFlight uses production.
Mistakes to avoid
- Passing the FCM token on iOS to a service that wants APNs. With many services nothing errors. Pushes just never arrive.
- Showing a notification for every data message. Support SDKs send silent data messages (Hailbell sends one to learn whether someone deleted the app). Show only messages your code recognises, or users get blank notifications.
-
Configuring inside a widget's
initState. A notification tap can start the app on a different route, before that widget exists. - Promising "instant" replies. If you're one person in one time zone, "we usually reply within a day" is honest and still good.
Where Hailbell fits
Hailbell is in-app support chat and push for iOS, Android and the web. The Flutter package wraps the native SDKs, so your customers get the same native chat as a Swift or Kotlin app, with photos, an offline cache and the chat's words in 14 languages. An AI answers first from your notes, prices and help articles, and you finish the reply from the dashboard, Discord, Telegram or Slack; the customer gets a push when you answer. From the chat you can send an offer that opens one of your paywalls (Hailbell.onPaywall), or a review card once a problem is solved: on iOS it opens the App Store's write-review sheet, on Android the app's Play Store listing. Bug reports with a screenshot are built in, off by default.
Where it's not the right pick: the Flutter plugin covers iOS and Android only, not Flutter web or desktop. Bug reports carry a screenshot, device details and recent screens, but no logs or session replay; Gleap goes further there. Hailbell doesn't import chat history from another tool. And because the native SDKs ship inside the plugin, a Hailbell SDK update reaches customers only when you update the package and release your app.
Pro is $29 a month for up to 10,000 monthly active users, and Scale is $79 a month for up to 100,000. There's a 14-day free trial with no card, and a 14-day money-back guarantee on the first payment: ask within 14 days, while AI replies have used under 20% of the plan's monthly AI allowance. The full Flutter setup is in the docs.
Questions
Which support chat tools have an official Flutter package?
On pub.dev, checked November 21, 2026: Gleap (gleap_sdk, verified publisher gleap.io), Freshchat (freshchat_sdk, verified publisher freshworks.com, labelled beta), Chatwoot (chatwoot_client_sdk, verified publisher chatwoot.com) and Hailbell (hailbell, published by Hailbell without a verified publisher badge). The most used packages for Intercom, Crisp and Zendesk come from other developers, not from those companies.
Can I build a support chat in Flutter myself?
Yes, with Firestore or any backend plus firebase_messaging for reply pushes. The chat screen is the easy part. The work is the inbox your team answers from, push for replies when the app is closed, signed identity so nobody can read someone else's chat, deletion, and photo uploads. Most teams buy that part.
Why don't my iOS reply pushes arrive in a Flutter app?
Check three things: the Push Notifications capability is on for the Runner target, the APNs key is uploaded to whichever service sends the push, and you passed the token that service expects. firebase_messaging gives you an FCM token from getToken() and an APNs token from getAPNSToken(); a service that talks to APNs directly needs the APNs one.
Does the Hailbell Flutter plugin work on Flutter web or desktop?
No. The hailbell package supports iOS and Android only. Hailbell has a separate web chat for websites, but the Flutter plugin does not wrap it.
Top comments (0)