BotComm

Why only bots

Bots deserve their own app.

Bots don't belong in the app where you talk to your family — and strangers don't belong in the app where you talk to your bots. Every conversation here is a session between one account and one bot; that single constraint removes most of what makes messengers complicated, noisy, and risky.

No user-to-user contact

There is no friend list, no discovery of other people, no way to be messaged by a stranger. The server has no route for it.

Bots dial out

A bot is a program that connects to BotComm over one HTTP stream — no inbound ports, no webhooks, no public URL. Run it on a laptop, a Raspberry Pi, or a cluster.

Secrets shown once

A bot's credentials are returned exactly once at creation and can be rotated any time. Access tokens are short-lived RS256 JWTs you can verify against a public jwks.json.

How it works

From POST /bot to a live conversation.

Create a bot

Name it and claim a unique @handle. You get its client credentials back — once.

It connects

The bot authenticates with its credentials and holds an event stream from /updates. While the stream is up, it shows as online.

People find it

Make the bot public and anyone can open a chat by its handle. Each person gets their own private session.

Messages flow

Delivered instantly over the stream when you're in the app, as a push notification when you're not. Read receipts go both ways.

For developers

A bot is a for-loop.

This is the complete echo bot, in whichever language you already write. Authentication, token refresh, reconnects, and unread back-fill are the SDK's problem, not yours.

Official SDKs for Go, Python, JavaScript, and Rust — the same bot, four ways.
Or use any language — it's a small REST API plus one Server-Sent Events stream of plain JSON envelopes.
Register slash-commands and they arrive on their own channel, pre-routed.

go get github.com/BotComm/go-api

b := &bot.Bot{
    ClientID:     os.Getenv("CLIENT_ID"),
    ClientSecret: os.Getenv("CLIENT_SECRET"),
}

b.NewSession = func(s *bot.Session) {
    b.Send(ctx, s.ID, "Hello! I repeat everything you say.")
}

if err := b.Run(ctx); err != nil {
    log.Fatal(err)
}

for msg := range b.Messages {
    b.Send(ctx, msg.SessionID, msg.Content)  // echo
}

bot = Bot(client_id, client_secret)

async def greet(session):
    await bot.send(session.id, "Hello! I repeat everything you say.")

bot.on_new_session = greet
await bot.run()

while True:
    msg = await bot.messages.get()
    await bot.send(msg.session_id, msg.content)  # echo

const bot = new Bot({ clientId, clientSecret });

bot.on('new_session', (session) =>
  bot.send(session.id, 'Hello! I repeat everything you say.'));

bot.on('message', (msg) =>
  bot.send(msg.sessionID, msg.content));  // echo

await bot.run();

let config = Config::new(client_id, client_secret);
let (bot, mut events) = Bot::run(config).await?;

while let Some(event) = events.recv().await {
    match event {
        Event::NewSession(s) => {
            bot.send(&s.id, "Hello! I repeat everything you say.", false).await?;
        }
        Event::Message(msg) => {
            bot.send(&msg.session_id, &msg.content, false).await?;  // echo
        }
        _ => {}
    }
}

Under the hood

Everything a messenger needs. Nothing it doesn't.

Real-time delivery

One Server-Sent Events stream carries messages, new sessions, and read receipts as JSON. No polling, no sockets.

Push when away

Offline users get an APNs notification instead, with the badge kept at the true unread count.

Nothing gets lost

Reconnecting clients back-fill unread messages per session and confirm reads, so state converges after any outage.

Simple sign-in

An email code or Sign in with Apple. Refresh tokens rotate on every use, and a reused token revokes its whole family.

Bot commands

Bots publish a command menu; the app renders it, and commands arrive at the bot already separated from chat.

iOS, Android, and web

Native apps on the App Store and Google Play, plus a web app — all talking to the same open REST API you can script with curl.

Humans on one side. Bots on the other.