Upuah — Enterprise live chat API

In short

We build the control panel. You connect the API and run chat.

One sentence for the whole product: Upuah ships the admin layer — your team connects keys, answers live, and automates replies. AI is soon.

See team chat View API keys

01 · We build

Control panel

Dashboard, inbox engine, and branded widget.

fk_pub_8K2m… Connected

02 · You connect

API keys

Wire publishable and secret keys into your stack.

03 · Team runs

Live chat

Reply live, fire auto replies, brand the UI. AI soon.

How Upuah works

From dashboard setup to live conversations.

Connect keys, brand the widget, staff the inbox, and automate first responses — all from admin.

01

Connect your workspace

Create API keys in the admin dashboard and attach Upuah to your product surfaces.

Publishable + secret keys
Allowed domains locked

02

Operate live chat

Your team replies from the inbox while visitors chat on your branded widget.

Shared agent inbox
Realtime visitor chat

03

Automate & brand

Set automatic replies, themes, and launcher rules — AI replies coming soon.

Auto-reply rules
Widget theme · AI Soon

Team chat

Where your team works — live, automated, and connected.

Mock screens from the agent side of Upuah — how your team sees and answers conversations.

Team · Live thread

M

Maya R. Visitor · yourbrand.com

You · Agent

Hi — can someone help with pricing? 09:40

Of course. Are you looking at Growth or Enterprise? You · 09:41

Growth, for a 12-person support team. 09:41

Maya is typing

Reply to Maya… Send

Live agent chat Your team answers visitors in a real conversation thread.

Team · Auto reply fired

O

Omar K. Visitor · after hours

Auto

Is anyone online? Need install help. 22:14

Automatic reply We’re offline right now. Leave a note and we’ll follow up at open. Rule · After hours

Got it — please call me tomorrow morning. 22:15

Queued for morning handoff. Inbox · noted

Claim & reply… Send

Auto reply in the thread Canned replies appear in chat so the team can pick up after.

Team · Shared inbox

Open chats

G

Guest 4821 Waiting · 0:42

M

Maya R. You · active

L

Lina S. Sara · assigned

Anyone free to take this? Guest

I’ve got it — joining now. You

AI draft Soon Suggested: “Happy to help — what error do you see?”

Team inbox Agents share the queue, claim chats, and collaborate live.

Brand control

Centralized design. Consistent delivery.

Marketing and support teams shape the chat experience in the dashboard. Engineering deploys it with keys — without rebuilding the UI for every site.

Widget appearance Dashboard

Primary color

#fc603a

Display name

Brand Support

Launcher

Bottom right Bottom left

Greeting

Welcome — how may we assist you today?

Admins also manage automatic replies here. AI-assisted replies are marked Soon.

Customer-facing preview

Welcome — how may we assist you today?

This matches our brand guidelines.

Credentials

API keys built for clear separation of risk.

Issue keys from the dashboard with roles your security team expects — publishable for the client, secret for the backend.

Publishable Browser / embed

Intended for client-side initialization. Restricted to approved origins and channels.

fk_pub_8K2mQ9xL4nR7vP0a91F

Prefix fk_pub_
Used in Sesh.push(['init', …])

Secret Server only

Full access for sessions, messaging, and webhooks. Remains on your infrastructure only.

fk_live_••••••••••••••••c3E2

Prefix fk_live_ or fk_test_
Header Authorization: Bearer …

Reliability

Infrastructure shaped by a decade of live traffic.

Upuah is operated as long-running production infrastructure — monitored, versioned, and documented for teams that cannot afford guesswork.

Since 2014: Serving branded chat experiences across consumer and B2B sites.
99.99%: Uptime objective with status history and incident communication.
Global edge: Low-latency delivery for visitors and agent workspaces worldwide.
Stable API: Versioned endpoints and clear deprecation windows for enterprise change control.

Platform

Built for how real teams run chat.

Not a stacked feature list — four pillars of the Upuah control panel, designed to ship and operate together.

01

Admin control panel

Connect the API, invite agents, and run every property from one governed workspace.

02

Automatic replies

Admins register greetings, after-hours messages, and keyword triggers — no deploy required.

03

Team live inbox

Agents answer in real time while visitors use your branded on-site widget.

04

AI replies Soon

Suggested and automated AI responses land in the same dashboard — roadmap, not vaporware UI.

On the roadmap Drafts · intent routing · after-hours AI

Integrate

Connect in the stack you already ship.

Embed from the browser, call the API from your backend, ship in mobile apps, or install on WordPress and Shopify — web, server, React Native, Flutter, Expo, Swift, Kotlin, Ionic, and more.

Frontend

Backend

Mobile

CMS / Plugin

Demo publishable key fk_pub_8K2mQ9xL4nR7vP0a91F

Full implementation guide →

embed.html

<script src="https://cdn.upuah.com/widget.js" defer></script>
<script>
  window.Sesh = window.Sesh || [];
  Sesh.push(['init', {
    key: 'fk_pub_8K2mQ9xL4nR7vP0a91F',
    channel: 'support'
  }]);
</script>

import { useEffect } from 'react';

export function SeshChat() {
  useEffect(() => {
    const s = document.createElement('script');
    s.src = 'https://cdn.upuah.com/widget.js';
    s.async = true;
    document.body.appendChild(s);
    window.Sesh = window.Sesh || [];
    Sesh.push(['init', {
      key: 'fk_pub_8K2mQ9xL4nR7vP0a91F',
      channel: 'support'
    }]);
  }, []);
  return null;
}

<script setup>
import { onMounted } from 'vue'

onMounted(() => {
  const s = document.createElement('script')
  s.src = 'https://cdn.upuah.com/widget.js'
  s.defer = true
  document.body.appendChild(s)
  window.Sesh = window.Sesh || []
  Sesh.push(['init', {
    key: 'fk_pub_8K2mQ9xL4nR7vP0a91F',
    channel: 'support'
  }])
})
</script>

// app/layout.tsx or _app.tsx
import Script from 'next/script';

export default function RootLayout({ children }) {
  return (
    <html>
      <body>
        {children}
        <Script src="https://cdn.upuah.com/widget.js" strategy="afterInteractive" />
        <Script id="Sesh-init">{`
          window.Sesh = window.Sesh || [];
          Sesh.push(['init', {
            key: 'fk_pub_8K2mQ9xL4nR7vP0a91F',
            channel: 'support'
          }]);
        `}</Script>
      </body>
    </html>
  );
}

// plugins/sesh.client.ts
export default defineNuxtPlugin(() => {
  const s = document.createElement('script')
  s.src = 'https://cdn.upuah.com/widget.js'
  s.defer = true
  document.body.appendChild(s)
  window.Sesh = window.Sesh || []
  Sesh.push(['init', {
    key: 'fk_pub_8K2mQ9xL4nR7vP0a91F',
    channel: 'support'
  }])
})

import { Component, OnInit } from '@angular/core';

@Component({
  selector: 'app-sesh',
  template: ''
})
export class SeshComponent implements OnInit {
  ngOnInit() {
    const s = document.createElement('script');
    s.src = 'https://cdn.upuah.com/widget.js';
    s.async = true;
    document.body.appendChild(s);
    (window as any).Sesh = window.Sesh || [];
    Sesh.push(['init', {
      key: 'fk_pub_8K2mQ9xL4nR7vP0a91F',
      channel: 'support'
    }]);
  }
}

import fetch from 'node-fetch';

const res = await fetch('https://api.upuah.com/v1/messages', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer fk_live_••••••••c3E2',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    channel: 'support',
    text: 'Thanks — an agent will reply shortly.'
  })
});

const data = await res.json();

import express from 'express';

const app = express();

app.post('/webhook/sesh', express.json(), async (req, res) => {
  const reply = await fetch('https://api.upuah.com/v1/messages', {
    method: 'POST',
    headers: {
      'Authorization': 'Bearer fk_live_••••••••c3E2',
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      channel: 'support',
      text: 'Thanks — an agent will reply shortly.'
    })
  });
  res.json(await reply.json());
});

import requests

res = requests.post(
    "https://api.upuah.com/v1/messages",
    headers={
        "Authorization": "Bearer fk_live_••••••••c3E2",
        "Content-Type": "application/json",
    },
    json={
        "channel": "support",
        "text": "Thanks — an agent will reply shortly.",
    },
)

data = res.json()

import requests
from django.http import JsonResponse
from django.views.decorators.http import require_POST

@require_POST
def sesh_reply(request):
    res = requests.post(
        "https://api.upuah.com/v1/messages",
        headers={
            "Authorization": "Bearer fk_live_••••••••c3E2",
            "Content-Type": "application/json",
        },
        json={
            "channel": "support",
            "text": "Thanks — an agent will reply shortly.",
        },
    )
    return JsonResponse(res.json())

from fastapi import FastAPI
import httpx

app = FastAPI()

@app.post("/sesh/reply")
async def sesh_reply():
    async with httpx.AsyncClient() as client:
        res = await client.post(
            "https://api.upuah.com/v1/messages",
            headers={
                "Authorization": "Bearer fk_live_••••••••c3E2",
            },
            json={
                "channel": "support",
                "text": "Thanks — an agent will reply shortly.",
            },
        )
    return res.json()

<?php
$ch = curl_init('https://api.upuah.com/v1/messages');

curl_setopt_array($ch, [
  CURLOPT_POST => true,
  CURLOPT_HTTPHEADER => [
    'Authorization: Bearer fk_live_••••••••c3E2',
    'Content-Type: application/json',
  ],
  CURLOPT_POSTFIELDS => json_encode([
    'channel' => 'support',
    'text' => 'Thanks — an agent will reply shortly.',
  ]),
  CURLOPT_RETURNTRANSFER => true,
]);

$data = json_decode(curl_exec($ch), true);

use Illuminate\Support\Facades\Http;

$response = Http::withToken('fk_live_••••••••c3E2')
    ->post('https://api.upuah.com/v1/messages', [
        'channel' => 'support',
        'text' => 'Thanks — an agent will reply shortly.',
    ]);

$data = $response->json();

package main

import (
  "bytes"
  "net/http"
)

func main() {
  body := []byte(`{"channel":"support","text":"Thanks — an agent will reply shortly."}`)
  req, _ := http.NewRequest("POST", "https://api.upuah.com/v1/messages", bytes.NewBuffer(body))
  req.Header.Set("Authorization", "Bearer fk_live_••••••••c3E2")
  req.Header.Set("Content-Type", "application/json")
  http.DefaultClient.Do(req)
}

import { useEffect, useState } from 'react';
import { View, TextInput, Button, FlatList, Text } from 'react-native';

const SESH_KEY = 'fk_pub_8K2mQ9xL4nR7vP0a91F';

export default function SeshChat() {
  const [messages, setMessages] = useState([]);
  const [text, setText] = useState('');

  async function send() {
    const res = await fetch('https://api.upuah.com/v1/messages', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${SESH_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({ channel: 'support', text })
    });
    const data = await res.json();
    setMessages((prev) => [...prev, data]);
    setText('');
  }

  return (
    <View>
      <FlatList data={messages} renderItem={({ item }) => <Text>{item.text}</Text>} />
      <TextInput value={text} onChangeText={setText} />
      <Button title="Send" onPress={send} />
    </View>
  );
}

import 'package:http/http.dart' as http;
import 'dart:convert';

const seshKey = 'fk_pub_8K2mQ9xL4nR7vP0a91F';

Future<Map<String, dynamic>> sendSeshMessage(String text) async {
  final res = await http.post(
    Uri.parse('https://api.upuah.com/v1/messages'),
    headers: {
      'Authorization': 'Bearer $seshKey',
      'Content-Type': 'application/json',
    },
    body: jsonEncode({
      'channel': 'support',
      'text': text,
    }),
  );
  return jsonDecode(res.body) as Map<String, dynamic>;
}

// Use inside a StatefulWidget TextField + ElevatedButton
// await sendSeshMessage(controller.text);

import { useState } from 'react';
import { View, TextInput, Pressable, Text } from 'react-native';

const SESH_KEY = 'fk_pub_8K2mQ9xL4nR7vP0a91F';

export default function SupportScreen() {
  const [text, setText] = useState('');
  const [status, setStatus] = useState('');

  async function sendMessage() {
    const res = await fetch('https://api.upuah.com/v1/messages', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${SESH_KEY}`,
        'Content-Type': 'application/json'
      },
      body: JSON.stringify({
        channel: 'support',
        text,
        meta: { platform: 'expo' }
      })
    });
    setStatus(res.ok ? 'Sent' : 'Failed');
    setText('');
  }

  return (
    <View style={{ padding: 16 }}>
      <TextInput value={text} onChangeText={setText} placeholder="Message support" />
      <Pressable onPress={sendMessage}>
        <Text>Send via Upuah</Text>
      </Pressable>
      <Text>{status}</Text>
    </View>
  );
}

import Foundation

let seshKey = "fk_pub_8K2mQ9xL4nR7vP0a91F"

func sendSeshMessage(_ text: String) async throws -> [String: Any] {
  var request = URLRequest(url: URL(string: "https://api.upuah.com/v1/messages")!)
  request.httpMethod = "POST"
  request.setValue("Bearer \(seshKey)", forHTTPHeaderField: "Authorization")
  request.setValue("application/json", forHTTPHeaderField: "Content-Type")
  request.httpBody = try JSONSerialization.data(withJSONObject: [
    "channel": "support",
    "text": text,
    "meta": ["platform": "ios"]
  ])

  let (data, _) = try await URLSession.shared.data(for: request)
  return try JSONSerialization.jsonObject(with: data) as? [String: Any] ?? [:]
}

// Task { try await sendSeshMessage("Need help with my order") }

import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody

val seshKey = "fk_pub_8K2mQ9xL4nR7vP0a91F"
val client = OkHttpClient()

fun sendSeshMessage(text: String): String {
  val json = """{"channel":"support","text":"$text","meta":{"platform":"android"}}"""
  val body = json.toRequestBody("application/json".toMediaType())
  val request = Request.Builder()
    .url("https://api.upuah.com/v1/messages")
    .addHeader("Authorization", "Bearer $seshKey")
    .post(body)
    .build()

  client.newCall(request).execute().use { response ->
    return response.body?.string().orEmpty()
  }
}

import { Component } from '@angular/core';
import { HttpClient, HttpHeaders } from '@angular/common/http';

@Component({
  selector: 'app-sesh-chat',
  template: `
    <ion-input [(ngModel)]="text" placeholder="Message"></ion-input>
    <ion-button (click)="send()">Send</ion-button>
  `
})
export class SeshChatComponent {
  text = '';
  private key = 'fk_pub_8K2mQ9xL4nR7vP0a91F';

  constructor(private http: HttpClient) {}

  send() {
    const headers = new HttpHeaders({
      'Authorization': `Bearer ${this.key}`,
      'Content-Type': 'application/json'
    });
    this.http.post('https://api.upuah.com/v1/messages', {
      channel: 'support',
      text: this.text,
      meta: { platform: 'ionic' }
    }, { headers }).subscribe();
  }
}

Warning

Full WordPress plugin setup steps are in the documentation. Download the Upuah plugin ZIP from the docs, then upload and activate it in WordPress (Plugins → Add New → Upload Plugin).

Open documentation →

# 1. Download sesh.zip from Documentation
# 2. WP Admin → Plugins → Add New → Upload Plugin
# 3. Activate “Upuah Live Chat”
# 4. Settings → Upuah → paste your publishable key

define('SESH_PUB_KEY', 'fk_pub_8K2mQ9xL4nR7vP0a91F');
define('SESH_CHANNEL', 'support');

Warning

Add Upuah in Online Store → Themes → Edit code, or install the Upuah Shopify app when it ships. Paste your publishable key in theme settings.

Open documentation →

{% comment %} layout/theme.liquid — before </body> {% endcomment %}

<script src="https://cdn.upuah.com/widget.js" defer></script>
<script>
  window.Sesh = window.Sesh || [];
  Sesh.push(['init', {
    key: 'fk_pub_8K2mQ9xL4nR7vP0a91F',
    channel: 'support',
    meta: {
      shop: {{ shop.permanent_domain | json }},
      customer: {{ customer.id | default: blank | json }}
    }
  }]);
</script>

Pricing

Simple plans for teams that outgrow basic widgets.

Every plan includes the admin dashboard, API keys, live inbox, and automatic replies. AI is marked soon across all tiers.

Starter

EGP 49/mo

For early teams embedding chat on a single site.

1 month — list price
12 months — 5% off (EGP 46.55/mo)

1 workspace · 2 agents
Live inbox
Automatic replies
Publishable & secret keys
Widget branding
AI replies Soon

Start Starter

Most chosen

Growth

EGP 149/mo

For product and support teams running multiple properties.

1 month — list price
12 months — 10% off (EGP 134.1/mo)
24 months — 20% off (EGP 119.2/mo)

5 workspaces · 15 agents
Live inbox + presence
Unlimited auto-reply rules
Webhooks & channels
Priority email support
AI replies Soon

Choose Growth

Enterprise

Custom

For organizations that need governance, scale, and dedicated support.

12 months — list price
24 months — list price

Unlimited agents & sites
SSO / security review
Dedicated uptime objectives
Custom limits & contracts
Solution engineering
AI roadmap alignment Soon

Contact sales

One control panel. Your API. Live conversations.