Chat looks simple until you try to build it. A message list, an input box, maybe a send button. Then you hit the real work: keeping messages in order across flaky mobile networks, syncing history when the app comes back from the background, showing the right unread counts on two devices at once, routing push notifications so people actually return to the conversation. A React Native chat SDK exists so you do not rebuild all of that from scratch. This guide covers what these SDKs actually are, what a good one includes in 2026, and how to pick one without regretting it six months in.
What a React Native chat SDK actually is
A chat SDK is not one thing. Every serious offering is really three layers, and understanding the split matters because vendors draw the lines differently.
1. UI components
Prebuilt React Native components: message lists, input bars with attachment pickers, channel lists, avatars, reaction pickers, thread views. This layer decides how fast you can ship a first version. Good component kits are themeable down to individual message bubbles; weak ones lock you into the vendor’s look and you end up forking them anyway. Some teams skip vendor UI entirely and build on the client SDK below, which is a legitimate choice if chat is core to your product’s identity.
2. Client SDK
The JavaScript (or TypeScript) library that manages the connection, local state, and the hard synchronization problems: WebSocket or XMPP connection lifecycle, reconnection with backoff, message ordering, local caching, and delivering events (new message, typing, presence) to your components. This is where the engineering value lives. UI you can rewrite in weeks; a battle-tested sync engine takes years.
3. Backend
The server that stores messages, fans them out to participants, enforces permissions, and triggers push notifications. Here the market splits cleanly: hosted SaaS backends (you get an API key, they run everything, you pay per monthly active user) versus self-hostable or open source servers you run on your own infrastructure. Regulated industries, healthcare and finance especially, increasingly require the second option because message data cannot leave their environment.
When you evaluate any product, ask which of the three layers it actually provides and how tightly they are coupled. An SDK with great UI but a closed hosted backend is a very different commitment than an open source stack you can run and modify yourself.
Core features to expect in 2026
The baseline has moved a long way since this article was first written in 2021. These are table stakes now, and the details are where products differ.
- Offline support and sync. Messages composed offline should queue locally and send on reconnect. History should be cached so the app opens to a usable conversation with no network. Check how the SDK resolves conflicts and gaps after long offline periods, because this is where cheap implementations fall apart.
- Optimistic sends. A sent message should appear in the list instantly, marked pending, then confirm or fail visibly. If the demo app shows a spinner on every send, the sync layer is thin.
- Typing indicators and presence. Standard, but look at how they are transported. Ephemeral events should not hit the persistent message store, and presence should degrade gracefully when the socket drops.
- Read receipts and delivery states. Per-message delivered and read states, ideally with per-participant granularity in groups. Some platforms surface these as “delivery ticks”, same feature, different name.
- Media handling. Image, video, and file attachments with client-side compression, thumbnail generation, resumable uploads, and access control on the stored files. Ask where media lives and who can fetch a raw URL.
- Push notification routing. The genuinely annoying one. The backend must know which devices to notify, skip users who are actively viewing the conversation, collapse notifications sensibly, and deep link into the right chat on tap, through both APNs and FCM. Test this early; it is the feature most likely to eat an unplanned sprint.
- Moderation. Word filters, user muting and banning, message reporting, and admin APIs to remove content. If your app has user-generated content and public rooms, app store review will expect this, and so will your users.
- Threads, reactions, and mentions. Users trained by Slack and WhatsApp expect them. Not every product needs threads, but reactions and mentions are now assumed.
What changed since 2021
Three shifts have reshaped the evaluation criteria since the original version of this post.
The New Architecture is the default
In 2021 every native module ran on the old bridge, with its asynchronous serialization overhead. React Native 0.76 shipped the New Architecture (Fabric renderer plus TurboModules and JSI) enabled by default in late 2024, and by 2026 it is simply how React Native works. For chat SDKs the practical consequence is compatibility: any SDK with native modules for things like encrypted storage, media processing, or call support must support the New Architecture cleanly. If a vendor’s docs still talk about patching the old bridge or pinning you to an outdated React Native release, treat that as a red flag about maintenance in general. If you are new to the ecosystem and unsure how React Native relates to React itself, our React vs React Native explainer covers the distinction.
Expo went mainstream
Expo used to be the beginner path you graduated out of the moment you needed a custom native module. Config plugins, prebuild, and EAS changed that, and Expo is now the officially recommended way to start a React Native app. A chat SDK that requires manual native project surgery is a real cost for Expo-based teams. Check whether the SDK works in a standard Expo development build, whether it ships a config plugin for its native dependencies, and what parts, if any, genuinely require bare workflow.
AI moved into the chat layer
The biggest product-level change. In 2021 “chatbot support” meant webhook integrations you wired up yourself. In 2026, chat platforms are shipping AI capability as a first-class feature: LLM-backed assistant participants inside conversations, retrieval-augmented bots answering from your documentation, automatic translation between participants writing in different languages, AI-assisted moderation, and summarization of long threads. If there is any chance your roadmap includes an AI assistant living inside your chat, evaluate now whether the SDK treats bots as real conversation participants with proper identity and history access, or as an afterthought bolted onto webhooks. Retrofitting this later is painful.
How to evaluate a React Native chat SDK
A practical checklist, in rough priority order:
- Hosting model. Hosted only, self-hosted only, or both? If compliance (HIPAA, data residency, sector rules) is anywhere in your future, self-hosting or a dedicated instance stops being optional. Open source stacks such as Ethora, which we build, at ethora.com, exist largely because of this requirement; several proprietary vendors also offer dedicated deployments at enterprise pricing.
- Pricing shape. Most hosted vendors price per monthly active user. Model your cost at 10x your current usage and see if the number still makes sense. MAU pricing that is trivial at launch can dominate your infrastructure budget at scale.
- Sync quality. Kill the network in the demo app mid-send. Background the app for an hour and reopen. Log in on two devices. The gap between polished and shallow SDKs shows up here, not on the feature grid.
- New Architecture and Expo support. Confirmed above; verify against a fresh project, not the vendor’s sample repo.
- Customization depth. Can you restyle components, replace individual ones, or drop to the client SDK when the UI kit runs out? Look for teams that shipped something visually distinctive on the SDK, not just the default theme.
- Push notifications end to end. Build the deep-link-from-notification flow during your trial, on both platforms. Do not take the documentation’s word for it.
- Maintenance signals. Recent releases tracking new React Native versions, a responsive issue tracker, and a changelog that mentions the New Architecture. An abandoned SDK is a liability regardless of feature count.
- Exit cost. Can you export your message history? With open source or self-hosted options the data is yours by definition; with hosted vendors, check before you have three years of conversations locked in.
Once you have your shortlist, we maintain a detailed side-by-side in our comparison of the best React Native chat SDKs, covering pricing, hosting models, and feature depth across the major options.
FAQ
Should I build chat from scratch instead of using an SDK?
Only if chat is your core product. A minimal real-time chat is a weekend project; production chat with offline sync, push routing, media, and moderation is a multi-year engineering commitment. For most products an SDK gets you 90 percent of the way and lets your team spend its time on what makes your app different.
Do React Native chat SDKs work with Expo?
Most major ones now do, via development builds and config plugins. Pure JavaScript SDKs work everywhere; SDKs with native modules need a development build rather than Expo Go. Check the vendor’s Expo documentation specifically, and test in a fresh project before committing.
What does a chat SDK typically cost?
Hosted vendors mostly charge per monthly active user, commonly starting in the low hundreds of dollars per month and scaling with usage, with feature gates on things like moderation or calls. Open source and self-hosted options remove the per-user fee but you pay in infrastructure and operations time. Model both paths at your expected scale before choosing.