Channels

Documentation Index

Fetch the complete documentation index at: https://koreai.mintlify.app/llms.txt

Use this file to discover all available pages before exploring further.

​

Channel architecture

​

Channel matrix

​

Adapter pattern

External platform ──webhook/ws──> Channel Adapter ──normalize──> Inbound Queue
                                                                      │
                                                          Agent Runtime executes
                                                                      │
External platform <──send────── Channel Adapter <──transform── Outbound Queue

• verifyRequest() — Validates inbound request signatures (HMAC, JWT, token).
• parseIncoming() — Converts the platform-specific payload into a NormalizedIncomingMessage.
• sendResponse() — Delivers the agent’s response through the channel.
• transformOutput() — Converts plain text and interactive actions into the channel’s native format (Block Kit, Adaptive Cards, interactive messages, etc.).
• sendTypingIndicator() — Sends a “typing” signal on channels that support it.

​

Message normalization

​

Processing pipeline

1. Inbound webhook receives the raw payload.
2. Verification validates the request signature using the channel connection’s credentials.
3. Filtering skips bot messages, irrelevant subtypes, and duplicate events.
4. Connection resolution maps the external identifier to a tenant, project, and agent.
5. Normalization converts the payload to the standard message format.
6. Enqueue adds the message to the BullMQ inbound queue with idempotency keys.
7. Processing the inbound worker picks up the job, creates or resumes a session, and runs the agent.
8. Delivery the agent’s response is transformed to the channel’s native format and sent.

​

Common features

​

Interactive elements

​

Typing indicators

​

Media attachments

• Inbound: Files are downloaded and stored as attachments linked to the session.
• Outbound: Files are uploaded to the channel’s media API or sent as URLs.

​

A2A per-message metadata

{
  "message": {
    "kind": "message",
    "role": "user",
    "parts": [{ "kind": "text", "text": "Look up this account" }],
    "metadata": {
      "messageMetadata": {
        "accountId": "acct_123",
        "context": { "tier": "gold" }
      }
    }
  }
}

​

Webhook URLs

​

Channel API

​

Channel connections

• Channel type — Which platform adapter to use.
• External identifier — The unique key for routing inbound messages (for example, Slack team_id:app_id).
• Encrypted credentials — API keys, tokens, and secrets for the platform.
• Agent binding — Which agent handles conversations on this channel.
• Deployment — Which deployment version to use (optional, defaults to latest).

​

Create a new channel connection

​

GET /api/projects/:projectId/channel-connections

​

PATCH /api/projects/:projectId/channel-connections/:id

​

DELETE /api/projects/:projectId/channel-connections/:id

​

Voice endpoints

​

GET /api/v1/voice/capabilities

Response body

Example request

curl https://agents.kore.ai/api/v1/voice/capabilities \
  -H "Authorization: Bearer abl_sk-your-api-key"

Example response

{
  "twilio": true,
  "deepgram": true,
  "elevenlabs": true,
  "fullVoice": true
}

​

POST /api/v1/voice/token

Request body

Response body

Example request

curl -X POST https://agents.kore.ai/api/v1/voice/token \
  -H "Authorization: Bearer abl_sk-your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "sessionId": "sess_abc123",
    "projectId": "proj_xyz"
  }'

Example response

{
  "token": "eyJhbGciOiJIUzI1NiIs...",
  "identity": "user-sess_abc123",
  "sessionId": "sess_abc123"
}

​

POST /api/v1/voice/connect

​

POST /api/v1/voice/status

​

LiveKit voice

​

GET /api/v1/livekit/capabilities

Response body

Example request

curl https://agents.kore.ai/api/v1/livekit/capabilities \
  -H "Authorization: Bearer abl_sk-your-api-key"

Example response

{
  "enabled": true,
  "configured": true
}

​

POST /api/v1/livekit/token

Request body

Response body

Example request

curl -X POST https://agents.kore.ai/api/v1/livekit/token \
  -H "Authorization: Bearer abl_sk-your-api-key" \
  -H "Content-Type: application/json" \
  -d '{
    "sessionId": "sess_abc123",
    "projectId": "proj_xyz",
    "agentName": "voice-agent"
  }'

Error responses

​

SDK channels

​

GET /api/projects/:projectId/sdk-channels

Query parameters

Response body

{
  "success": true,
  "channels": [
    {
      "id": "ch_abc123",
      "tenantId": "tenant_001",
      "projectId": "proj_xyz",
      "name": "Website Chat Widget",
      "channelType": "web",
      "deploymentId": "dep_456",
      "publicApiKeyId": "pk_789",
      "config": {},
      "isActive": true,
      "environment": "production",
      "followEnvironment": true,
      "createdAt": "2026-03-01T10:00:00.000Z",
      "updatedAt": "2026-03-10T14:30:00.000Z"
    }
  ],
  "pagination": {
    "total": 1,
    "limit": 50,
    "offset": 0
  }
}

​

POST /api/projects/:projectId/sdk-channels

Request body

​

GET /api/projects/:projectId/sdk-channels/:channelId

​

PATCH /api/projects/:projectId/sdk-channels/:channelId

​

DELETE /api/projects/:projectId/sdk-channels/:channelId

​

POST /api/projects/:projectId/sdk-channels/:channelId/token

​

Widget configuration

​

GET /api/v1/sdk/config/:projectId

Response body

Example request

curl https://agents.kore.ai/api/v1/sdk/config/proj_xyz \
  -H "X-API-Key: pk_your-public-key"

Example response

{
  "projectId": "proj_xyz",
  "permissions": {
    "chat": true,
    "voice": false
  },
  "config": {
    "mode": "chat",
    "position": "bottom-right",
    "theme": {
      "primaryColor": "#4F46E5",
      "darkMode": false
    },
    "welcomeMessage": "Hello! How can I help you today?",
    "placeholderText": "Type a message...",
    "voiceEnabled": false,
    "chatEnabled": true
  }
}

​

Inbound webhooks

​

POST /api/v1/channels/:channelType/webhook

​

POST /api/v1/channels/:channelType/webhook/:connectionIdentifier

1. Looks up the channel adapter from the registry
2. Handles verification challenges (e.g., Slack url_verification)
3. Filters events (skips bot messages, etc.)
4. Resolves the channel connection to a tenant and project
5. Verifies the request signature using per-connection secrets
6. Normalizes the message format
7. Enqueues the message for processing
8. Returns 200 to acknowledge receipt

​

REST API integration

​

Session management

curl -X POST https://agents.kore.ai/api/v1/chat/send \
  -H "Authorization: Bearer your-token" \
  -H "Content-Type: application/json" \
  -d '{
    "projectId": "project-123",
    "message": "I need help with my account"
  }'

curl -X POST https://agents.kore.ai/api/v1/chat/send \
  -H "Authorization: Bearer your-token" \
  -H "Content-Type: application/json" \
  -d '{
    "sessionId": "sess_abc123",
    "message": "I want to update my email address"
  }'

curl -X POST https://agents.kore.ai/api/v1/sessions/sess_abc123/end \
  -H "Authorization: Bearer your-token"

​

Message patterns

​

Synchronous (request-response)

curl -X POST https://agents.kore.ai/api/v1/chat/send \
  -H "Authorization: Bearer your-token" \
  -H "Content-Type: application/json" \
  -d '{
    "sessionId": "sess_abc123",
    "message": "What are your business hours?"
  }'

​

Streaming (SSE)

curl -N -X POST https://agents.kore.ai/api/v1/chat/stream \
  -H "Authorization: Bearer your-token" \
  -H "Content-Type: application/json" \
  -H "Accept: text/event-stream" \
  -d '{
    "sessionId": "sess_abc123",
    "message": "Explain how multi-agent orchestration works"
  }'

event: chunk
data: {"messageId":"msg_xyz","text":"Multi-agent","done":false}

event: chunk
data: {"messageId":"msg_xyz","text":" orchestration","done":false}

event: done
data: {"messageId":"msg_xyz","text":"Multi-agent orchestration allows...","done":true}

​

Async (webhook callback)

1. Create an HTTP Async channel connection with your callback URL.
2. Send messages to the async endpoint.
3. Receive responses at your webhook URL.

# Send async message
curl -X POST https://agents.kore.ai/api/v1/channels/http_async/send \
  -H "X-API-Key: ak_your_api_key" \
  -H "Content-Type: application/json" \
  -d '{
    "connectionId": "conn_123",
    "message": "Generate a comprehensive report on Q4 sales"
  }'

{
  "eventType": "agent.response",
  "sessionId": "sess_abc123",
  "messageId": "msg_xyz",
  "text": "Here is the Q4 sales report...",
  "metadata": {}
}

​

Best practices

1. Reuse sessions — Create a session once and reuse the sessionId for follow-up messages. Do not create a new session per message.
2. Handle streaming — Use SSE streaming for user-facing integrations to provide real-time feedback.
3. Implement retries — Use exponential backoff for 429 and 503 responses.
4. Validate API keys — Rotate API keys regularly and use the minimum scope needed.
5. Set timeouts — Configure client-side timeouts. Agent responses with tool calls can take 30+ seconds.

​

Chat channels

​

Slack

​

Capabilities

​

Setup

1. Create a Slack app at api.slack.com/apps.
2. Enable Event Subscriptions and Interactivity & Shortcuts.
3. Add bot scopes: chat:write, app_mentions:read, im:history, im:read, im:write.
4. Install the app to your Slack workspace.
5. In ABL Studio, go to Project > Channels > Add Channel > Slack.
6. Enter the credentials:
   • Bot token — Starts with xoxb-
   • Signing secret — From your app’s Basic Information page
7. Copy the generated webhook URL and paste it into Slack’s Event Subscriptions Request URL.

​

Webhook URL formats

https://agents.kore.ai/api/v1/channels/slack/webhook

https://agents.kore.ai/api/v1/channels/slack/webhook/{team_id}:{app_id}

https://agents.kore.ai/api/v1/channels/slack/slash/{team_id}:{app_id}

​

Rich output

SAY "Choose a department:"
ACTION_SET
  BUTTON id="sales" label="Sales"
  BUTTON id="support" label="Support"
  BUTTON id="billing" label="Billing"

​

Microsoft Teams

​

Capabilities

​

Setup

1. Register a bot in the Azure Bot Service.
2. Create an Azure AD app registration for the bot.
3. Note the Application (client) ID, Client secret, and Tenant ID.
4. In ABL Studio, go to Project > Channels > Add Channel > Microsoft Teams.
5. Enter the credentials:
   • App ID — Azure AD application ID
   • Client secret — Azure AD client secret
   • Tenant ID — Azure AD tenant ID (or common for multi-tenant)
6. Copy the webhook URL and configure it as the bot’s messaging endpoint in Azure.

​

Webhook URL

https://agents.kore.ai/api/v1/channels/msteams/webhook/{app_id}

​

Rich output

SAY "Please select your issue type:"
ACTION_SET
  SELECT id="issue_type" label="Issue type"
    OPTION id="bug" label="Bug report"
    OPTION id="feature" label="Feature request"
    OPTION id="question" label="General question"

​

WhatsApp

​

Capabilities

​

Providers

​

Setup (Meta Cloud API)

1. Create a Meta Business App at developers.facebook.com.
2. Add the WhatsApp product to your app.
3. Generate a permanent access token.
4. In ABL Studio, go to Project > Channels > Add Channel > WhatsApp.
5. Enter the credentials:
   • Access token — Permanent token from Meta
   • App secret — From your app’s Basic Settings
   • Verify token — A string you define for webhook verification
6. Copy the webhook URL and configure it in Meta’s webhook settings.
7. Subscribe to the messages webhook field.

​

Webhook verification

​

Rich output

SAY "How can I help you?"
ACTION_SET
  BUTTON id="track" label="Track order"
  BUTTON id="return" label="Start return"
  BUTTON id="contact" label="Talk to agent"

​

Telegram

​

Capabilities

​

Setup

1. Create a bot via @BotFather on Telegram.
2. Note the Bot token.
3. In ABL Studio, go to Project > Channels > Add Channel > Telegram.
4. Enter the Bot token.
5. The platform automatically registers the webhook URL with the Telegram Bot API.

​

Webhook URL

https://agents.kore.ai/api/v1/channels/telegram/webhook/{bot_id}

​

Facebook Messenger

​

Capabilities

​

Setup

1. Create a Meta Business App at developers.facebook.com.
2. Add the Messenger product.
3. Generate a Page access token for your Facebook Page.
4. In ABL Studio, go to Project > Channels > Add Channel > Messenger.
5. Enter the credentials:
   • Page access token
   • App secret
   • Verify token
6. Copy the webhook URL and configure it in Meta’s webhook settings.
7. Subscribe to the messages and messaging_postbacks webhook events.

​

Instagram DM

​

Capabilities

​

Setup

1. Use the same Meta Business App as Messenger.
2. Connect your Instagram Professional Account to the Facebook Page.
3. In ABL Studio, go to Project > Channels > Add Channel > Instagram.
4. Enter the same credentials as Messenger (Page access token, App secret, Verify token).
5. Subscribe to the instagram_messaging webhook events.

​

LINE

​

Capabilities

​

Setup

1. Create a LINE channel at developers.line.biz.
2. Note the Channel access token and Channel secret.
3. In ABL Studio, go to Project > Channels > Add Channel > LINE.
4. Enter the credentials:
   • Channel access token (long-lived)
   • Channel secret
5. Copy the webhook URL and configure it in the LINE Developers Console.

​

Webhook URL

https://agents.kore.ai/api/v1/channels/line/webhook

​

Twilio SMS

​

Capabilities

​

Setup

1. Create a Twilio account and provision a phone number.
2. Note the Account SID and Auth Token.
3. In ABL Studio, go to Project > Channels > Add Channel > Twilio SMS.
4. Enter the credentials:
   • Account SID
   • Auth Token
5. Copy the webhook URL and configure it as the phone number’s messaging webhook in Twilio.

​

Webhook URL

https://agents.kore.ai/api/v1/channels/twilio_sms/webhook/{phone_number}

​

Common channel operations

​

Viewing channel status

​

Testing a channel

1. Open the channel connection details.
2. Click Send test message.
3. Verify the message arrives on the external platform and a response is returned.

​

Deactivating a channel

1. Go to Project > Channels.
2. Click the channel you want to deactivate.
3. Toggle Active to off.

​

Voice channels

​

Voice architecture

​

Pipeline mode

Caller ──audio──> STT (Deepgram) ──text──> Agent Runtime ──text──> TTS (ElevenLabs) ──audio──> Caller

​

Realtime mode

Caller ──audio──> Realtime Model (OpenAI/Gemini) ──audio──> Caller

​

Voice mode selection

​

Jambonz (voice gateway)

​

Setup

1. Deploy Jambonz or use a hosted instance.
2. Configure the voice settings in your workspace:
   • Jambonz API URL
   • Account SID
   • API key
   • SBC address (for SIP routing)
3. Create a voice channel connection in your project.
4. The platform provisions a Jambonz application, VoIP carrier, and phone number automatically.

​

How it works

1. An inbound call arrives at Jambonz.
2. Jambonz opens a WebSocket to the platform runtime.
3. The runtime manages the call using the agent’s flow.
4. Audio is streamed bidirectionally over the WebSocket.

​

SIP integration (BYOC)

1. When creating the voice channel connection, set the provider to byoc_sip.
2. Provide the SIP gateway address and port.
3. The platform provisions a Jambonz SIP gateway pointing to your carrier.

​

AudioCodes

​

Capabilities

​

Setup

1. In ABL Studio, go to Project > Channels > Add Channel > AudioCodes.
2. Enter the Inbound auth token for webhook verification.
3. Copy the generated webhook URL.
4. Configure the AudioCodes device to POST call events to the webhook URL.

​

Webhook URL

https://agents.kore.ai/api/v1/channels/audiocodes/webhook/{identifier}

​

Twilio Voice

​

Browser-based voice (WebRTC)

1. Configure Twilio credentials in your workspace:
   • Account SID
   • Auth Token
   • API Key SID and Secret (for token generation)
   • TwiML App SID
2. The SDK generates a Twilio access token for the browser client.
3. Voice is routed through Twilio’s WebRTC infrastructure to the platform.

​

VXML / IVR

​

Capabilities

​

Setup

1. In ABL Studio, go to Project > Channels > Add Channel > VXML.
2. The platform generates a webhook URL for your IVR system.
3. Configure your IVR to POST user input and receive agent responses synchronously.

​

Webhook URL

https://agents.kore.ai/api/v1/channels/vxml/hooks/{streamId}

​

LiveKit (WebRTC)

​

Setup

1. Deploy a LiveKit server or use LiveKit Cloud.
2. Configure the LiveKit settings:
   • LiveKit URL
   • API Key
   • API Secret
3. The SDK connects to LiveKit for audio streaming and the platform runtime for agent logic.

​

Configuration

​

Voice analytics

​

Voice configuration reference

​

Email channel

​

Capabilities

​

How email works

​

Inbound flow

1. An email arrives at your configured email address.
2. Your mail server or relay forwards the email to the platform via SMTP inbound processing.
3. The platform parses the email, extracts the text body, and normalizes it as an inbound message.
4. Threading is resolved using the In-Reply-To and References headers to match the email to an existing session.
5. The agent processes the message and generates a response.

​

Outbound flow

• The agent’s response as the email body (plain text with markdown formatting).
• Proper threading headers (In-Reply-To, References, Message-ID).
• Attachments if the agent generated any files.
• A consistent From address configured per channel connection.

​

Setup

1. In ABL Studio, go to Project > Channels > Add Channel > Email.
2. Configure the inbound email address that will receive messages.
3. Configure the outbound transport:

• SMTP host and port
• Authentication credentials (username/password or OAuth 2.0)
• TLS settings

• Azure AD client ID
• Client secret
• Tenant ID
• Sender mailbox

4. Set the sender display name and reply-to address.
5. Click Save and test to send a verification email.

​

Email threading

​

Session mapping

• New email (no threading headers): Creates a new session.
• Reply to a platform email: Resumes the existing session using the In-Reply-To header.
• Forwarded email: Treated as a new session unless threading headers are preserved.

​

Email configuration reference

​

Preventing email loops

• Auto-reply detection: Emails with Auto-Submitted: auto-replied or similar headers are ignored.
• Rate limiting: A per-address cooldown prevents responding more than once per configurable interval.
• Loop detection: If the platform detects that it is replying to its own messages, the loop is broken.

​

Email best practices

1. Use a dedicated mailbox for the agent to avoid mixing agent conversations with human email.
2. Configure SPF, DKIM, and DMARC on your sending domain to avoid outbound emails being marked as spam.
3. Set a reasonable auto-reply threshold (default: 60 seconds) to prevent rapid-fire loops.
4. Monitor delivery rates in your SMTP provider’s dashboard for bounces and spam reports.

​

Enterprise channels

​

Genesys Cloud

​

Capabilities

​

How Genesys integration works

Genesys Cloud ──POST──> ABL Runtime ──agent execution──> Response in same HTTP response

​

Setup

1. In Genesys Cloud, create an Open Messaging Integration.
2. Configure the outbound messaging endpoint.
3. Note the Client secret from the integration settings.
4. In ABL Studio, go to Project > Channels > Add Channel > Genesys.
5. Enter the Client secret.
6. Copy the generated webhook URL and paste it into the Genesys Cloud integration as the inbound message webhook.

​

Webhook URL

https://agents.kore.ai/api/v1/channels/genesys/hooks/{streamId}

​

Agent transfer

1. The ABL agent triggers an ESCALATE action.
2. The platform sends a transfer request to Genesys Cloud.
3. Genesys Cloud routes the conversation to the configured queue.
4. The session remains open for post-transfer context.

​

Zendesk

​

Capabilities

​

How Zendesk integration works

​

Setup

1. In Zendesk, go to Admin > Sunshine Conversations > Integrations.
2. Create a custom integration and note the:
   • App ID
   • Key ID
   • Key secret
3. Optionally generate a Webhook secret for HMAC-SHA256 inbound verification.
4. In ABL Studio, go to Project > Channels > Add Channel > Zendesk.
5. Enter the credentials.
6. Copy the generated webhook URL and configure it in Zendesk’s webhook settings.

​

Webhook URL

https://agents.kore.ai/api/v1/channels/zendesk/webhook/{identifier}

​

Custom adapter development

​

Adapter interface

interface ChannelAdapter {
  readonly channelType: ChannelType;
  readonly capabilities: ChannelCapabilities;

  // Validate inbound request signature
  verifyRequest(
    headers: Record<string, string>,
    body: unknown,
    rawBody?: Buffer | string,
    connection?: ResolvedConnection | null,
    webhookUrl?: string,
  ): Promise<boolean>;

  // Parse inbound payload into normalized message
  parseIncoming(payload: InboundJobPayload): NormalizedIncomingMessage;

  // Send response through the channel
  sendResponse(
    message: NormalizedOutgoingMessage,
    connection: ResolvedConnection,
  ): Promise<SendResult>;

  // Transform plain text + actions into channel-native format (optional)
  transformOutput?(text: string, actions?: ActionSetIR, richContent?: RichContentIR): ChannelOutput;

  // Send typing indicator (optional)
  sendTypingIndicator?(
    connection: ResolvedConnection,
    externalSessionKey: string,
    metadata?: Record<string, unknown>,
  ): Promise<void>;
}

​

Capabilities declaration

interface ChannelCapabilities {
  supportsAsync: boolean;
  supportsStreaming: boolean;
  supportsMedia: boolean;
  supportsThreading: boolean;
}

​

Adding to the channel manifest

my_channel: {
  displayName: 'My Channel',
  ingress: 'webhook',           // 'webhook' | 'websocket' | 'api' | 'smtp' | 'sync_webhook' | 'none'
  delivery: 'async_queue',      // 'async_queue' | 'sync_response' | 'websocket' | 'direct_send' | 'none'
  authMode: 'hmac',             // 'hmac' | 'jwt' | 'token' | 'api_key' | 'sdk_auth' | 'none'
  responseFormat: 'text',
  supportsRichOutput: false,
  supportsThreading: false,
  supportsMedia: false,
  supportsStreaming: false,
  isConnectionEligible: true,
  requiredCredentials: ['api_token', 'webhook_secret'],
  webhookPathPattern: '/api/v1/channels/my_channel/webhook/:identifier',
  isVoice: false,
  supportsTypingIndicator: false,
}

​

Registering the adapter

import { getChannelRegistry } from '../channels/registry.js';
import { MyChannelAdapter } from './my-channel-adapter.js';

const registry = getChannelRegistry();
registry.register(new MyChannelAdapter());

​

Implementation checklist

• Implement verifyRequest() with proper signature validation for your platform.
• Implement parseIncoming() to normalize the platform’s message format.
• Implement sendResponse() to deliver messages through the platform’s API.
• Add the channel type to the manifest with accurate capability flags.
• Register the adapter in the channel registry.
• Test with your platform’s webhook testing tools.
• Handle idempotency: extract a unique event ID from each inbound message to prevent duplicate processing.

​

Next steps

• API overview — Authentication and general conventions
• Conversation API — Text-based agent interactions
• SDKs — Embed voice and chat widgets