How to Add a Chatbot to Your Mobile App: Android, iOS, Flutter & React Native SDKs (2026)

Most chatbot platforms offer mobile "support" through a WebView — an embedded browser window that loads the web chat widget inside your app. It looks cheap, performs poorly, and breaks constantly. Here is why a native SDK is fundamentally different:

Native SDK vs WebView: The Real Difference

Conferbot provides true native SDKs for all four major mobile platforms: Android (Kotlin + Jetpack Compose), iOS (Swift + SwiftUI), Flutter (Dart), and React Native (TypeScript). Not wrappers. Not WebViews. Real native components that look and perform exactly like the rest of your app.

What You Get with Native SDKs

• 50+ node types: Text, choices, carousels, calendars, file uploads, ratings, location pickers, and more — all rendered natively
• Real-time messaging: Socket.IO connections with automatic reconnection
• Offline support: Messages queue locally and sync when connection returns
• Live agent handover: Seamless bot-to-human transition with typing indicators
• Push notifications: FCM (Android) and APNs (iOS) integration
• Knowledge base: In-app search through your documentation
• Full theming: Match your app's color scheme, typography, and design language
• Voice messages: Record, send, and playback audio messages
• Message reactions: Emoji reactions on messages
• Analytics: 20+ event types tracked automatically

Requirements

• Android Studio Arctic Fox or later
• Min SDK 21 (Android 5.0)
• Kotlin 1.9+
• Gradle 7.0+

Step 1: Add the Dependency

Add to your app-level build.gradle:

dependencies {
    implementation 'com.conferbot:android-sdk:1.0.0'
}

Step 2: Initialize

In your Application class or Activity:

val conferbot = ConferBot.initialize(
    context = this,
    botId = "YOUR_BOT_ID",
    config = ConferBotConfig(
        theme = ConferBotTheme.Light,
        enablePushNotifications = true,
        enableOfflineQueue = true
    )
)

Step 3: Show the Chat

Option A — Drop-in Composable (recommended):

@Composable
fun MyScreen() {
    ConferBotChatView(
        botId = "YOUR_BOT_ID",
        modifier = Modifier.fillMaxSize()
    )
}

Option B — Floating Action Button:

ConferBotFAB(
    botId = "YOUR_BOT_ID",
    position = FABPosition.BottomEnd
)

Option C — Headless (for custom UI):

val state = conferbot.chatState.collectAsState()
// Build your own UI using state.messages, state.isTyping, etc.
conferbot.sendMessage("Hello!")

Architecture

The Android SDK uses Jetpack Compose for the UI layer with a Kotlin-first API. It follows Material Design 3 guidelines with full dark mode support. Data persistence uses Room database for chat history and message queue. The SDK weighs approximately 2MB and adds minimal overhead to your app size.

Requirements

• Xcode 14.0+
• iOS 14.0+
• Swift 5.7+

Step 1: Install via CocoaPods or SPM

CocoaPods:

pod 'Conferbot', '~> 1.0'

Swift Package Manager:

// In Xcode: File > Add Package Dependencies
// URL: https://github.com/conferbot/conferbot-ios

Step 2: Initialize

import Conferbot

ConferBot.shared.configure(
    botId: "YOUR_BOT_ID",
    options: .init(
        theme: .light,
        enablePushNotifications: true,
        enableOfflineQueue: true
    )
)

Step 3: Show the Chat

Option A — SwiftUI (recommended):

struct ContentView: View {
    var body: some View {
        ConferBotChatView(botId: "YOUR_BOT_ID")
    }
}

Option B — UIKit:

let chatVC = ConferBotChatViewController(botId: "YOUR_BOT_ID")
present(chatVC, animated: true)

Option C — Modal presentation:

ConferBot.shared.presentChat(from: self)

Architecture

The iOS SDK provides both SwiftUI and UIKit interfaces. The primary implementation uses SwiftUI with Combine for reactive state management. UIKit support is provided through a ChatViewController wrapper for apps that have not yet adopted SwiftUI. The SDK supports both light and dark mode with full customization through ConferBotCustomization.

Requirements

• Flutter 3.10+
• Dart 3.0+
• iOS 12.0+ / Android API 21+

Step 1: Add the Dependency

dependencies:
  conferbot_flutter: ^1.0.0

Then run: flutter pub get

Step 2: Initialize

import 'package:conferbot_flutter/conferbot_flutter.dart';

await ConferBot.initialize(
  botId: 'YOUR_BOT_ID',
  config: ConferBotConfig(
    theme: ConferBotTheme.light(),
    enableOfflineQueue: true,
  ),
);

Step 3: Show the Chat

Option A — Drop-in Widget (recommended):

Scaffold(
  body: ConferBotChatWidget(
    botId: 'YOUR_BOT_ID',
  ),
)

Option B — Floating Action Button:

ConferBotFAB(
  botId: 'YOUR_BOT_ID',
  position: FABPosition.bottomRight,
)

Option C — Headless with Provider:

ConferBotProvider(
  botId: 'YOUR_BOT_ID',
  child: Consumer<ConferBotState>(
    builder: (context, state, _) {
      // Build custom UI from state
    },
  ),
)

Architecture

The Flutter SDK uses Provider for state management with Hive for local storage. It renders all 50+ node types with Flutter-native widgets — no platform views or WebViews involved. The SDK supports both Material and Cupertino design patterns and includes voice message recording and playback with the audio processing handled natively.

Cross-Platform Advantage

With Flutter, you get a single codebase that deploys to both iOS and Android. The Conferbot Flutter SDK ensures your chatbot looks and behaves consistently across platforms while still respecting platform-specific conventions (Material Design on Android, Cupertino on iOS).

Requirements

• React 17.0.0+
• React Native 0.70.0+
• TypeScript 5.x (recommended)

Step 1: Install

npm install @conferbot/react-native
# or
yarn add @conferbot/react-native

Step 2: Initialize

import { ConferBotProvider } from '@conferbot/react-native';

export default function App() {
  return (
    <ConferBotProvider
      botId="YOUR_BOT_ID"
      config={{
        theme: 'light',
        enableOfflineQueue: true,
        enablePushNotifications: true,
      }}
    >
      <YourApp />
    </ConferBotProvider>
  );
}

Step 3: Show the Chat

Option A — Drop-in Component (recommended):

import { ChatWidget } from '@conferbot/react-native';

function ChatScreen() {
  return <ChatWidget style={{ flex: 1 }} />;
}

Option B — Floating Widget:

import { ConferBotWidget } from '@conferbot/react-native';

// Add anywhere in your app
<ConferBotWidget position="bottom-right" />

Option C — Headless Hook:

import { useConferBot } from '@conferbot/react-native';

function CustomChat() {
  const { messages, sendMessage, isTyping, isConnected } = useConferBot();
  // Build completely custom UI
}

Architecture

The React Native SDK is written in TypeScript with complete type definitions. It uses React Context for state management and AsyncStorage for persistence. The MessageList component uses a virtualized FlatList for performance with thousands of messages. An emoji picker with 1,000+ emojis and skin tone selector is included. All 50+ node types are rendered as native React Native components — no WebView anywhere in the SDK.

All SDKs Share the Same Backend

Regardless of which SDK you choose, you get the same bot logic, same knowledge base, same analytics, and same live agent handover. Build your bot once in the Conferbot builder, and it works identically across all platforms.

Integration Patterns

All four SDKs support three integration patterns:

1. Drop-in Widget: Add a pre-built chat component to your app with 3 lines of code. Handles everything — UI, state, networking, persistence. Best for getting started fast.
2. Floating Button: A floating action button that opens the chat in a modal or bottom sheet. Non-intrusive, available from any screen. Best for support chatbots.
3. Headless Mode: Access the SDK's state and functions without any pre-built UI. Build your own chat interface with full control over every pixel. Best for apps with strict design systems.

Choosing between a native SDK and a WebView wrapper is not just an architectural preference — it has measurable impacts on performance, battery life, memory consumption, and user experience. We benchmarked Conferbot's native SDKs against three popular WebView-based chatbot implementations across identical test scenarios on mid-range devices (Samsung Galaxy A54 for Android, iPhone 13 for iOS).

Load Time Benchmarks

The cold start difference is particularly critical. A 2-3 second load time for a WebView chatbot means users see a blank screen or loading spinner before the chat interface appears. With native SDKs, the chat UI renders almost instantly, keeping the interaction seamless.

Memory Usage Comparison

Memory matters because mobile devices are resource-constrained. A WebView wrapper running at 140 MB competes with the rest of your app for limited RAM. On lower-end Android devices with 3-4 GB RAM, this can trigger the OS to kill background processes, causing your app to lose state. Native SDKs stay lean, leaving resources available for your core app features.

Battery Impact

Battery drain from WebView wrappers is a hidden cost that directly impacts user satisfaction. Apps with high battery consumption receive lower App Store ratings and higher uninstall rates. Users notice when an app "eats battery" even if they cannot identify the chatbot widget as the cause.

Frame Rate and Animation Smoothness

Native SDKs render UI at a consistent 60 frames per second (fps) using platform-native animation frameworks (Core Animation on iOS, Compose animation on Android). WebView wrappers typically render at 30-45 fps with visible jank during scrolling, typing, and message transitions. On older devices, WebView frame rates can drop to 15-20 fps, creating a noticeably sluggish experience.

The bottom line: native SDKs deliver a fundamentally superior user experience across every measurable dimension. If your app handles sensitive or high-frequency chat interactions, the native approach is not optional — it is essential. For apps where the chatbot is a secondary feature used occasionally, WebView can work, but you accept measurable trade-offs in performance and polish. Review our chatbot builder documentation for SDK installation guides across all platforms.

App Size Impact

A common concern for mobile teams is SDK bloat — how much does adding a chatbot SDK increase your app's download size? Here is the comparison:

Native SDKs are slightly larger on disk but dramatically lighter at runtime. Most dependencies (Compose, Room, OkHttp on Android; SwiftUI on iOS) are already included in modern apps, so the marginal size increase is often just 1-2 MB. For context, a single high-resolution product image is typically 0.5-2 MB — the entire chatbot SDK adds less weight than a few photos.

Network Efficiency

Native SDKs also outperform WebView wrappers in network usage. A WebView-based chatbot downloads the full web chat interface (HTML, CSS, JavaScript, fonts) on every cold start — typically 500KB-2MB of data. Native SDKs only transmit message payloads over WebSocket connections, averaging 1-5KB per message exchange. For users on metered data plans or in areas with slow connectivity, this difference matters. The native SDK's offline queuing further reduces network dependency, allowing conversations to continue even with intermittent connectivity — a common scenario in many markets where mobile chat adoption is highest.

Testing and Quality Assurance

Before shipping a native chat SDK to production, run these benchmarks on your own app to establish your baseline and catch any integration-specific performance regressions:

Run these tests on at least 3 devices: a flagship (iPhone 15 Pro or Pixel 8 Pro), a mid-range device (Samsung A54 or iPhone 13), and a low-end device (Samsung A14 or iPhone SE). Performance on low-end devices is your true benchmark — that is where most global users experience your app. Integrate these tests into your CI/CD pipeline to catch performance regressions before they ship to users. For teams using Conferbot's SDKs, all benchmarks above are met out of the box on supported minimum OS versions — but always validate in your specific app context, as other SDK integrations and app complexity can affect overall performance.

For teams evaluating multiple chat SDK vendors, create a standardized benchmark suite using the table above and run it against each vendor's SDK in your actual app environment. The results will differ from vendor-published benchmarks because real-world apps have competing resource demands. A chat SDK that performs well in isolation may degrade significantly when sharing resources with your app's core features — video playback, maps rendering, or heavy image processing. Testing in your production environment is the only way to get accurate performance data. Choose the SDK that performs best under realistic conditions, not the one with the most impressive marketing benchmarks. Our platform comparison guide evaluates SDK quality alongside other factors like AI capabilities, channel coverage, and pricing to help you make an informed decision.

Mobile chatbots handle sensitive data — customer names, email addresses, payment details, health information, and conversation history. Security and privacy are not optional features; they are foundational requirements that affect your compliance posture, App Store approval, and user trust.

Data Encryption Standards

A production-grade mobile chat SDK must implement encryption at every layer:

Conferbot's native SDKs implement all five layers by default. The Android SDK uses the Android Keystore system, and the iOS SDK leverages the Secure Enclave for key storage — meaning encryption keys never leave the hardware security module and cannot be extracted even if the device is compromised.

Local Data Storage and Retention

Chat SDKs store data locally for offline support and conversation persistence. Ensure your SDK handles local storage responsibly:

• Encrypted database: Chat history should be stored in an encrypted local database (SQLCipher for Android Room, encrypted Core Data for iOS). Plain-text SQLite databases are a vulnerability.
• Automatic data purging: Configure retention periods — conversations older than 90 days are purged automatically from the device. This limits exposure if a device is lost or stolen.
• Secure file storage: Uploaded images, voice messages, and documents should be stored in the app's sandboxed storage directory, not on external/shared storage where other apps could access them.
• Session token management: Authentication tokens should have short expiration windows (1-24 hours) with automatic refresh. Never store long-lived tokens in SharedPreferences or UserDefaults without encryption.

Compliance Requirements by Industry

App Store Security Requirements

Both Apple and Google enforce security standards for apps that handle user data:

• Apple App Store: Apps must declare all data collection in the Privacy Nutrition Label. Chat SDKs that use WebView are flagged more frequently during review because WebViews can load arbitrary content. Native SDKs with well-defined data flows pass review more reliably.
• Google Play: The Data Safety section requires disclosure of all data types collected, stored, and shared. SDKs that phone home to undisclosed third-party domains trigger rejection. Ensure your chat SDK's data flow is fully documented.

Security Best Practices for Implementation

1. Never hardcode API keys. Use environment variables or a secure configuration service. A hardcoded bot ID in your source code is discoverable through reverse engineering.
2. Implement certificate pinning. Prevent man-in-the-middle attacks by pinning your chatbot server's SSL certificate in the SDK configuration.
3. Audit third-party dependencies. Run npm audit (React Native), flutter pub deps (Flutter), or dependency scanning tools to ensure no SDK dependency has known vulnerabilities.
4. Enable biometric authentication for chat history access in sensitive applications (healthcare, financial). The SDK should support FaceID, TouchID, and Android BiometricPrompt as gating mechanisms.
5. Log redaction: Ensure chat logs sent to your analytics platform redact PII (email addresses, phone numbers, card numbers) before transmission.

Security is a differentiator. When enterprise clients evaluate chat SDKs, the security documentation and compliance certifications often outweigh feature comparisons. Invest in getting it right from the start, and it becomes a competitive advantage rather than a last-minute scramble. For platforms that handle security out of the box, see our no-code chatbot builder comparison.

Offline Message Queuing

When the user loses connection (subway, airplane mode, weak signal), messages are queued locally. When connection returns, they sync automatically in order. The user never loses a message, and the conversation continues seamlessly. This is critical for real-world mobile usage where connectivity is intermittent.

Session Persistence

Close the app. Open it a week later. The conversation picks up exactly where it left off. Chat history is stored locally (Room on Android, Core Data on iOS, Hive on Flutter, AsyncStorage on React Native) and synced with the server. No "start over" frustration.

Push Notifications

When the bot or a live agent sends a message while the app is in the background, the user gets a push notification. Tapping the notification opens the chat directly. Supports FCM (Android/Flutter/React Native) and APNs (iOS). Configure notification priority, sound, and grouping.

Knowledge Base Search

Users can search your knowledge base directly within the chat interface. Five dedicated views (search, results, article detail, categories, related articles) provide a full self-service help center embedded in your app.

Voice Messages

Users can record and send voice messages. Playback includes waveform visualization and duration display. Supported on Flutter and React Native SDKs. Ideal for accessibility, hands-free use cases, and markets where voice messaging is preferred over text.

Message Reactions

Users can react to messages with emojis. The React Native SDK includes a full emoji picker with 1,000+ emojis and skin tone selection. Reactions are synced across devices and visible in your analytics dashboard.

Theming

Every SDK supports comprehensive theming:

• Android: Material Design 3 with dynamic color support
• iOS: SF Symbols, system colors, respects system dark mode
• Flutter: Full ThemeData customization
• React Native: ThemeProvider with light/dark mode switching

Match your app's exact color palette, typography, border radius, and spacing. The chatbot feels like a native part of your app, not a bolted-on third-party widget.