Put the agent inside your own product, with your own UI.
The API channel lets your backend talk to the same Callaro agent that answers your calls and WhatsApp. Start a conversation, send each user message, escalate to a person — and receive replies as streamed events or signed webhooks, with structured rich replies you render your way.
- Start, reply and escalate conversations from your backend with an agent key.
- Replies arrive as a server-sent event stream or HMAC-signed webhooks.
- Rich replies as structured events — cards, slots, carts, forms — rendered in your design.
- The same customer shares memory with WhatsApp, calls and chat.
What customers see on API channel
- Text replies
- Structured rich replies (cards, slots, carts, forms)
- Hand-off and status events
- Conversation outcomes and collected data
One agent writes once; each channel shows the reply in its best native format, and anything a channel can't draw becomes clear text and links — so no choice or link is ever lost.
The API channel problems Callaro solves
Off-the-shelf chat widgets don't match your product or brand.
Render every reply in your own UI; Callaro provides the conversation, tools and memory.
Building your own LLM agent means rebuilding memory, tools, guardrails and hand-off.
Use the same production agent that already runs your calls and WhatsApp, through a simple API.
In-app conversations are disconnected from phone and WhatsApp.
The API channel shares one customer record and memory with every other channel.
What the API channel agent does
Your interface, our agent
Keep full control of the user experience in your app, kiosk, partner portal or internal tool, while Callaro handles the conversation.
Streamed or webhook replies
Subscribe to a live event stream for instant UI updates, or receive signed webhooks in your backend.
Structured rich replies
Buttons, comparisons, booking slots, carts and forms arrive as structured data your front end can render natively.
Escalate to a person
Your app can hand a conversation to your team at any moment; the inbox shows it alongside every other channel.
Same tools and guardrails
The agent uses the same knowledge, tools, consent rules and budgets as on every other channel.
Rotate keys any time
Each agent has its own key and signing secret, shown once and rotatable whenever you need.
Your interface. Callaro's brain.
Every reply — including cards, slots, carts and forms — arrives as structured data, so you can render it with your own components, in any app or device.
// Your backend → Callaro
POST /api/v1/agent_api/reply
{ "conversation_id": "c_8812", "text": "Can I visit this weekend?" }
// Callaro → your app (event stream or signed webhook)
{
"type": "message",
"text": "Pick a time for the site visit",
"rich": {
"kind": "slots",
"options": [
{ "id": "sat-11", "title": "Sat 11:00" },
{ "id": "sun-16", "title": "Sun 16:00" }
]
}
}Rendered in YOUR UI
Pick a time for the site visit
Callaro sends the meaning; you decide the look. Use your design system, your components and your brand — in a web app, mobile app, kiosk, partner portal or internal tool.
Tools, data and live events — inside the conversation, not after it
Most bots answer from a script and update your systems later. Callaro exchanges data with your systems while the customer is still talking — so nothing breaks when a journey crosses channels or something changes in real time.
Context in before the first word
Customer profile, CRM stage, open orders and the last conversation on any channel are loaded as the call or chat starts — the agent opens warm, never cold.
In-call tool calling
The agent calls your APIs, MCP servers and payment gateway mid-sentence — look up, book, update, charge — and uses the answer immediately.
Runtime context insertion
A payment, a CRM change or a chat message arrives while the call is live? It's inserted into the conversation within seconds, and the agent can say it aloud.
No broken hand-overs
Call to WhatsApp, chat to call, AI to human and back — each step carries the context forward, so customers never repeat themselves.
Engineered for speed
The agent is prepared before the call connects so the greeting is ready on the first moment of audio; prompts are cached, models chosen per use case, and turn-taking tuned for real phone lines.
- Hi, I'm calling about the 2BHK at Skyline Heights.
- Before the first word: CRM profile, last WhatsApp chat and open deal stage loaded into the agent's context.
- Welcome back, Priya — you asked about the east-facing units on WhatsApp yesterday. Two are still open.
- Tool call → inventory API: 2 units, live prices returned and used in the answer.
- Tool call → send WhatsApp: brochure, price sheet and site location delivered mid-call.
- Live event from your payment gateway: booking amount received.
- I can see your booking amount just came through — Unit 1204 is now reserved for you.
After the call: transcript, collected data and outcome to your CRM by webhook; open chats get a summary; a recap email lists what was sent.
One customer, one memory — across channels
API channel is one mouth of the same agent. Every message lands on the same customer record as their calls, chats and emails, so the conversation simply continues.
Your app → WhatsApp
A user starts in your fintech app and later continues on WhatsApp — the agent remembers everything.
Your app → call
When the user wants to talk, the agent rings them or their app with the conversation's context.
Your systems → conversation
Post an event (KYC approved, order shipped) and the next reply in your app reflects it.
Popular use cases
- AI assistant inside a banking or fintech app
- Partner portals and marketplaces
- In-product onboarding and support
- Kiosks and custom devices
- Internal ops copilots
Connect what you already use
Full developer documentation at developers.callaro.ai.
Launch your API channel agent.
Book a demo and see one agent handle a journey across voice and messaging, end to end.
Book a demo