How to create a Telegram bot with Python in less than 10 minutes

If you use Telegram daily, you've probably thought more than once how great it would be to have a bot that does tasks for you. Medication reminders, answers to frequently asked questions, or automatic alerts These are just a few examples of what you can automate without breaking a sweat. The good news is that, with Python, you can have a working bot up and running in minutes.

In this article you will learn How to create a Telegram bot with Python in less than 10 minutesStarting from scratch and understanding what you're doing at each step. We'll cover everything from creating the bot with BotFather, installing libraries, real code examples, to options for deploying it in the cloud (like AWS or free services) so you don't have to keep your computer on all day.

What exactly is a Telegram bot and why is it worth creating one?

A Telegram bot is, in essence, a program that lives within Telegram and responds to messages following rules that you define in the code. It's not a human user, but a "special account" controlled by a backend that you develop, usually hosted on a server or a cloud service.

These bots can be as simple as a system that always responds with the same message, or as advanced as a assistant with Artificial Intelligence that understands natural languagemanage payments, speak multiple languages, and connect to external services (APIs, databases, systems IoTetc.). Telegram offers a Bot API is open and very well documented which greatly facilitates development.

Furthermore, Bots are not limited to private chatsThey can function in groups, supergroups, and channels, moderate conversations, send summaries, polls, and all kinds of multimedia content. That's why they've become a key component for automating tasks, managing communities, and offering services without taking the user out of the app.

From a technical point of view, a bot communicates with Telegram using HTTPS requests to the Bot APIYou write the code (for example in Python), Telegram gives you a secret token, and from there, everything is done by exchanging JSON between your scripts and Telegram's servers.

Real-world use cases: what Telegram bots are used for today

Before we start coding, it's good to be clear What kind of problems can you solve with a Telegram bot?This will help you better design your bot's logic and, above all, ensure it doesn't remain just a simple experiment.

Many companies use bots as first level of customer serviceA bot can answer frequently asked questions, check order status, manage bookings, or send personalized help links. If things get complicated, it can escalate the conversation to a human, but initially, it takes a lot of repetitive work off your hands.

Another very common application is the content distributionThere are bots that read RSS feeds, blogs, YouTube channels, or social media and send news, posts, or videos to users or channels in real time. This is ideal for media outlets, content creators, or anyone who wants to centralize information without switching apps.

On a personal level, productivity bots make all the difference: reminders, to-do lists, event alerts, or smart alarmsA bot can understand phrases like "Remind me about my medication tomorrow at 8" and schedule a notification at the appropriate time, without having to open a different app.

There are also bots geared towards leisure and utility: media content download (always respecting copyright), travel managers who recommend flights and hotelsBots for viewing maps, managing personal finances, receiving alerts from industrial systems or server monitoring, etc. The combination of 24/7 availability and ease of use makes the range of possibilities enormous.

How the architecture of a Telegram bot works

To fully understand what you're going to program, it's helpful to have a clear grasp of the basic architecture. On one hand, there's Telegram, with its servers and the Bot APIAnd on the other hand, there's your application (the code in Python, Node.js, or whatever language you choose) that runs somewhere: your PC, a virtual machine, a serverless service, a container, etc.

When a user sends a message to your bot, Telegram generates a “update” in JSON formatThat update arrives to your program in two possible ways: either you will look for it using polling with the getUpdates methodOr Telegram sends it to you automatically via a HTTPS webhook that you have previously configured.

In polling mode, your script It periodically requests Telegram asking if there are any new messages. It's perfect for local development and rapid testingBecause you don't need to expose your machine to the internet or configure certificates. You just run the script and you're done.

In webhook mode, on the other hand, Telegram sends updates directly to an HTTPS URL that you control. This is best suited for production environmentsBecause you reduce latency, you're not making constant requests, and you can scale the application behind a web server, proxy, or load balancer. Here, you absolutely need a public URL and a valid SSL certificate.

In both cases, your bot receives the JSON, processes it according to the logic you have defined, and responds using Bot API methods such as sendMessage, sendPhoto, responseCallbackQuery and many others. High-level libraries (like python-telegram-bot or Telegraf in Node.js) encapsulate these details so you only have to work with functions and handlers. commands.

Prerequisites for creating a bot with Python in a few minutes

To set up your first bot you don't need a huge corporate environment, but you do need some very clear minimum requirementsHaving them prepared will save you time and silly mistakes during setup.

The basics are to have Python 3 installed on your systemAny modern version (3.8 and later) is usually more than sufficient. It's also recommended to have pip available for installing packages, although it's already included with Python in most current distributions.

The next step is to install a library that simplifies working with the Bot API. In this case, we'll use python-telegram-bot, one of the most popular and maintained Python community plugins. To install it, simply run the following command in the terminal:

pip3 install python-telegram-bot

In addition to the technical setup, you need to register the bot itself on Telegram. To do this, you will use @BotFatherThe official Telegram bot acts as a control panel for all your bots. From there, you'll create the bot, name it, and obtain the access token that will be the key for your script to manage that account.

Create a Telegram bot with BotFather

The starting point is always the same: Register the bot and get the tokenWithout that token, your code won't be able to communicate with the Bot API or send messages to anyone, because it's what uniquely identifies your bot.

Open Telegram and search for the user @BotFatherIt's an official, verified bot, so you can't go wrong. Once you have it, start a chat with it and type the command. /newbotBotFather will guide you step by step.

First you will need to specify a a “friendly” name for your botThis is what users will see (for example, “Medication Reminder”). Then it will ask you for a username, which must be unique and end in botsuch as recordatorio_meds_bot or something similar.

Once the process is complete, BotFather will return a API token with a format similar to this: 123456789:ABC-DEF…This token is sacred: treat it like a very strong password. Don't publish it on GitHub, don't copy it to forums, and if you ever think it's been leaked, you can regenerate it from BotFather using token rotation commands.

With that, you already have the essentials: a Telegram bot account and the credentials to control it from your Python codeNow it's time to prepare a small script that connects the pieces.

Installing python-telegram-bot and preparing the environment

With the token in hand, the next step is to ensure your Python environment is ready to work with the Telegram API. As we mentioned, the most convenient option is to use the library python-telegram-bot, which offers you high-level classes and functions to define commands, manage conversations, and send messages.

If you haven't already done so, install the library by running the following command in your terminal or console:

pip3 install python-telegram-bot

On many systems, if you only have one version of Python, it may also work simply:

pip install python-telegram-bot

With this, you can now create a Python file, for example bot_telegram.pyThis is where you'll start writing your bot's code. You can use any text editor or IDE: VS Code, PyCharm, Sublime Text, even Notepad If you'd like. The important thing isn't the tool, but the content of the script.

The minimum structure of a bot with python-telegram-bot consists of importing the necessary classes, Configure the application with your token and define at least one handler function for the command /startwhich is usually the gateway to any bot.

First example: minimal bot with /start command

Let's look at a practical example of a very simple bot that responds with a basic message when the user sends the command /startThis will allow you to verify that everything is properly connected: correct token, installed library, and communication with Telegram is working.

In your file bot_telegram.pyYou can create a modern version based on the current python-telegram-bot (asynchronous) architecture with code similar to this, adapted to a more recent style:

from telegram.ext import ApplicationBuilder, CommandHandler

async def start(update, context):
await update.message.reply_text("Hello! I'm your example bot on Telegram.")

TOKEN = "YOUR_TOKEN_HERE"

def main ():
app = ApplicationBuilder().token(TOKEN).build()
app.add_handler(CommandHandler("start", start))
app.run_polling()

if __name__ == "__main__":
Main()

In this excerpt, ApplicationBuilder creates the main bot application, to which you associate a handler for the command /start. The function start It is responsible for responding to the user with a simple text, and run_polling() Activate long polling mode, so that the bot keeps asking Telegram for new updates.

To run it, simply launch the following in the terminal:

python3 bot_telegram.py

If everything is working correctly, you'll see console messages indicating that the bot is active. Open Telegram, search for your bot using the username you assigned it in BotFather, open the chat, and send a message. /start. You should receive the welcome message that you have defined in the code.

Making the bot more useful: menus, statuses, and conversations

Starting with the basic "hello world", the fun lies in adding More advanced logic: menus, buttons, different conversation flows and state management. This is where the real power of python-telegram-bot comes into play, with tools like ReplyKeyboardMarkup, InlineKeyboardMarkup or ConversationHandler.

Suppose you want to create a bot to report incidents or disastersSimilar to projects like DisAtBot, the idea is to display an initial menu with options such as "Submit report," "View map," "FAQ," or "About." To do this, you can define a custom keyboard with buttons that the user can press, instead of forcing them to type text manually.

Using a fast-response keyboard, you define a list of lists in Python, where each sublist represents a row of buttons. Then, you use ReplyKeyboardMarkup to build the keyboard and you pass it off as an argument to reply_text or similar methods, so that Telegram displays those buttons above the writing box.

This technique is ideal when you need highly guided workflows, such as step-by-step forms, questionnaires, or critical processes where you don't want the user to make typing mistakes. Furthermore, you can combine it with a state machine using ConversationHandlerwhere each state of the flow is associated with one or more different handlers (for example, choosing language, choosing report type, requesting geolocation, confirming data, etc.).

The library allows you to define a dictionary of states where each key is an integer (the state identifier) ​​and the value is a list of handlers that are activated at that point. In this way, You preserve the context between messages And you can build complex dialogues without going crazy with if/else statements everywhere.

Practical example: medication reminder bot (every other day).

A very specific and useful example is that of remember to take your medicationalternating between medication at midday and at dinner, every other day. The initial approach of checking if the calendar day is even or odd seems simple, but it breaks down when you change months (30, 31 days, February, leap years, etc.).

The most robust way to solve this is not to rely on the day of the month, but on a fixed reference dateFor example, you can store somewhere (a file, a database, or even a persistent variable on the server) the date of the first day you took the medication and define that day as "noon dose day." From there, you calculate how many days have passed since that initial date.

With the current date and the start date, you can calculate the difference in days using the functions in the Python standard library (module datetimeThen, you do a modulo 2 (remainder when dividing by 2)If the remainder is 0, you get one type of meal (for example, midday); if the remainder is 1, you get the other (for example, dinner). Since the calculation is based on the total number of days that have passed, the change of month and the number of days in each month do not affect you.

Your bot can then run a small script that, at a specific time each day, calculates whether it's lunchtime or dinnertime and sends you the corresponding message. To schedule the automatic sending, you can integrate scheduling libraries in Python, such as schedule or apscheduler, or rely on external systems such as cron jobs, scheduled Lambda functions, or scheduled tasks from the service where you host the bot.

Where to host your bot: free and cloud-based options

A very common question is: Do I have to keep my computer on all day for the bot to work? The answer is no, as long as you deploy it on some cloud service or online platform that keeps the process running for you.

Services like PythonAnywhere allows you to run Python scripts in the cloudThese plans can be a good option for testing or simple bots. However, free plans often have limitations on continuous runtime, outbound connections, or availability. It's important to review their terms and conditions to ensure your bot will remain active without constant monitoring.

If you want something more robust but also with very economical options (or almost free in low volume), a very interesting alternative is to use AWS with a serverless approachFor example, you can set up your bot with a webhook served by AWS Lambda, exposed through Amazon API Gateway. In this model, your code only runs when Telegram sends an update, and you don't have to worry about keeping a server running. If you need additional protection, consider services like Cloudflare.

In this approach, you define a Lambda function that receives the JSON that Telegram sends to your webhook, validates the secret token, processes the message, and responds by calling the Bot API via HTTPS requests. The cost for low traffic is usually very lowAnd you don't have to manage machines, patches, or reboots.

For larger bots, with more traffic or heavier dependencies, you can opt for containers in ECS Fargate together with an Application Load BalancerIn this case, you run your bot (for example, a FastAPI application integrated with python-telegram-bot in webhook mode) inside a Docker container, and the ALB receives the HTTPS requests and redirects them to your Fargate tasks. It's more complex, but also very scalable and flexible.

Long polling vs webhooks: which to choose and when

Telegram supports two mutually exclusive approaches to receiving updates: getUpdates (polling) or webhooksYou can't use both at the same time; either your bot queries Telegram, or Telegram pushes the updates to your server.

El long polling It's the simplest way to start. Your code periodically calls getUpdatesThis indicates a timeout period to keep the connection open until new messages are received. It's ideal for local development because you can run the bot on your laptop without exposing ports to the outside world, and the python-telegram-bot library handles these details with methods like run_polling().

Los webhooksOn the other hand, they are the option designed for production. You configure an HTTPS URL (for example, an endpoint in API Gateway, a Flask/FastAPI server, or a route in a Node framework like Express or Telegraf) and call the method setWebhook from the Bot API by specifying that URL. From that moment on, every update that Telegram receives will be sent as a POST request in JSON format to your endpoint.

With webhooks you can add a extra layer of security using the secret_token parameterWhen defining the webhook, you pass it a secret token and then, on your server, you validate that the header X-Telegram-Bot-Api-Secret-Token This matches the expected value. This way, you only accept requests that actually come from Telegram.

In any case, remember that as long as a webhook is configured, You will not be able to use getUpdatesIf you want to return to polling mode, you must first disable the webhook by deleting it or setting it to blank, and then you can run your bot locally with run_polling() without conflict.

Best practices for security, UX, and maintenance

When your bot starts being used by more people, it's important to go beyond the experiment and consider some things. good practices to make it safe, pleasant to use and easy to maintain long term.

In terms of security, the critical point is protect the bot's tokenAlways store it in environment variables or secret managers (such as AWS Secrets Manager) and avoid hardcoding it in the source code, especially if that code will be in public repositories. If you suspect it may have been leaked, regenerate the token in BotFather immediately.

If you use webhooks, take advantage of the secret_token and always validate the header that Telegram sends. Similarly, limit the exposed ports (such as 443, 80, 88, 8443, which are the ones Telegram supports for webhooks) and configure your cloud provider's firewall rules or security groups to only accept necessary traffic.

From a user experience perspective, it's essential that your bot Use clear commands, explanatory messages, and user-friendly error handling.If something goes wrong, don't leave the user in complete silence; send a message saying you're having trouble and, if possible, suggest what they can try. Buttons, custom keyboards, and well-designed menus make interaction much faster.

Finally, it is recommended monitor performance and log errorsTake advantage of the systems of logs from your provider (CloudWatch, for example, in AWS) to detect exceptions, slow response times, or traffic spikes. You can also gather feedback from users themselves, with commands like /feedback or targeted surveys, to improve the most frequently used features.

With all of the above, setting up a Telegram bot with Python in less than 10 minutes is no longer magic, but a clear process: You register the bot with BotFather, install python-telegram-bot, write a small script with /start, choose between polling or webhook, and decide where to host it.From there, you can add layers: menus, statuses, integrations with external APIs, or smart reminders like your medication reminder, until you end up with a truly useful assistant adapted to your daily life.