How to add support chat to a Flutter app (2026 guide)

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.

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.

ToolPackagePublished byLatest versionNotes
HailbellhailbellHailbell (no verified publisher badge yet)1.0.4iOS and Android. Wraps Hailbell's native Swift and Kotlin SDKs, so the chat is a native screen.
Gleapgleap_sdkgleap.io (verified)19.5.1Android, iOS and web. Support chat plus in-app bug reporting.
Freshchatfreshchat_sdkfreshworks.com (verified)0.10.36Android and iOS. The package description calls it beta.
Chatwootchatwoot_client_sdkchatwoot.com (verified)0.1.0Depends on flutter_inappwebview: the website widget in a web view, or your own UI on Chatwoot's API.
Intercomintercom_flutterA third-party developer, not Intercom9.6.38Community plugin around Intercom's SDKs.
Crispcrisp_chatNo verified publisher3.0.0Community plugin. Crisp's developer docs list iOS, Android and React Native SDKs.
Zendeskzendesk_messagingNo verified publisher3.7.1Community 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:

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

  1. Open the chat from every entry point and send a message with a photo.
  2. Check the message arrives with version, device and plan attached.
  3. Close the app fully, reply from your side, and check the push arrives on both platforms.
  4. Tap the push with the app closed and check it opens the conversation, not the home screen.
  5. Deny notifications and check the unread badge shows your reply.
  6. Sign out, sign in as someone else, and check the old conversation is gone.
  7. Test iOS push twice: a build from Xcode uses the sandbox APNs environment, TestFlight uses production.

Mistakes to avoid

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.

Wiring this into your Flutter app and stuck on a step? Start a chat with us. It's the same chat your users would get.