30 Claude Prompts That Build Telegram Bots

You are a Python developer building commerce bots for Telegram. <context> I want a bot that lets customers browse my product catalog with inline buttons: categories, product cards with photos, and a details view. Deliver a single runnable file. </context> <inputs> - Catalog source: [HARDCODED LIST / JSON FILE / API] - Product fields: [NAME, PRICE, DESCRIPTION, PHOTO URL, CATEGORY] - Currency: [E.G. USD] - Browse UX: [CATEGORY MENU -> PRODUCT LIST -> DETAILS] - Commands: [E.G. /shop, /search] </inputs> <task> Build a python-telegram-bot with inline-keyboard navigation: /shop shows a category menu, tapping a category lists products as cards, tapping a product shows its photo, price, and full description with a Back button. Add /search <term> to find products by name. Load the catalog from a JSON file so it can be edited without touching code. Use callback data routing and edit messages in place for smooth navigation. </task> <constraints> - One runnable .py file; token from env; catalog JSON path and deps in a header comment. - Clean callback_data routing; edit the same message on navigation rather than spamming new ones. - Send product photos by URL or file_id; handle missing images gracefully. </constraints> <format> Return the full code in one block plus a small sample catalog.json, then explain the callback routing scheme. </format>

You are a Python developer building ordering bots for restaurants and shops on Telegram. <context> I want a bot where customers browse a menu, add items to a cart, adjust quantities, and place an order that gets sent to me. Deliver a single runnable file. </context> <inputs> - Menu: [ITEMS WITH NAME, PRICE, CATEGORY] - Currency: [E.G. GBP] - Order destination: [MY CHAT ID / A GROUP] - Fields to collect: [NAME, ADDRESS/TABLE, PHONE, NOTES] - Commands: [E.G. /menu, /cart, /checkout] </inputs> <task> Build a python-telegram-bot with an inline menu where each item has Add / +/- quantity buttons that build a per-user cart. /cart shows the current cart with a running total and Remove buttons, /checkout collects delivery details via a short conversation, confirms the order summary, and forwards the full order to the order-destination chat with a generated order id. Keep carts per user in memory (or SQLite) until checkout. </task> <constraints> - One runnable .py file; token from env; menu and deps in a header comment. - Use ConversationHandler for the checkout steps; validate required fields. - Accurate cart math; clear order summary; unique order id per order. </constraints> <format> Return the full code in one block, then explain the cart state model and how to persist carts across restarts. </format>

You are a Python developer building customer-service bots for Telegram. <context> I want a bot where customers enter an order number and get its current status, and where I (as admin) can update statuses. Deliver a single runnable file. </context> <inputs> - Order data source: [SQLITE / A JSON FILE / API] - Status stages: [E.G. RECEIVED, PREPARING, SHIPPED, DELIVERED] - Admin chat id(s): [WHO CAN UPDATE] - Lookup key: [ORDER ID / PHONE] - Commands: [E.G. /track, /setstatus (admin)] </inputs> <task> Build a python-telegram-bot where /track <order_id> returns the order's current stage, timestamp of last update, and a simple progress indicator. Admins can run /setstatus <order_id> <stage> to advance an order, which optionally notifies the customer's chat if it is on file. Reject unknown order ids with a helpful message and gate admin commands to allowed chat ids. Persist orders and status history in SQLite. </task> <constraints> - One runnable .py file; token from env; admin ids and deps in a header comment. - Admin-only commands enforced by chat id; validate stage against the allowed list. - Store status history with timestamps; customer notification is optional and safe if no chat is linked. </constraints> <format> Return the full code in one block, then explain the order schema and how to auto-import orders from an API. </format>

You are a Python developer building scheduling bots for Telegram. <context> I want a bot that shows my available time slots and lets customers book one, then confirms and notifies me. Deliver a single runnable file. </context> <inputs> - Services offered: [NAME + DURATION] - Working hours: [E.G. MON-FRI 09:00-17:00] - Slot length: [E.G. 30 MIN] - Timezone: [E.G. EUROPE/BERLIN] - Commands: [E.G. /book, /mybookings, /cancel, /slots (admin)] </inputs> <task> Build a python-telegram-bot where /book walks the user through picking a service, a date, and an open slot via inline keyboards, then stores the booking and confirms it, notifying the owner chat. It must hide already-taken slots and slots outside working hours. /mybookings lists a user's upcoming bookings, /cancel frees a slot. Persist bookings in SQLite and prevent double-booking with a uniqueness check. </task> <constraints> - One runnable .py file; token from env; hours, slot length, and deps in a header comment. - Generate slots from working hours minus existing bookings; timezone-aware. - Atomic booking to prevent races/double-booking; clear confirmation message. </constraints> <format> Return the full code in one block, then explain slot generation and how to add buffer time between appointments. </format>

You are a Python developer experienced with the Telegram Payments API. <context> I want a bot that sells a product or service and takes real payment inside Telegram using the Bot Payments API and a provider token. Deliver a single runnable file. </context> <inputs> - Provider token: [FROM BOTFATHER / STRIPE VIA TELEGRAM] - Products: [NAME, DESCRIPTION, PRICE] - Currency: [E.G. USD] - Post-payment action: [DELIVER A LINK / CODE / CONFIRMATION] - Commands: [E.G. /buy, /orders] </inputs> <task> Build a python-telegram-bot that sends an invoice via send_invoice when the user picks a product, correctly answers the PreCheckoutQuery, and on successful_payment delivers the post-payment item and records the order. Handle the full payment lifecycle: invoice -> pre-checkout validation -> successful_payment handler. /orders lists the user's paid orders. Persist orders in SQLite with the Telegram payment charge id. </task> <constraints> - One runnable .py file; bot token and provider token from env; deps in a header comment. - Implement PreCheckoutQueryHandler (must answer within seconds) and a successful_payment message handler. - Store the telegram_payment_charge_id; never deliver goods before successful_payment fires. </constraints> <format> Return the full code in one block, then explain how to get a provider token from BotFather and how to test payments in test mode. </format>

You are a Python developer building content-automation bots for Telegram. <context> I want a bot that watches RSS feeds and auto-posts new items to my Telegram channel, formatted cleanly. Deliver a single runnable file. </context> <inputs> - Feeds: [LIST OF RSS URLS] - Target channel: [@CHANNEL OR ID] - Poll interval: [E.G. EVERY 15 MINUTES] - Post format: [TITLE, SUMMARY, LINK] - Commands: [E.G. /addfeed, /feeds, /rmfeed (admin)] </inputs> <task> Build a python-telegram-bot that polls each RSS feed on the interval, detects new entries (dedupe by guid/link), and posts them to the channel with a formatted title, trimmed summary, and link. Admin-only /addfeed <url>, /feeds, and /rmfeed <url> manage the feed list at runtime. Persist seen-entry ids and the feed list in SQLite so restarts do not repost old items. Respect Telegram message length limits. </task> <constraints> - One runnable .py file; token from env; admin ids and deps (incl. a feed parser) in a header comment. - Dedupe with a persisted seen-set; skip items already posted before first run of a new feed. - Handle malformed feeds and network errors without crashing the poller. </constraints> <format> Return the full code in one block, then explain the dedupe strategy and how to add per-feed formatting. </format>

You are a Python developer building creator-notification bots for Telegram. <context> I want a bot that alerts me (or a channel) whenever specific YouTube channels upload a new video. Deliver a single runnable file. </context> <inputs> - YouTube channels to watch: [CHANNEL IDS OR HANDLES] - Data method: [YOUTUBE RSS FEED PER CHANNEL / DATA API] - Destination: [MY CHAT / A CHANNEL] - Poll interval: [E.G. EVERY 20 MINUTES] - Commands: [E.G. /watch, /list, /unwatch] </inputs> <task> Build a python-telegram-bot that checks each watched YouTube channel's uploads feed and posts a message with the video title, channel name, and link for new uploads only. Prefer the per-channel RSS feed (no API key needed). /watch <channel>, /unwatch <channel>, and /list manage the watch list live. Persist watched channels and last-seen video ids in SQLite so restarts do not re-alert. </task> <constraints> - One runnable .py file; token from env; deps in a header comment. - Resolve handles to channel ids if needed; dedupe by video id. - Never re-post the backlog when a channel is first added; handle empty feeds. </constraints> <format> Return the full code in one block, then explain how to find a channel id and how to switch to the Data API for richer info. </format>

You are a Python developer building scheduled digest bots for Telegram. <context> I want a bot that collects headlines from a few sources and sends me one clean digest at a set time each day. Deliver a single runnable file. </context> <inputs> - Sources: [RSS FEEDS / A NEWS API] - Topics/keywords to prioritize: [OPTIONAL LIST] - Digest time: [E.G. 08:00 MY TIMEZONE] - Items per digest: [E.G. TOP 10] - Commands: [E.G. /now, /sources, /settime] </inputs> <task> Build a python-telegram-bot that, at the scheduled time, pulls the latest items from all sources, dedupes across feeds, optionally boosts items matching my keywords to the top, and sends a single numbered digest with title + link per item. /now sends the digest on demand, /sources lists feeds, /settime <HH:MM> changes the schedule. Use JobQueue for the daily send and persist settings in SQLite. </task> <constraints> - One runnable .py file; token from env; deps in a header comment. - Cross-feed dedupe by normalized title/URL; cap the digest at the configured item count. - Timezone-aware daily schedule; degrade gracefully if a source is down. </constraints> <format> Return the full code in one block, then explain the ranking/dedupe logic and how to add a source. </format>

You are a Python developer building community-monitoring bots for Telegram. <context> I want a bot that watches subreddits and pings me when new posts match my filters (keyword, min upvotes, flair). Deliver a single runnable file. </context> <inputs> - Subreddits: [LIST] - Filters: [KEYWORDS, MIN SCORE, FLAIR] - Access method: [REDDIT JSON ENDPOINT / PRAW WITH API KEYS] - Poll interval: [E.G. EVERY 10 MINUTES] - Commands: [E.G. /watch, /filters, /list] </inputs> <task> Build a python-telegram-bot that polls the newest posts of each subreddit, applies the filters, and sends matching posts with title, subreddit, score, and permalink. Use the public .json endpoint by default (no keys) with a proper User-Agent, or PRAW if keys are provided. /watch <subreddit>, /list, and /filters manage config at runtime. Dedupe by post id in SQLite so restarts do not re-alert. </task> <constraints> - One runnable .py file; token from env; optional Reddit keys from env; deps in a header comment. - Set a descriptive User-Agent; respect Reddit rate limits with backoff. - Filter by keyword, min score, and flair; dedupe by post id. </constraints> <format> Return the full code in one block, then explain the JSON-vs-PRAW toggle and how to tune the filters. </format>

You are a Python developer building media-notification bots for Telegram. <context> I want a bot that watches podcast RSS feeds and notifies me when a new episode drops, with the title and listen link. Deliver a single runnable file. </context> <inputs> - Podcast feeds: [LIST OF RSS URLS] - Destination: [MY CHAT / A CHANNEL] - Poll interval: [E.G. HOURLY] - Info to include: [TITLE, DURATION, PUBLISH DATE, LINK] - Commands: [E.G. /addpod, /pods, /rmpod] </inputs> <task> Build a python-telegram-bot that polls each podcast RSS feed, detects new episodes (dedupe by guid), and posts the episode title, publish date, duration, and audio/listen link. /addpod <url>, /pods, and /rmpod <url> manage the feed list live. Optionally send the episode's cover image. Persist feeds and seen-episode guids in SQLite so restarts do not re-notify old episodes. </task> <constraints> - One runnable .py file; token from env; deps (incl. a feed parser) in a header comment. - Parse iTunes podcast RSS fields (duration, enclosure URL); dedupe by guid. - Mark existing episodes seen on a feed's first poll; handle malformed feeds. </constraints> <format> Return the full code in one block, then explain the RSS enclosure parsing and how to add episode summaries. </format>

You are a Python developer building Telegram group-management bots. <context> I run a Telegram group and want a bot that greets new members, posts the rules, and points them to key resources. Deliver a single runnable file. </context> <inputs> - Welcome message: [TEXT, CAN USE {name} AND {group}] - Rules: [BULLET LIST] - Useful links: [E.G. FAQ, WEBSITE, PINNED GUIDE] - Cleanup: [DELETE WELCOME AFTER N SECONDS? YES/NO] - Commands: [E.G. /rules, /setwelcome (admin)] </inputs> <task> Build a python-telegram-bot that detects new_chat_members, sends a personalized welcome with the member's name and inline buttons linking to rules and resources, and optionally deletes the welcome after a delay to keep chat clean. /rules posts the rules on demand; admin-only /setwelcome updates the welcome text at runtime. Store per-group welcome text and rules in SQLite so one bot can serve multiple groups. </task> <constraints> - One runnable .py file; token from env; deps in a header comment. - Handle new_chat_members updates; personalize with the member's first name safely. - Admin-only config commands (check chat admin status via get_chat_member); per-group settings. </constraints> <format> Return the full code in one block, then explain how it checks admin status and how to support multiple groups. </format>

You are a Python developer building moderation bots for busy Telegram groups. <context> My group gets spam, message floods, and unsolicited links. I want a bot that auto-removes them and warns offenders. Deliver a single runnable file. </context> <inputs> - Flood rule: [E.G. MORE THAN 5 MSGS IN 10 SECONDS] - Link policy: [BLOCK ALL LINKS / ALLOWLIST DOMAINS] - Banned words: [LIST] - Action ladder: [WARN -> MUTE -> BAN] - Commands: [E.G. /allow, /ban, /settings (admin)] </inputs> <task> Build a python-telegram-bot that detects flooding (rate per user), messages with disallowed links, and banned words, deletes the offending message, and escalates through warn -> temporary mute -> ban based on repeat offenses. Track per-user warning counts in SQLite. Admins bypass all filters and can /allow <domain>, /ban <reply>, and view /settings. Never act on admins; log every action. </task> <constraints> - One runnable .py file; token from env; thresholds and deps in a header comment. - Exempt group admins from filters; use restrict_chat_member for mutes and ban_chat_member for bans. - Sliding-window flood detection; case-insensitive word matching; domain allowlist for links. </constraints> <format> Return the full code in one block, then explain the escalation ladder and how to tune the flood window. </format>

You are a Python developer building bot-defense tools for Telegram groups. <context> Bot accounts keep joining my group. I want a captcha bot that restricts new members until they prove they are human. Deliver a single runnable file. </context> <inputs> - Captcha type: [BUTTON TAP / SIMPLE MATH / EMOJI PICK] - Time limit: [E.G. 60 SECONDS TO SOLVE] - Fail action: [KICK / BAN] - Restricted state: [MUTE UNTIL SOLVED] - Commands: [E.G. /verify (fallback), /settings (admin)] </inputs> <task> Build a python-telegram-bot that, on a new member joining, mutes them (restrict_chat_member with no send permissions) and posts a captcha with inline buttons only the joining user can solve. On success, restore full permissions and delete the captcha; on timeout or wrong answer, kick or ban per the fail action. Handle the timer with JobQueue, ensure only the target user's taps count, and clean up messages. Persist per-group settings in SQLite. </task> <constraints> - One runnable .py file; token from env; time limit and deps in a header comment. - Correctly restrict then restore ChatPermissions; only the joining user's callback solves it. - Timeout via JobQueue triggers the fail action; delete captcha and system join messages. </constraints> <format> Return the full code in one block, then explain the permission restrict/restore flow and how to change the captcha type. </format>

You are a Python developer building admin command tools for Telegram groups. <context> I want a moderation bot that gives my admins reply-based commands to warn, mute, and ban users, with a tracked warning system. Deliver a single runnable file. </context> <inputs> - Warn limit before action: [E.G. 3 WARNINGS = MUTE] - Default mute duration: [E.G. 1 HOUR] - Who can moderate: [GROUP ADMINS ONLY] - Commands: [E.G. /warn, /unwarn, /mute, /unmute, /ban, /kick, /warns] - Reason logging: [YES / NO] </inputs> <task> Build a python-telegram-bot where admins reply to a user's message with /warn (with optional reason) to add a warning; when warnings hit the limit, auto-mute for the default duration. Add /mute <duration>, /unmute, /ban, /kick, /unwarn, and /warns <reply> to show a user's warning count and reasons. Enforce admin-only usage via get_chat_member, store warnings and mod-log entries in SQLite, and confirm each action in-chat. </task> <constraints> - One runnable .py file; token from env; warn limit, mute duration, and deps in a header comment. - All commands admin-gated; parse durations like 30m/1h/1d; use restrict/ban/unban APIs correctly. - Auto-escalate at the warn limit; never let a command act on another admin. </constraints> <format> Return the full code in one block, then explain the warning schema and how to add a temp-ban with auto-unban. </format>

You are a Python developer building group-communication bots for Telegram. <context> I want a bot that posts scheduled announcements to my group and can auto-pin them, so recurring notices go out without me remembering. Deliver a single runnable file. </context> <inputs> - Announcements: [TEXT + WHEN, E.G. "MONDAY 09:00 STANDUP"] - Auto-pin: [YES / NO, UNPIN AFTER N HOURS?] - Target group(s): [ID(S)] - Timezone: [E.G. UTC] - Commands: [E.G. /schedule, /announcements, /cancel, /now (admin)] </inputs> <task> Build a python-telegram-bot where admins schedule one-off or recurring announcements (specific days/times) that the bot posts to the group and optionally pins, then unpins after a set duration. /schedule creates one, /announcements lists them, /cancel <id> removes one, /now <id> posts immediately. Use JobQueue for timing, persist schedules in SQLite, and rebuild all jobs on startup. Gate all commands to admins. </task> <constraints> - One runnable .py file; token from env; deps in a header comment. - Support recurring (weekday/time) and one-off schedules; timezone-aware. - Admin-gated; pin/unpin via the correct API calls; reschedule persisted jobs on boot. </constraints> <format> Return the full code in one block, then explain the schedule format and how to add per-announcement pin rules. </format>