SingIDBot — Telegram ID Retrieval Bot for OpenClaw Topic Configuration

Originally published on , you already know that one of the trickiest steps is obtaining the correct Chat ID and Topic Thread ID before you can configure your bot endpoints. Getting those IDs wrong means your bot silently sends messages into the void — no errors, no feedback, just nothing arriving in the right place.

SingIDBot was built specifically to solve that problem. Drop it into any Telegram chat or group, fire the /getids command, and it instantly reports back the Chat ID and — crucially — the message_thread_id for whichever topic the command was sent from.

Beyond the ID retrieval utility, SingIDBot has a second personality: it responds to free-text messages in Singlish — Singapore's beloved colloquial English creole — cycling through randomised phrases like "Aiyoh, you finally came! Welcome lah!" and "Wah, interesting leh. Tell me more can?"

This guide walks through the complete source code, explains each architectural decision, and covers deployment on PythonAnywhere including the free-tier network restrictions you will inevitably hit.

Prerequisites

Requirement	Details
Python 3.10+	Required for python-telegram-bot v20+ async support
python-telegram-bot v20+	The async-native version. Install with pip install python-telegram-bot
Telegram Bot Token	Create via @botfather — send /newbot and copy the token
PythonAnywhere account	Free Beginner account is sufficient to run and test the bot

Section 1 — What SingIDBot Does

The message_thread_id Mechanism

Telegram supergroups can be divided into named Topics, each identified by a message_thread_id. When a message is sent inside a topic, Telegram attaches this integer to the message object. When sent outside any topic, the field is absent entirely — not zero, not null, but genuinely missing.

This is the exact value OpenClaw requires to route notifications to the correct topic thread. SingIDBot's /getids command reads message_thread_id from the incoming message and reports it in plain text for direct copy-paste into your configuration.

Because the field may be absent, the code uses getattr(update.effective_message, 'message_thread_id', None) rather than direct attribute access, which would raise an AttributeError in non-topic contexts.

The Singlish Responder

Any free-text message (not a command) triggers the singlish_chat handler. It classifies the message into greeting, thanks, or default using keyword matching, then picks a random phrase from the corresponding pool.

Section 2 — Code Walkthrough

2.1 Logging Setup

Two handlers run simultaneously: a FileHandler writing UTF-8 lines to singidbot.log, and a StreamHandler for the console.

CODE Kopieren

LOG_FILE = "singidbot.log"

logging.basicConfig(

    format="%(asctime)s [%(levelname)s] %(name)s: %(message)s",

    level=logging.INFO,

    handlers=[

        logging.FileHandler(LOG_FILE, encoding="utf-8"),

        logging.StreamHandler(),

    ],

)

logger = logging.getLogger(__name__)

Tip: The encoding="utf-8" argument is essential if any Telegram usernames contain non-ASCII characters. Without it, a single emoji in a username can crash the logger with a UnicodeEncodeError.

2.2 Singlish Response Bank

SINGLISH_RESPONSES maps category keys to phrase lists. get_singlish_response() uses dict.get() with a "default" fallback so unknown categories never raise a KeyError.

CODE Kopieren

SINGLISH_RESPONSES = {

    "greeting": [

        "Wah, you here ah! Come come, sit down lah!",

        "Eh hello! Long time no see, how are you?",

        "Aiyoh, you finally came! Welcome lah!",

        "Oi! Good to see you sia. What can I help you?",

    ],

    "thanks": [

        "Aiyah, no need to thank one lah!",

        "Wah, so polite! Welcome lah, anytime!",

        "No problem one! Next time also can help you.",

        "Eh, paiseh lah - that is what I am here for!",

    ],

    "default": [

        "Hah? Can repeat or not? I blur blur lah.",

        "Wah, interesting leh. Tell me more can?",

        "Aiyoh, I also dunno how to answer you sia.",

        "Got it lah! But I not so sure about that one.",

        "Eh, you very clever leh. I learn from you!",

    ],

}



def get_singlish_response(category):

    pool = SINGLISH_RESPONSES.get(category, SINGLISH_RESPONSES["default"])

    return random.choice(pool)

2.3 log_activity() Async Helper

CODE Kopieren

async def log_activity(user, event_type, metadata):

    user_info = (

        f"@{user.username}" if user and user.username

        else f"id={user.id}" if user

        else "unknown"

    )

    timestamp = datetime.now(timezone.utc).isoformat()

    logger.info("[%s] event=%s user=%s metadata=%s",

                timestamp, event_type, user_info, metadata)

2.4 /start and /help Handlers

CODE Kopieren

async def start(update, context):

    user = update.effective_user

    await log_activity(user, "START", {"chat_id": update.effective_chat.id})

    greeting = get_singlish_response("greeting")

    name = user.first_name if user and user.first_name else "friend"

    welcome_text = (

        f"{greeting}



Eh {name}, I am *SingIDBot* lah!



"

        "Commands:

- /start

- /help

- /getids"

    )

    await update.message.reply_text(welcome_text, parse_mode="Markdown")

2.5 /getids Handler

The key line is the getattr call. Telegram only populates message_thread_id when a message arrives inside a topic thread — in a regular chat the attribute simply does not exist.

CODE Kopieren

async def get_ids(update, context):

    user = update.effective_user

    await log_activity(user, "ID_RETRIEVAL", {"chat_id": update.effective_chat.id})

    chat_id = update.effective_chat.id

    topic_id = getattr(update.effective_message, "message_thread_id", None)

    response = f"Chat/Group ID: `{chat_id}`

"

    if topic_id is not None:

        response += f"Topic ID: `{topic_id}`

(This ID confirms the specific topic thread)"

    else:

        response += "Topic ID: Not available

(Topics may not be enabled)"

    response += "



Tip: Record these IDs for configuring bot endpoints!"

    await update.message.reply_text(response, parse_mode="Markdown")

    await update.message.reply_text(f"{get_singlish_response('thanks')} Lah!")

2.6 singlish_chat Handler

Registered with filters.TEXT and ~filters.COMMAND. A guard clause checks if the sender is the bot itself to prevent infinite reply loops.

CODE Kopieren

async def singlish_chat(update, context):

    user = update.effective_user

    await log_activity(user, "MESSAGE", {

        "text_preview": update.message.text[:50] if update.message else "N/A"

    })

    if (not update.message

            or update.message.text.startswith("/")

            or update.effective_user.id == context.bot.id):

        return

    user_text = update.message.text.lower().strip()

    if any(w in user_text for w in ["thanks", "thank", "appreciate"]):

        category = "thanks"

    elif any(w in user_text for w in ["hello", "hi", "hey", "oi", "wah", "alamak"]):

        category = "greeting"

    else:

        category = "default"

    await update.message.reply_text(get_singlish_response(category))

2.7 error_handler — Two-Tier Approach

CODE Kopieren

async def error_handler(update, context):

    error = context.error

    if isinstance(error, Exception):

        error_name = type(error).__name__

        error_msg = str(error)

        if "ProxyError" in error_msg or "NetworkError" in error_name:

            logger.warning("Network error (transient): %s", error_msg)

        elif "Conflict" in error_name or "terminated by other getUpdates" in error_msg:

            logger.warning("Conflict error (duplicate instance?): %s", error_msg)

        else:

            logger.error("Unhandled exception: %s: %s",

                         error_name, error_msg, exc_info=context.error)

2.8 main() — Builder Chain and Handler Registration

CODE Kopieren

def main():

    TOKEN = "YOUR_BOT_TOKEN_HERE"

    application = (

        Application.builder()

        .token(TOKEN)

        .connect_timeout(30)

        .read_timeout(30)

        .write_timeout(30)

        .build()

    )

    application.add_handler(CommandHandler("start", start))

    application.add_handler(CommandHandler("help", help_command))

    application.add_handler(CommandHandler("getids", get_ids))

    application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, singlish_chat))

    application.add_error_handler(error_handler)

    logger.info("--- SingIDBot Initializing ---")

    application.run_polling(allowed_updates=Update.ALL_TYPES)

Section 3 — Deployment on PythonAnywhere

Upload singidbot.py via the Files tab, open a Bash console, and run:

CODE Kopieren

pip install python-telegram-bot --upgrade

python singidbot.py

Free-Tier Proxy Restriction

Free accounts route outbound traffic through a proxy that does not whitelist api.telegram.org. Outbound sendMessage calls can fail with httpx.ProxyError: 503 Service Unavailable. Inbound polling via getUpdates works fine — it is only the reply direction that is intermittently blocked.

In practice across four live sessions totalling over 5 hours, only 2 ProxyErrors occurred in 1800+ polling cycles.

Options if you need reliable reply delivery: Upgrade to a paid PythonAnywhere plan, or switch from polling to webhook mode via PythonAnywhere's WSGI layer.

Avoiding Duplicate Instance Conflicts

Telegram only allows one active getUpdates poller per token. Always kill the old process before restarting:

CODE Kopieren

pkill -f singidbot.py

pgrep -a -f singidbot

python singidbot.py

Section 4 — Log Analysis

Session	Duration	Key Events	Errors
Session 1	~2 min	First run. /getids succeeded returning Chat ID 5024469893.	1 ProxyError (no error handler yet)
Session 2	~3 min	Error handler added. /help ProxyError suppressed to WARNING.	1 ProxyError (WARNING only)
Session 3	~14 min	Extended run. 47 consecutive clean polling cycles.	1 ProxyError (WARNING only)
Session 4	~5 hours	1800+ log lines. Clean polling throughout. No conflicts.	2 ProxyErrors total

SingIDBot is production-stable on the free tier. The intermittent ProxyError is a platform constraint, not a code defect.

Quick Reference

Command	What it returns	Notes
/start	Personalised Singlish greeting and command list	Works in any chat context
/help	List of all available commands	Works in any chat context
/getids	Chat ID and Topic Thread ID (if inside a topic)	Must be run inside the target topic to get a valid Thread ID

Vollständiger Original-Artikel

Den kompletten Beitrag mit allen Details direkt auf dev.to lesen.

↗ Original-Artikel auf dev.to lesen