Kotlin
Android Chat SDK
TalkJS’s Kotlin Data API is a native, headless SDK for adding real-time chat to Android apps. You build the UI, TalkJS handles real-time messaging, presence, and delivery.
Everything you need for real-time Android messaging
Every core messaging feature you need to build a native Android chat experience, backed by the Kotlin Data API.
Show when someone’s typing in a conversation. Indicators clear automatically after 10 seconds or when a message is sent.
Let users share a location pin directly in a conversation, with a map preview that makes meeting points easy to find.
OlegTrack message delivery and read status for each participant, or check when everyone in a conversation has read a message.
Upload and send files, images, videos, and voice recordings, with metadata such as dimensions and duration captured for you.
Explore Travel
now
Flight update
Check in online for your Singapore flight tomorrow. Upgrade to priority boarding.
Register a user’s Firebase Cloud Messaging token to notify them of new messages when your app isn’t in the foreground.
Format messages with bold, italics, links, mentions, and inline code. Add reactions with up to 50 different emojis per message.
Get started in three steps
Install the Kotlin Data API and connect your first user in three steps.
01
Add the Gradle dependency
Add com.talkjs:core to your module-level build.gradle.kts. Replace <latest_version> with the current version on Maven Central.
dependencies {
implementation("com.talkjs:core:<latest_version>")
}02
Initialize a session
Create a session for the current user with your TalkJS app ID, found on the Settings page of your TalkJS dashboard.
import com.talkjs.core.getTalkSession
val session = getTalkSession(
appId = "<APP_ID>", // Replace with your own app ID
userId = "<USER_ID>", // Replace with a user ID
)03
Add internet permission
TalkJS connects to its servers over the internet, so add this permission to your AndroidManifest.xml:
<uses-permission android:name="android.permission.INTERNET"/>You’re now ready to create conversations, send messages, and subscribe to real-time updates.
Read the full Kotlin Data API docs
Bring your own UI, we handle the real-time data
The Kotlin Data API is a headless messaging layer built with Kotlin Multiplatform. It connects to TalkJS over WebSocket as a specific, authenticated user, and exposes coroutine-based functions for creating conversations, sending messages, and subscribing to real-time updates. You render that data using whatever UI approach fits your app (Jetpack Compose, XML views, or a mix) with no TalkJS-provided components in the render path.
Because it’s built on Kotlin Multiplatform, the same session and data-layer code can also run in JVM environments (Java 11+), such as a desktop companion app or a backend service, without rewriting your chat logic.
Native Android chat UI Components are on our roadmap. Get in touch if you’d like early access.
Connect AI agents via REST and webhooks
Power AI agents and LLM-backed conversations by pairing your Android chat with the TalkJS REST API and webhooks. You can trigger a response, route to a bot, or hand off to a human agent, all from your own backend. TalkJS doesn’t bundle a specific AI or bot framework, so you stay in control of the model and logic you use.
A typical pattern: a webhook fires when a user sends a message, your backend calls an LLM, and the REST API sends the response back into the conversation. Because this all happens server-side, your Android client doesn’t need any special handling, it just receives the AI’s reply as a normal message.
Works with your stack
In addition to the native Kotlin Data API for Android, TalkJS also supports cross-platform mobile, web, and server-side integrations.
Cross-platform mobile
If your app targets both Android and iOS from a single codebase, choose a cross-platform SDK instead.
Build a custom chat UI in Dart that runs on both Android and iOS from one codebase.
Pre-built chat UI components for React Native apps.
Web
Add chat to a web app with pre-built UI components for your framework.
Server-side
Connect to chat data from your backend to manage users, conversations, and messages, or to power AI agents and integrations.
Built for every messaging need
See how teams use TalkJS’s Kotlin Data API to build chat for their Android app, across industries and use cases.
Buyer-seller messaging with file sharing and push notifications, so deals don’t stall when waiting for a reply.
Add white-label, in-app messaging to your Android app without building or maintaining your own real-time infrastructure.
Driver-rider or provider-customer chat for delivery, ride-hailing, and field service apps, with real-time presence and push notifications.
Pair the Android client with the REST API and webhooks to power AI agents and LLM-backed conversations.
Foodies
Channel5 members
Multi-participant conversations with typing indicators, read receipts, and reactions, ready for team or community chat in your app.
Patient-provider messaging with location sharing and file or image attachments for care coordination.
We saved 1,000+ hours on maintenance and development, with zero downtime as the platform expanded globally.
How TalkJS compares for Android
See how TalkJS’s Kotlin Data API compares with other Android chat providers on language support, UI options, and pricing.
 TalkJS |  Sendbird |  Stream | |
|---|---|---|---|
| Paid plan starting price | TalkJS Basic: $239/month, 10,000 MAU included | Sendbird Starter: $349 /month, 5,000 MAU included | Stream Start: $399/month, 10,000 MAU included |
| Free tier | TalkJS Free for development | Sendbird Free trial, no overages | Stream Free tier, max. 1,000 MAU |
| Android SDK language | TalkJS Kotlin | Sendbird Kotlin, Java | Stream Kotlin, Java |
| Pre-built Android UI Kit | TalkJS On roadmap | Sendbird UIKit for Android View | Stream UI Components, Jetpack Compose |
| Push notifications | TalkJS Yes | Sendbird Yes | Stream Yes |
| Minimum Android version | TalkJS Android 7.0 (API 24+) | Sendbird Android 5.0 (API 21+) | Stream Android 5.0 (API 21+) |
FAQs
TalkJS offers Android chat through the Kotlin Data API, a native, headless SDK built with Kotlin Multiplatform. It connects to TalkJS as a specific user over WebSocket and gives you coroutine-based access to conversations, messages, and real-time updates, so you can build your own chat UI with Jetpack Compose or XML.
The right choice depends on your app’s needs. TalkJS’s Kotlin Data API is a strong fit if you want a native, headless API with full UI control rather than a pre-built component library. See how TalkJS compares with other providers for SDK language, requirements, and pricing.
It’s headless. TalkJS handles real-time messaging, delivery, and state, while you build and own the chat UI. Pre-built Android UI Components are on the roadmap, but aren’t available yet. In the meantime, you get full control over how your chat looks and behaves.
Yes. The Kotlin Data API is built with Kotlin Multiplatform and also supports JVM environments (Java 11+), such as desktop or backend services. iOS support is planned for a future update.
Yes. In addition to the native Kotlin Data API, TalkJS offers a Flutter Data API that runs on both Android and iOS from a single Dart codebase. Choose Kotlin for a fully native Android app, or Flutter if you’re building cross-platform.
Yes. TalkJS delivers push notifications via FCM (Android) and APNs (iOS) to notify users of new messages even when the app is closed or offline.
Use the TalkJS REST API and webhooks to connect your conversations to an AI or LLM backend. A webhook can notify your server when a message arrives, and the REST API sends the AI’s response back into the conversation, no changes needed on the Android client. This way you can trigger responses, route to a bot, or hand off to a human agent.
TalkJS is free for development mode with full feature access. You’re only required to subscribe to a paid plan once you go live with real users. See Pricing for details.
Yes. The Kotlin Data API lets you upload and send images, videos, audio, and voice recordings directly from your app, with metadata such as dimensions and duration captured automatically. See file sharing in the Kotlin docs for details.