How it works
Introducing our agentic MCP 0.1.0
Engagement
infrastructure
built
for
devs
and
AI
agents.
You build the app. Your agent keeps users engaged.
What you need
Turn your app activity and user behaviors into targeted and automated engagement.
Integrations
Connect the stack you already ship.
Add the SDK once. Engagement runs from your dashboard, code, or agent.
From events
01
Connect
Add the SDK, ask for permission, and identify users and devices - with one integration.
02
Configure
Set triggers, schedules, and workflows from your dashboard, code, or AI agent.
03
Target
Reach the right audience by properties, platform, activity, plan, or your own attributes.
04
Engage
Send now or schedule for the moment most likely to open your app again.
Tuesday, 09:30
Best audience time
05
Measure
See what was delivered, opened, and failed - so you know what brought people back.
Delivered
98.7%
Opened
42.1%
Failed
1.3%
Workflows
Bring them back to what matters.
From a useful reminder to a behavioral trigger, send the moment that opens your app again - around the action users should repeat.
On demand
Send when it matters
Compose a message, pick who should return, and send - timed to something they can accomplish.
Your streak is waiting
Open the app and pick up where you left off.
Scheduled
Reach them at the right time
Schedule later, or send in each user's local timezone - when the action is most useful.
We saved your spot
nowPick up where you left off
Automations
Let events do the work
Trigger engagement from in-app events automatically - your agent can configure the path.
Quick start
Works with the apps you already build.
Integrate in minutes. Identify users once, then build and run engagement that brings them back - from your dashboard, API, or agent.
npx expo install @notifiable/expo expo-notifications expo-constants @react-native-async-storage/async-storage
import { NotifiableProvider, useNotifiable } from "@notifiable/expo";
function App() {
return (
<NotifiableProvider
publicKey="ntf_pub_..."
projectId="your-eas-project-id"
deepLinks={[
{ path: "/orders", label: "Orders" },
{ path: "/inbox", label: "Inbox" },
]}
onDeepLink={(url) => {
// Open this route in your navigator.
}}
>
<Home />
</NotifiableProvider>
);
}
const { requestPermission, identify } = useNotifiable();
await requestPermission();
await identify({
email: "[email protected]",
externalId: "user_123",
});
npm install @notifiable/react-native @react-native-async-storage/async-storage
import { NotifiableProvider, useNotifiable } from "@notifiable/react-native";
function App() {
return (
<NotifiableProvider
publicKey="ntf_pub_..."
push={{
provider: "fcm",
getPermissionStatus,
requestPermission,
getToken,
}}
deepLinks={[
{ path: "/orders", label: "Orders" },
{ path: "/inbox", label: "Inbox" },
]}
onDeepLink={(url) => {
// Open this route in your navigator.
}}
>
<Home />
</NotifiableProvider>
);
}
const { requestPermission, identify } = useNotifiable();
await requestPermission();
await identify({
email: "[email protected]",
externalId: "user_123",
});
dependencies: notifiable: path: ../flutter
import 'package:notifiable/notifiable.dart';
Notifiable(
publicKey: 'ntf_pub_...',
deepLinks: const [
DeepLink(path: '/orders', label: 'Orders'),
DeepLink(path: '/inbox', label: 'Inbox'),
],
onDeepLink: (url) {
// Open this route with your navigator.
},
child: const Home(),
)
final notifiable = Notifiable.of(context);
await notifiable.requestPermission();
await notifiable.identify(
email: '[email protected]',
externalId: 'user_123',
);
https://github.com/itsnotifiable/swift
import Notifiable
let notifiable = try NotifiableClient(
publicKey: "ntf_pub_...",
deepLinks: [
DeepLink(path: "/orders", label: "Orders"),
DeepLink(path: "/inbox", label: "Inbox"),
],
onDeepLink: { url in
// Open this route with your navigator.
}
)
try await notifiable.start()
try await notifiable.requestPermission()
try await notifiable.identify(
email: "[email protected]",
externalId: "user_123"
)
implementation("sh.notifiable:notifiable:0.1.0")
import sh.notifiable.DeepLink
import sh.notifiable.NotifiableClient
val notifiable = NotifiableClient(
context = this,
publicKey = "ntf_pub_...",
deepLinks = listOf(
DeepLink(path = "/orders", label = "Orders"),
DeepLink(path = "/inbox", label = "Inbox"),
),
onDeepLink = { url ->
// Open this route with your navigator.
},
)
lifecycleScope.launch {
notifiable.start()
notifiable.requestPermission()
notifiable.identify(email = "[email protected]", externalId = "user_123")
}
# Send with a workspace server API key
curl -X POST \
https://api.notifiable.sh/api/v1/public/apps/{app}/environments/development/notifications \
-H "Authorization: Bearer ntf_key_..." \
-H "Content-Type: application/json" \
-d '{
"title": "Your order shipped",
"body": "Your package is on its way.",
"url": "/orders/123",
"audience_type": "all",
"intent": "send"
}'
FAQ
Frequently asked questions.
Straight answers for developers and AI agents before the first engagement.
01 What is Notifiable, and how does it work?
Notifiable is engagement infrastructure for developers and AI agents. It connects your app's user activity to targeted, scheduled, and automated engagement actions. You manage everything through your code, dashboard, or AI agent, without building the engagement backend yourself.
02 Is Notifiable just another push notification service?
No. Push notifications are our first channel, but Notifiable is built around the entire engagement lifecycle: understanding user activity, targeting the right audience, automating actions, and measuring results. We're building toward engagement across multiple channels.
03 How is Notifiable different from Firebase or OneSignal?
Firebase provides messaging infrastructure, while OneSignal offers a broader customer engagement platform. Notifiable focuses on developers and AI app builders, making engagement part of the development workflow through SDKs, APIs, and AI-agent integrations.
04 Can my AI agent set up and manage Notifiable?
Yes. Notifiable provides an MCP server that lets compatible AI agents interact with the platform. Your agent can help configure apps, manage audiences, and operate supported engagement workflows, while you remain in control of what gets executed.
05 Which frameworks and platforms does Notifiable support?
Notifiable currently provides SDKs for React Native and Expo, with mobile push support for iOS and Android. You can also use its API and MCP integration to manage engagement from compatible backend services and AI tools. More platform integrations are planned.
06 Do I need to build a backend or configure Firebase and Apple Push Notifications myself?
You don't need to build your own engagement backend. Notifiable manages targeting, scheduling, workflows, and delivery through its platform. Some platform-specific setup, permissions, and credentials may still be required depending on your app and environment.
07 Can I automate onboarding, reminders, and re-engagement?
Yes. You can use user identities, audience segments, schedules, and supported event-driven workflows to create engagement actions. For example, you can target users who haven't completed onboarding or schedule a reminder tied to an important product moment.
08 How reliable is delivery, and can I track results?
Notifiable provides delivery reporting and engagement tracking so you can inspect what happened after sending. Push delivery still depends on device connectivity, operating-system permissions, and providers such as APNs and FCM, so no platform can guarantee every notification will arrive.
09 Is Notifiable free? What happens as my app grows?
Yes. You can start free with up to 5,000 engagement actions per month. Paid plans offer higher usage allowances as your app grows, with custom options for larger volumes. You can start building without committing to a paid plan.