How to Build a Prediction Market Telegram Bot With an API

A Telegram bot is the cheapest useful interface you can put on market data. No frontend, no hosting a UI, no login. You send a message and it appears on someone's phone.

The build is genuinely small. What takes the time is the parts nobody mentions: Telegram's rate limits, how to stop the bot shouting, and what happens when the process restarts.

Creating the Bot

Message @BotFather on Telegram, send /newbot, pick a name and a username. You get a token that looks like 123456789:AAH.... That token is a credential. It belongs in an environment variable, not in your repository.

Next you need a chat id, because a bot cannot message someone who has not spoken to it first. Send your bot a message, then read it back:

curl "https://api.telegram.org/bot$TOKEN/getUpdates"

Sending a Message

async function send(text) {
  await fetch(`https://api.telegram.org/bot${process.env.TG_TOKEN}/sendMessage`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      chat_id: process.env.TG_CHAT_ID,
      text,
      parse_mode: 'HTML',
      disable_web_page_preview: true
    })
  });
}

Wiring In Prices

Now the other half. Subscribe once and let the venue push updates to you.

import Predictefy from '@predictefy/sdk';

const client = new Predictefy({ apiKey: process.env.PREDICTEFY_API_KEY });
const lastSide = new Map();

const watch = (venue, marketId, label, threshold) =>
  client.watchOrderBook({ venue, marketId }, ({ data }) => {
    const ask = data.asks[0]?.price;
    if (ask === undefined) return;

    const key = `${venue}:${marketId}`;
    const above = ask >= threshold;
    const before = lastSide.get(key);
    lastSide.set(key, above);

    if (before === undefined || before === above) return;
    send(`<b>${label}</b>\n${venue} ask ${ask} crossed ${threshold}`);
  });

Adding a second venue is one more call with a different venue string. Nothing else changes, because the book shape is the same across all 15+ venues.

Telegram's Rate Limits

This is where working bots become annoying bots. Telegram allows roughly one message per second to a single chat and around 30 per second overall. Exceed it and you get a 429 with a retry_after, and messages start disappearing.

A volatile market can trip forty rules in a few seconds. The fix is a queue with a floor on spacing, and batching anything that arrives together.

const queue = [];
let draining = false;

function enqueue(text) {
  queue.push(text);
  if (!draining) drain();
}

async function drain() {
  draining = true;
  while (queue.length) {
    // One message carrying five lines beats five messages.
    const batch = queue.splice(0, 10).join('\n');
    await send(batch);
    await new Promise((r) => setTimeout(r, 1100));
  }
  draining = false;
}

Taking Commands

A bot that only pushes is a notifier. Accepting commands turns it into something people use. The simplest approach is long polling: ask Telegram for new messages, act on them, repeat.

let offset = 0;

async function poll() {
  const res = await fetch(
    `https://api.telegram.org/bot${process.env.TG_TOKEN}/getUpdates?timeout=30&offset=${offset}`
  ).then((r) => r.json());

  for (const update of res.result ?? []) {
    offset = update.update_id + 1;
    const text = update.message?.text ?? '';

    if (text.startsWith('/price ')) {
      const book = await client.router.fetchMarkets({ query: text.slice(7) });
      send(formatResults(book));
    }
  }
  poll();
}

Why the Venue Layer Matters Here

The Telegram half of this bot is the same whatever data you put behind it. The half that decides whether the project survives is the market data.

Written per venue, you maintain a WebSocket client for Kalshi, another for Polymarket with its own identifier scheme, another for SX Bet on Centrifugo, and each one breaks independently. Through Predictefy it is one connection, one book shape and one reconnect strategy across 15+ venues, so the bot above gains a venue by changing a string. The API key is free to start with a monthly credit allowance, which comfortably covers a personal bot.

Frequently Asked Questions

Conclusion

The bot itself is two HTTP calls. What separates one people keep and one they mute is restraint: fire on crossings rather than states, batch bursts into single messages, and respect the rate limit before Telegram enforces it for you.

Build the alerting logic first and the Telegram wiring last. The delivery is the easy half.

One housekeeping note: this is information, not financial advice. Endpoints, limits and credit costs change, so confirm anything that matters against the current documentation.