Инструкция по созданию бота телеграм

This guide will walk you through everything you need to know to build your first Telegram Bot.
If you already know your way around some of the basic steps, you can jump directly to the part you’re missing. Equivalent examples are available in C#, Python, Go and TypeScript .

• Introduction
• Basic Tutorial

• Advanced Tutorial

• Further Reading

Introduction

At its core, you can think of the Telegram Bot API as software that provides JSON-encoded responses to your queries.

A bot, on the other hand, is essentially a routine, software or script that queries the API by means of an HTTPS request and waits for a response. There are several types of requests you can make, as well as many different objects that you can use and receive as responses.

Since your browser is capable of sending HTTPS requests, you can use it to quickly try out the API. After obtaining your token, try pasting this string into your browser:

https://api.telegram.org/bot<YOUR_BOT_TOKEN>/getMe

In theory, you could interact with the API with basic requests like this, either via your browser or other tailor-made tools like cURL. While this can work for simple requests like the example above, it’s not practical for larger applications and doesn’t scale well.
For that reason, this guide will show you how to use libraries and frameworks, along with some basic programming skills, to build a more robust and scalable project.

If you know how to code, you’ll fly right through each step in no time – and if you’re just starting out, this guide will show you everything you need to learn.

We will use Java throughout this guide as it’s one of the most popular programming languages, however, you can follow along with any language as all the steps are fundamentally the same.
Since Java is fully cross-platform, each code example will work with any operating system.
If you pick another language, equivalent examples are available in C#, Python, Go and TypeScript .

Getting Ready

First, we will briefly cover how to create your first project, obtain your API token and download all necessary dependencies and libraries.

For the purposes of this guide, a copy of the bot you will be creating is also live at @TutorialBot – feel free to check it out along the way to see how your own implementation should look after each step.

Obtain Your Bot Token

In this context, a token is a string that authenticates your bot (not your account) on the bot API. Each bot has a unique token which can also be revoked at any time via @BotFather.

Obtaining a token is as simple as contacting @BotFather, issuing the /newbot command and following the steps until you’re given a new token. You can find a step-by-step guide here.

Your token will look something like this:

4839574812:AAFD39kkdpWt3ywyRZergyOLMaJhac60qc

Make sure to save your token in a secure place, treat it like a password and don’t share it with anyone.

Download an IDE

To program in Java you’ll need an IDE – a special text editor that will let you write, compile and run your code.
In this tutorial, we’ll use IntelliJ – there are several free, open source alternatives like Eclipse or NetBeans which work in the exact same way.

You will also need a JDK, a software kit that allows your Java code to run.
Most IDEs don’t include a JDK, so you should download a version compatible with your operating system separately. You can find a free, open source version here.

If you use another language, the steps are identical. You will just have to download a different IDE and software development kit.

Pick a Framework or Library

You can think of a framework as software that handles all the low-level logic for you, including the API calls, and lets you focus on your bot-specific logic.

In this tutorial, we’ll use TelegramBots, but you can follow along with any equivalent implementation, since all the underlying methods are either similar or exactly the same.

You can find many frameworks, along with code examples, in our dedicated list.

Create Your Project

In IntelliJ, go to File > New > Project.

Fill in the fields accordingly:

• Name — The name of your project. For example, BotTutorial.
• Location — Where to store your project. You can use the default value.
• Language — Java
• Build System — The framework that will handle your dependencies. Pick Maven.
• JDK — Pick whichever version you downloaded. We’ll be using version 17.
• Add Sample Code — Leave this selected, it will generate some needed files for you.
• Advanced Settings > GroupId — We suggest tutorial.
• Advanced Settings > ArtifactId — You can use the default value.

After hitting Create, if you did everything correctly, your Project view in the top left should show a project structure along these lines:

BotTutorial
├─ .idea
├─ src
│  └─ main
│     └─ java
│        └─ tutorial
│           └─ Main
└─ pom.xml

Other IDEs will follow a similar pattern. Your dependency management system will have a different name (or no name at all if it’s built-in) depending on the language you chose.

If this looks scary, don’t worry. We will only be using the Main file and the pom.xml file.
In fact, to check that everything is working so far, double click on Main and click on the small green arrow on the left of public class Main, then select the first option.
If you followed the steps correctly, Hello world! should appear in the console below.

Add Framework Dependency

We will now instruct the IDE to download and configure everything needed to work with the API.
This is very easy and happens automatically behind the scenes.

First, locate your pom.xml file on the left side of the screen.
Open it by double-clicking and simply add:

<dependencies>
    <dependency>
        <groupId>org.telegram</groupId>
        <artifactId>telegrambots</artifactId>
        <version>6.0.1</version>
    </dependency>
</dependencies>

right after the </properties> tag.

When you’re done, your pom.xml should look something like this.

Start Coding

We are ready to start coding. If you’re a beginner, consider that being familiar with your language of choice will greatly help. With this tutorial, you’ll be able to teach your bot basic behaviors, though more advanced features will require some coding experience.

Creating a Bot Class

If you’re familiar with object-oriented programming, you’ll know what a class is.
If you’ve never heard of it before, consider a class as a file where you write some logic.

To create the class that will contain the bot logic, right click on tutorial from the project tree on the left and select New > Java Class. Name it Bot and hit enter.

Now we have to connect this class to the bot framework. In other words, we must make sure it extends TelegramLongPollingBot. To do that, just add extends TelegramLongPollingBot right after Bot.
A red line will appear – it simply means we’re missing some important methods.

To fix this, hover over the red line, click on implement methods, then hit OK.
Depending on the IDE, this option may be called implement missing methods or something similar.

You should end up with this – if something went wrong, feel free to copy it from here and paste it in your class:

package tutorial;
import org.telegram.telegrambots.bots.TelegramLongPollingBot;
import org.telegram.telegrambots.meta.api.objects.Update;

public class Bot extends TelegramLongPollingBot {

  @Override
  public String getBotUsername() {
      return null;
  }

  @Override
  public String getBotToken() {
      return null;
  }

  @Override
  public void onUpdateReceived(Update update) {}

}

If you get a red line under TelegramLongPollingBot, it means you didn’t set up your pom.xml correctly. If this is the case, restart from here.

Available Methods

Let’s look into these 3 methods one by one.

• getBotUsername — This method must be edited to always return your bot’s username. You should replace the null return value with it.
• getBotToken — This method will be used by the framework to retrieve your bot token. You should replace the null return value with the token.
• onUpdateReceived — This is the most important method. It will be called automatically whenever a new Update is available. Let’s add a System.out.println(update); call in there to quickly show what we are getting.

After you’ve replaced all the strings, you should end up with this:

@Override
public String getBotUsername() {
    return "TutorialBot";
}

@Override
public String getBotToken() {
    return "4839574812:AAFD39kkdpWt3ywyRZergyOLMaJhac60qc";
}

@Override
public void onUpdateReceived(Update update) {
    System.out.println(update);
}

At this point, the bot is configured and ready to go – time to register it on the API and start processing updates.

In the future, you should consider storing your token in a dedicated settings file or in environment variables. Keeping it in the code is fine for the scope of this tutorial, however, it’s not very versatile and is generally considered bad practice.

Registering the Bot

To register the bot on the API, simply add a couple of lines in the main method that will launch the application. If you named your class Bot, this is what your main method should look like:

public static void main(String[] args) throws TelegramApiException {
  TelegramBotsApi botsApi = new TelegramBotsApi(DefaultBotSession.class);
  botsApi.registerBot(new Bot());
}

You can place this method in any class. Since we have an auto-generated main method in the Main class, we’ll be using that one for this tutorial.

First Run

It’s time to run your bot for the first time.
Hit the green arrow to the left of public static void main and select the first option.

And then there was nothing. Yes, a bit anticlimactic.
This is because your bot has nothing to print – there are no new updates because nobody messaged it yet.

If you try messaging the bot on Telegram, you’ll then see new updates pop up in the console. At this point, you have your very own Telegram Bot – quite the achievement. Now, on to making it a bit more intelligent.

If nothing pops up, make sure you messaged the right bot and that the token you pasted in the code is correct.

Receiving Messages

Every time someone sends a private message to your bot, your onUpdateReceived method will be called automatically and you’ll be able to handle the update parameter, which contains the message, along with a great deal of other info which you can see detailed here.

Let’s focus on two values for now:

• The user — Who sent the message. Access it via update.getMessage().getFrom().
• The message — What was sent. Access it via update.getMessage().

Knowing this, we can make it a bit more clear in the console output.

@Override
public void onUpdateReceived(Update update) {
    var msg = update.getMessage();
    var user = msg.getFrom();

    System.out.println(user.getFirstName() + " wrote " + msg.getText());
}

This is just a basic example – you can now play around with all the methods to see everything you can pull out of these objects. You can try getUsername, getLanguageCode, and dozens more.

Knowing how to receive, process and print incoming messages, now it’s time to learn how to answer them.

Remember to stop and re-launch your bot after each change to the code.

Sending Messages

To send a private text message, you generally need three things:

• The user must have contacted your bot first. (Unless the user sent a join request to a group where your bot is an admin, but that’s a more advanced scenario).
• You must have previously saved the User ID (user.getId())
• A String object containing the message text, 1-4096 characters.

With that out of the way, let’s create a new method to send the first message:

public void sendText(Long who, String what){
   SendMessage sm = SendMessage.builder()
                    .chatId(who.toString()) //Who are we sending a message to
                    .text(what).build();    //Message content
   try {
        execute(sm);                        //Actually sending the message
   } catch (TelegramApiException e) {
        throw new RuntimeException(e);      //Any error will be printed here
   }
}

And proceed to run this in the main method, right after registering the bot.
For this example, we’ll assume your User ID is 1234.

public static void main(String[] args) throws TelegramApiException {
   TelegramBotsApi botsApi = new TelegramBotsApi(DefaultBotSession.class);
   Bot bot = new Bot();                  //We moved this line out of the register method, to access it later
   botsApi.registerBot(bot);            
   bot.sendText(1234L, "Hello World!");  //The L just turns the Integer into a Long
}

If you did everything correctly, your bot should text you Hello World! every time you launch your code. Sending messages to groups or channels – assuming you have the relevant permissions – is as simple as replacing 1234 with the ID of the respective chat.

Try experimenting with other types of messages, like SendPhoto, SendSticker, SendDice…
A full list is available starting here.

Echo Bot

Let’s practice everything we tried so far by coding an Echo Bot.
Its functionality will be rather simple: every text message it receives will be sent right back to the user.

Copying Text

The most intuitive way of coding this is saving the User ID and calling sendText right after each update.

In other words:

@Override
public void onUpdateReceived(Update update) {
    var msg = update.getMessage();
    var user = msg.getFrom();
    var id = user.getId();

    sendText(id, msg.getText());
}

This works for text but can be extended to stickers, media and files.

Copying Everything

There are more specific functions that can be used to copy messages and send them back.
Let’s build a method to do just that:

public void copyMessage(Long who, Integer msgId){
   CopyMessage cm = CopyMessage.builder()
              .fromChatId(who.toString())  //We copy from the user
           .chatId(who.toString())      //And send it back to him
           .messageId(msgId)            //Specifying what message
           .build();
    try {
        execute(cm);
    } catch (TelegramApiException e) {
        throw new RuntimeException(e);
    }
}

After replacing the method call inonUpdateReceived, running the code will result in a fully functional Echo Bot.

This tutorial assumes that updates always contain messages for the sake of simplicity. This may not always be true – be sure to implement all the proper checks in your code to handle every type of update with the appropriate methods.

Executing Commands

To learn what a command is and how it works, we recommend reading this dedicated summary.
In this guide, we’ll focus on the technical side of things.

Creating Your Command

Begin by opening @BotFather.
Type /mybots > Your_Bot_Name > Edit Bot > Edit Commands.

Now send a new command, followed by a brief description.
For the purpose of this tutorial, we’ll implement two simple commands:

scream - Speak, I'll scream right back 
whisper - Shhhhhhh

Command Logic

We want the Echo Bot to reply in uppercase when it’s in scream mode and normally otherwise.

First, let’s create a variable to store the current mode.

public class Bot extends TelegramLongPollingBot {

   private boolean screaming = false;

   [...]
}

Then, let’s change some logic to account for this mode.

public void onUpdateReceived(Update update) {
    [...]                                   //Same variables as the previous versions
   if(screaming)                            //If we are screaming
       scream(id, update.getMessage());     //Call a custom method
   else
       copyMessage(id, msg.getMessageId()); //Else proceed normally
}

private void scream(Long id, Message msg) {
   if(msg.hasText())
       sendText(id, msg.getText().toUpperCase());
   else
       copyMessage(id, msg.getMessageId());  //We can't really scream a sticker
}

Finally, let’s add a couple more lines to the onUpdateReceived method to process each command before replying.

if(msg.isCommand()){ 
   if(msg.getText().equals("/scream"))         //If the command was /scream, we switch gears
      screaming = true;
   else if (msg.getText().equals("/whisper"))  //Otherwise, we return to normal
      screaming = false;

   return;                                     //We don't want to echo commands, so we exit
}

As you can see, it checks if the message is a command. If it is, the bot enters scream mode.
In the update method, we check which mode we are in and either copy the message or convert it to upper case before sending it back.

And that’s it. Now the bot can execute commands and change its behavior accordingly.

Naturally, this simplified logic will change the bot’s behavior for everyone – not just the person who sent the command. This can be fun for this tutorial but won’t work in a production environment – consider using a Map, dictionary or equivalent data structure to assign settings for individual users.

Remember to always implement a few basic global commands.
You can practice by implementing a simple feedback to the /start command, which we intentionally left out.

Buttons and Keyboards

To streamline and simplify user interaction with your bot, you can replace many text-based exchanges with handy buttons. These buttons can perform a wide variety of actions and can be customized for each user.

Button Types

There are two main types of buttons:

• Reply Buttons — used to provide a list of predefined text reply options.
• Inline Buttons — used to offer quick navigation, shortcuts, URLs, games and so much more.

Using these buttons is as easy as attaching a ReplyKeyboardMarkup or an InlineKeyboardMarkup to your SendMessage object.

This guide will focus on inline buttons since they only require a few extra lines of code.

Creating Buttons

First of all, let’s create some buttons.

 var next = InlineKeyboardButton.builder()
            .text("Next").callbackData("next")           
            .build();

 var back = InlineKeyboardButton.builder()
            .text("Back").callbackData("back")
            .build();

 var url = InlineKeyboardButton.builder()
            .text("Tutorial")
            .url("https://core.telegram.org/bots/api")
            .build();

Let’s go back through the fields we specified:

• Text — This is what the user will see, the text that appears on the button
• Callback Data — This will be sent back to the code instance as part of a new Update, so we can quickly identify what button was clicked.
• Url — A button that specifies a URL doesn’t specify callbackdata since its behavior is predefined – it will open the given link when tapped.

Creating Keyboards

The buttons we created can be assembled into two keyboards, which will then be used to navigate back and forth between two sample menus.

First, add two fields to store the necessary keyboards.

private boolean screaming = false;

private InlineKeyboardMarkup keyboardM1;
private InlineKeyboardMarkup keyboardM2;

Then, build and assign them.

keyboardM1 = InlineKeyboardMarkup.builder()
          .keyboardRow(List.of(next)).build();  

//Buttons are wrapped in lists since each keyboard is a set of button rows
keyboardM2 = InlineKeyboardMarkup.builder()
          .keyboardRow(List.of(back))
          .keyboardRow(List.of(url))
          .build();

You can place this code wherever you prefer, the important thing is making sure that keyboard variables are accessible from the method call that will send the new menu. If you’re confused by this concept and don’t know where to put them, just paste them above the command processing flow.

Sending Keyboards

Sending a keyboard only requires specifying a reply markup for the message.

public void sendMenu(Long who, String txt, InlineKeyboardMarkup kb){
    SendMessage sm = SendMessage.builder().chatId(who.toString())
            .parseMode("HTML").text(txt)
            .replyMarkup(kb).build();

    try {
        execute(sm);
    } catch (TelegramApiException e) {
        throw new RuntimeException(e);
    }
}

You may have noticed that we also added a new parameter, HTML.
This is called a formatting option and will allow us to use HTML tags and add formatting to the text later on.

Menu Trigger

We could send a new menu for each new user, but for simplicity let’s add a new command that will spawn a menu. We can achieve this by adding a new else clause to the previous command flow.

 var txt = msg.getText();
 if(msg.isCommand()) {
        if (txt.equals("/scream"))
            screaming = true;
        else if (txt.equals("/whisper"))
            screaming = false;
        else if (txt.equals("/menu"))
            sendMenu(id, "<b>Menu 1</b>", keyboardM1);
        return;
 }

Try sending /menu to your bot now. If you did everything correctly, you should see a brand new menu pop up.

In a production environment, commands should be handled with an appropriate design pattern that isolates them into different executor classes – modular and separated from the main logic.

Navigation

When building complex bots, navigation is essential. Your users must be able to move seamlessly from one menu to the next.

In this example, we want the Next button to lead the user to the second menu.
The Back button will send us back.
To do that, we will start processing incoming CallbackQueries, which are the results we get after the user taps on a button.

A CallbackQuery is essentially composed of three main parameters:

• queryId — Needed to close the query. You must always close new queries after processing them – if you don’t, a loading symbol will keep showing on the user’s side on top of each button.
• data — This identifies which button was pressed.
• from — The user who pressed the button.

Processing in this context just means executing the action uniquely identified by the button, then closing the query.

A very basic button handler could look something like:

private void buttonTap(Long id, String queryId, String data, int msgId) {

    EditMessageText newTxt = EditMessageText.builder()
            .chatId(id.toString())
            .messageId(msgId).text("").build();

    EditMessageReplyMarkup newKb = EditMessageReplyMarkup.builder()
            .chatId(id.toString()).messageId(msgId).build();                           

    if(data.equals("next")) {
        newTxt.setText("MENU 2");
        newKb.setReplyMarkup(keyboardM2);
    } else if(data.equals("back")) {
        newTxt.setText("MENU 1");
        newKb.setReplyMarkup(keyboardM1);
    }

    AnswerCallbackQuery close = AnswerCallbackQuery.builder()
            .callbackQueryId(queryId).build();

    execute(close);
    execute(newTxt);
    execute(newKb);
}

With this handler, whenever a button is tapped, your bot will automatically navigate between inline menus.
Expanding on this concept allows for endless combinations of navigable submenus, settings and dynamic pages.

Database

Telegram does not host an update database for you – once you process and consume an update, it will no longer be available. This means that features like user lists, message lists, current user inline menu, settings, etc. have to be implemented and maintained by bot developers.

If your bot needs one of these features and you want to get started on data persistence, we recommend that you look into serialization practices and libraries for your language of choice, as well as available databases.

Implementing a database is out of scope for this guide, however, several guides are available online for simple embedded open source software solutions like SQLite, HyperSQL, Derby and many more.

Your language of choice will also influence which databases are available and supported – the list above assumes you followed this Java tutorial.

Hosting

So far, your bot has been running on your local machine – your PC. While this may be good for developing, testing and debugging, it is not ideal for a production environment.
You’ll want your bot to be available and responsive at all times, but your computer might not always be online.

This can be done in four steps:

• Package your code
  Making your bot easy to move and runnable outside of an IDE is essential to host it elsewhere.
  If you followed this tutorial, this standard guide will work for you. If you didn’t, look into export or packaging guides for your IDE and language of choice – procedures may vary but the end result is the same.

• Purchase a VPS or equivalent service
  A server is essentially a machine that is always online and running, without you having to worry about anything. To host your bot, you can opt for a VPS which serves this purpose and can be rented from several different providers.
  Another option would be to purchase a network-capable microcontroller, which come in all different specs and sizes depending on your needs.

You should ensure that all user data remains heavily encrypted at all times in your database to guarantee the privacy of your users. The same concept applies to your local instance, however, this becomes especially important once you transfer your database to a remote server.

• Upload your executable/package

Once you have a working ssh connection between your machine and your new server, you should upload your executable and all associated files.
We will assume the runnable jar TutorialBot.jar and its database dbase.db are currently in the /TBot folder.

$ scp -r /TBot/ username@server_ip:/bots/TBotRemote/

• Run your application

Depending on which language you chose, you might have to configure your server environment differently. If you chose Java, you just need to install a compatible JDK.

$ apt install openjdk-17-jre
$ java -version

If you did everything correctly, you should see a Java version as the output, along with a few other values. This means you’re ready to run your application.

Now, to run the executable:

$ cd /bots/TBotRemote/
$ java -jar TutorialBot.jar

Your bot is now online and users can interact with it at any time.

To streamline and modularize this process, you could employ a specialized docker container or equivalent service.
If you followed along in one of the equivalent examples (C#, Python, Go and TypeScript) you can find a detailed set of instructions to export and run your code here.

Further Reading

If you got this far, you might be interested in these additional guides and docs:

• General Bot Platform Overview
• Detailed List of Bot Features
• Full API Reference

If you encounter any issues while following this guide, you can contact us on Telegram at @BotSupport.

Иллюстрация: Оля Ежак для Skillbox Media

Программист, консультант, специалист по документированию. Легко и доступно рассказывает о сложных вещах в программировании и дизайне.

Обычно для разработки телеграм-ботов программисты используют специальные библиотеки и фреймворки, например Aiogram или Telegraf. Они ускоряют разработку и делают код компактным, однако их авторы не всегда успевают вовремя добавлять поддержку новых функций Telegram.

Альтернативное решение — Bot API. Это нативный интерфейс от создателей мессенджера, который лежит в основе всех ботов и библиотек. В этой статье рассказываем, для чего нужен Telegram Bot API и как им пользоваться.

Картинка с сайта: skillbox.ru

Эксперт

Principal Software Engineer, эксперт Skillbox по бэкенду и Java в коммерческой разработке.

Содержание

• Что такое Telegram Bot API
• Какие API есть в Telegram
• Как создать бота в Telegram
• Ограничения ботов
• Как взаимодействовать с ботом через Bot API
• Как прочитать сообщение
• Как отправить сообщение
• Как отправить стикер
• Какие ещё методы есть в Telegram Bot API
• Библиотеки для разработки телеграм-ботов

---

Чтобы понять, что такое Telegram Bot API, для начала разберёмся с самим понятием API.

API (application programming interface, программный интерфейс приложения) — это набор методов, с помощью которых различные сервисы и программы обмениваются данными между собой. Разработчики используют API для того, чтобы получить от сервиса нужную информацию или заставить его выполнить определённое действие.

Процесс работы с API строится на модели «запрос — ответ». Программист или приложение отправляет запрос на сервер и в ответ получает нужные данные, подтверждение выполнения операции или код ошибки.

Telegram Bot API — это набор методов для управления телеграм-ботами. С его помощью можно обрабатывать сообщения пользователей, автоматизировать модерацию групповых чатов и создавать полезные утилиты на базе мессенджера.

Если вы никогда не работали с API и хотите узнать об этом больше, рекомендуем прочитать наше руководство.

Telegram предоставляет разработчикам несколько API для создания приложений, ботов и сторонних сервисов. Все они связаны с мессенджером, но у них разные цели и возможности:

• Telegram API — низкоуровневый интерфейс, на базе которого реализованы основные функции Telegram, включая криптографический протокол MTProto. Официальные клиенты Telegram используют методы из этого набора.
• Bot API — HTTP-интерфейс, созданный для разработки ботов, внутренних мини-приложений и веб-игр. Благодаря ему программистам не надо разбираться в устройстве Telegram API для отправки сообщений и получения данных из чатов с пользователями в реальном времени. Достаточно отправить HTTP-запрос, получить ответ в формате JSON и обработать его.
• TDLib — библиотека, предназначенная для разработки альтернативных клиентов Telegram. Если вам кажется, что в приложении мессенджера нет какой-то важной функции, то с помощью TDLib можно создать собственное приложение и опубликовать его в интернете.
• Gateway API — набор методов для отправки кодов авторизации через Telegram. Обычно компании отправляют коды с помощью SMS, но благодаря Gateway API можно сэкономить на оплате мобильной связи.
• Bot Payments API — платформа для обработки платежей в телеграм-ботах. С её помощью разработчики могут получать деньги от пользователей за товары и услуги.

Перед тем как писать код, надо создать бота — зарегистрировать специальный аккаунт и получить уникальный токен для API. Разберём подробно этот процесс.

Для разработчиков в Telegram есть BotFather — «крёстный отец» всех ботов. С его помощью можно зарегистрировать и настроить нового бота. Вот как это сделать:

• Шаг 1. Запустите Telegram и перейдите в чат BotFather. Будьте внимательны, у официального бота должна быть галочка верификации.

Картинка с сайта: skillbox.ru

• Шаг 2. Нажмите кнопку Start, и BotFather пришлёт в ответ список доступных команд.

Картинка с сайта: skillbox.ru

• Шаг 3. Выберите команду /newbot для создания нового бота.
• Шаг 4. BotFather попросит придумать боту имя, которое пользователи будут видеть в списке чатов. Можно использовать символы любого алфавита, цифры, знаки препинания и эмодзи. Например: Суперполезный бот 3000 ?.
• Шаг 5. После этого бот-отец попросит задать username — уникальное имя пользователя, с помощью которого вашего бота можно будет найти в Telegram. В этом случае можно использовать только латиницу, цифры и некоторые разделительные знаки, а на конце обязательно должно быть слово bot. Например: Super3kBot или Super3k_bot.

BotFather проверит доступность юзернейма, и, если он свободен, поздравит с созданием нового бота и пришлёт токен. Это специальный набор букв и цифр, который нужен для связи вашего бота с сервером Telegram. Выглядит он примерно так:

7582552655:AAHmzfaKaoMnajrk47dLS76S2epa127gJ-0

Картинка с сайта: skillbox.ru

Сохраните токен в надёжном месте и никому не показывайте. Если злоумышленники завладеют им, то смогут контролировать вашего бота, собирать данные пользователей и перенаправлять платежи. В случае утечки сгенерируйте новый токен с помощью команды /revoke в BotFather.

С помощью BotFather можно не только создавать новых ботов, но и управлять существующими. Вот какие команды ещё есть:

• /mybots — показать список всех ботов пользователя;
• /setname — изменить имя бота;
• /setdescription — установить описание бота, которое отображается в профиле бота;
• /setabouttext — заполнить поле «О боте» в профиле;
• /setuserpic — установить аватарку;
• /setcommands — настроить список команд;
• /setinline — включить inline-режим, чтобы ботом можно было пользоваться в любом чате Telegram;
• /setjoingroups — разрешить боту работать в группах;
• /deletebot — удалить бота.

Боты в Telegram могут отправлять сообщения, модерировать групповые чаты и получать данные из сторонних сервисов. Несмотря на это, разработчики мессенджера устанавливают ограничения, чтобы не перегружались серверы и спамеры не докучали пользователям.

Работая над своим проектом, помните, что боты в Telegram не могут:

• писать первыми — для начала общения пользователь должен нажать кнопку Start;
• управлять группами, в которые их не добавили администраторы;
• отправлять более 30 сообщений в секунду всего и более 20 сообщений в минуту в один чат;
• отправлять файлы размером более 50 МБ.

Если превысить лимиты, то модераторы Telegram на время отключат бота. В случае повторных нарушений бота могут заблокировать.

Для взаимодействия с ботом при помощи Telegram Bot API мы будем отправлять HTTP-запросы на сервер мессенджера. В ответ нам будут приходить данные в формате JSON. Отправлять запросы можно несколькими способами.

Самый простой способ отправить запрос — воспользоваться браузером. Вот как это можно сделать:

• Шаг 1. Откройте любой браузер и введите адрес в формате https://api.telegram.org/bot{ТОКЕН}/{НАЗВАНИЕ-HTTP-МЕТОДА}.
• Шаг 2. Перейдите по адресу, чтобы получить ответ от сервера.

В качестве примера проверим, работает ли наш бот, и запросим основную информацию о нём. Для этого отправим запрос getMe:

https://api.telegram.org/bot7432444009:AAG62HGsVhddP5kq5Cbdf1ugTcYpTriV1Mg/getMe

Если вы всё сделали правильно, то в окне браузера появится следующий код:

{
    "ok":true,
    "result": {
        "id":7432444009,
        "is_bot":true,            
        "first_name":"Суперполезный бот 3000 ?",
        "username":"Super3kBot",
        "can_join_groups":true,
        "can_read_all_group_messages":false,
        "supports_inline_queries":false,
        "can_connect_to_business":false,
        "has_main_web_app":false
    }
 }

Из него мы можем узнать уникальный идентификатор бота, юзернейм, название и список разрешений — например, можно ли добавить бота в групповой чат и может ли он читать в нём все сообщения.

Запрос getMe можно отправить с помощью кода на Python и библиотеки Requests. Эта библиотека содержит функции, упрощающие процесс взаимодействия с различными API.

import requests

# Создаём переменные, в которых будут храниться токен бота и 
 HTTP-запрос 
bot_token = "7432444009:AAG62HGsVhddP5kq5Cbdf1ugTcYpTriV1Mg"
url = f"https://api.telegram.org/bot{bot_token}/getMe"

response = requests.get(url)

# Пишем условие для обработки ответа сервера
if response.status_code == 200:
    json_data = response.json()
    print("Ответ API:", json_data)
else:
    print(f"Ошибка: {response.status_code}")

После запуска кода в терминале IDE появится ответ сервера в виде JSON-файла. Ответ будет содержать всё то же самое, что и при отправке запроса через браузер: имя и идентификатор бота и список разрешений.

Пользователи могут активировать нашего бота и общаться с ним. Мы же можем получать эти сообщения и обрабатывать на своём сервере. Давайте напишем боту и попробуем прочитать чат с помощью Telegram Bot API.

Картинка с сайта: skillbox.ru

Список сообщений можно получить с помощью HTTP-метода getUpdates. Для этого просто перейдите в браузере по следующему адресу:

https://api.telegram.org/bot7432444009:AAG62HGsVhddP5kq5Cbdf1ugTcYpTriV1Mg/getUpdates

В браузере появится следующий JSON-код:

{
    "ok":true,
    "result": 
        {
            "update_id":123456789,
            "message": {
                "message_id":1,
                "from": {
                    "id":123456789,
                    "is_bot":false,
                    "first_name":"user",
                    "username":"user",
                    "language_code":"ru",
                    "is_premium":true
                },
                "chat": {
                    "id":123456789,
                    "first_name":"user",
                    "username":"user",
                    "type":"private"
                },
                "date":123456789,
                "text":"Hello!"
                }
            }
}

В нём:

• update_id — уникальный номер обращения к боту;
• message — большой блок со всеми метаданными сообщения;
• message_id — ID сообщения в чате;
• from — блок со всеми данными отправителя, включая ID пользователя, имя, никнейм и сведения о наличии подписки Telegram Premium;
• chat — блок с информацией о чате, включая ID, никнейм и тип (публичный или приватный);
• date — дата отправления;
• text — текст сообщения.

Также запрос getUpdates можно отправить с помощью Python:

import requests

# Токен бота и HTTP-запрос
bot_token = "7432444009:AAG62HGsVhddP5kq5Cbdf1ugTcYpTriV1Mg"
url = f"https://api.telegram.org/bot{bot_token}/getUpdates"

response = requests.get(url)

# Обработка ответа сервера
if response.status_code == 200:
    json_data = response.json()
    print("Ответ API:", json_data)
else:
    print(f"Ошибка: {response.status_code}")

Теперь попробуем ответить на наше же сообщение от имени бота. Для этого воспользуемся методом sendMessage. Он немного сложнее предыдущих и требует передать на вход дополнительные параметры: ID чата и текст сообщения. В общем виде метод выглядит так:

https://api.telegram.org/bot{ТОКЕН}/sendMessage? chat_id={ID-ЧАТА}& text={СООБЩЕНИЕ}

В нём:

• {ТОКЕН} — токен, который нам выдал BotFather;
• {ID-ЧАТА} — уникальный номер чата, в который бот отправит сообщение. Этот номер можно посмотреть в поле «chat»: {«id»: 123456789}, выполнив запрос getUpdates;
• {СООБЩЕНИЕ} — текст сообщения.

Отправим сообщение «Привет!»:

https://api.telegram.org/bot7432444009:AAG62HGsVhddP5kq5Cbdf1ugTcYpTriV1Mg/sendMessage?chat_id=123456789&text=Привет!

Если вы всё сделали правильно, то в чате появится сообщение от имени бота.

Картинка с сайта: skillbox.ru

С помощью Python запрос sendMessage можно отправить так:

import requests

# Токен бота и HTTP-запрос
bot_token = "7432444009:AAG62HGsVhddP5kq5Cbdf1ugTcYpTriV1Mg"
chat_id = "123456789"
message_text = "Привет!"

url = f"https://api.telegram.org/bot{bot_token}/sendMessage"

# Параметры запроса
params = {
    "chat_id": chat_id,
    "text": message_text
}

response = requests.get(url, params=params)

# Обработка ответа сервера
if response.status_code == 200:
    json_data = response.json()
    print("Ответ API:", json_data)
else:
    print(f"Ошибка: {response.status_code}")

Для отправки стикеров в Bot API есть метод sendSticker. Чаще всего этот запрос получается довольно длинным из-за объёмного ID стикера, поэтому вместо браузера удобнее использовать Python. В теле запроса надо обязательно передать токен бота, ID чата и стикера.

Как получить первые два параметра, мы уже знаем из примеров выше. Чтобы получить ID стикера, сделайте следующее:

• Шаг 1. Отправьте в чат с ботом нужный стикер.
• Шаг 2. Выполните в браузере запрос getUpdates.
• Шаг 3. В JSON-ответе найдите данные последнего сообщения.
• Шаг 4. В поле file_id будет ID стикера. Например: «file_id»:»CAACAgIAAxkBAAENhyhn18v1vykSL7iweWj0syat7KNAPwACmEcAAkYhyUrp2ZMtEnJVtTYE».

Код запроса на Python выглядит так:

import requests

# Токен бота и HTTP-запрос
bot_token = "7432444009:AAG62HGsVhddP5kq5Cbdf1ugTcYpTriV1Mg"
chat_id = "123456789"
sticker_id = "CAACAgIAAxkBAAENhyhn18v1vykSL7iweWj0syat7KNAPwACmEcAAkYhyUrp2ZMtEnJVtTYE"

url = f"https://api.telegram.org/bot{bot_token}/sendSticker"

# Параметры запроса
params = {
    "chat_id": chat_id,
    "sticker": sticker_id
}

response = requests.get(url, params=params)

# Обработка ответа сервера
if response.status_code == 200:
    json_data = response.json()
    print("Ответ API:", json_data)
else:
    print(f"Ошибка: {response.status_code}")

Если запустить код в IDE, то бот пришлёт указанный стикер в чат.

Картинка с сайта: skillbox.ru

Разработчики Telegram включили в Bot API несколько десятков методов. С их помощью можно отправлять обычный текст, стикеры, файлы, фотографии, голосовые сообщения, ставить реакции и управлять групповыми чатами. Например, можно запрограммировать бота для автоматической блокировки спамеров.

Все методы подробно описаны в официальной документации Bot API. В ней есть названия методов, принцип работы и список возможных параметров. Отдельно отмечены обязательные параметры, без которых сервер не сможет обработать запрос.

Вот некоторые из доступных методов в Bot API:

• forwardMessage — пересылает сообщение пользователя в другой чат;
• copyMessage — копирует сообщение;
• sendPhoto — отправляет изображение;
• sendVoice — отправляет голосовое сообщение;
• sendPoll — запускает в чате опрос;
• getUserProfilePhotos — получает аватарку пользователя;
• banChatMember — блокирует пользователя в групповом чате;
• createChatInviteLink — создаёт ссылку-приглашение в групповой чат;
• setChatPhoto — устанавливает аватарку группового чата;
• setChatTitle — устанавливает название группового чата;
• getChatAdministrators — получает список администраторов;
• setMyCommands — метод для замены списка команд бота;
• setMyName — метод для смены имени бота.

Сочетая методы Bot API можно создавать ботов со сложной логикой. Главное преимущество «чистого» API перед библиотеками в том, что запросы можно отправлять с помощью любого языка программирования или вообще без кода. Это даёт больше преимуществ разработчикам, которые создают ботов на непопулярных языках программирования.

Главный минус работы с Bot API напрямую в том, что каждый раз приходится использовать много кода даже для простых запросов. Кроме того, надо разработать алгоритм, который может быстро получать сообщения из чата с пользователем и анализировать их. Это усложняет процесс создания ботов, поэтому вместо Bot API лучше использовать специальные библиотеки.

Для разработчиков ботов есть специальные библиотеки на базе Bot API, которые упрощают процесс отправки запросов. Они помогают сократить количество кода в проекте и предоставляют готовые алгоритмы мониторинга новых сообщений и обработки команд. С такими библиотеками разработка бота становится похожа на сборку конструктора — просто берём нужные функции, связываем их друг с другом и событиями в чате.

Рассмотрим популярные библиотеки для создания телеграм-ботов на разных языках программирования.

Python — самый популярный язык в сообществе разработчиков ботов. В большинстве гайдов, курсов и уроков именно на нём показывают все примеры кода. Для Python есть следующие библиотеки:

• Aiogram — асинхронная библиотека для создания высоконагруженных ботов. Чаще всего именно её используют в масштабных проектах с десятками тысяч ежедневных пользователей. Разработчики Aiogram часто обновляют библиотеку и быстро внедряют новые функции Bot API.
• TeleBot — одна из первых библиотек для Python. Обновления для неё выходят редко, а боты на базе TeleBot не справляются с большим количеством запросов. Из-за простого синтаксиса решение подойдёт новичкам, которые только изучают возможности Bot API.
• Python-telegram-bot — библиотека с асинхронным и синхронным режимами работы. По возможностям и сложности находится между Aiogram и TeleBot. Обновления также выходят с интервалом в несколько месяцев.

Второй по популярности язык программирования для разработки телеграм-ботов — JavaScript. Для него и платформы Node.js тоже есть много обучающих материалов и библиотек. Ниже список популярных решений:

• Telegraf.js — фреймворк с поддержкой JavaScript и TypeScript. Поддерживает основные функции мессенджера и выполняет код асинхронно.
• GrammY — библиотека для разработки ботов на JavaScript и TypeScript, которых можно запускать в Node.js и Deno. Если вы уже создавали веб-проекты с нуля, то сможете быстро научиться писать код для телеграм-ботов. Во всяком случае, это гарантируют авторы GrammY.
• Node.js Telegram Bot API — простая библиотека для Node.js. Обновления для неё выходят редко.

Одно из преимуществ открытого Bot API в том, что сторонние разработчики могут создавать на его базе собственные библиотеки для любых языков программирования. Поддерживают их не так активно, как решения для Python и JavaScript, но базовые функции всегда работают. Ниже список библиотек для разных языков программирования.

Название	Язык программирования	Ссылка
PHP Telegram Bot	PHP	GitHub
Telegram Bot Java Library	Java	GitHub
Telegram.Bot	.NET	GitHub
Tgbot-cpp	C++	GitHub
Kotlin Telegram Bot	Kotlin	GitHub
Swift Telegram SDK	Swift	GitHub
Telegram-bot-ruby	Ruby	GitHub

• Telegram Bot API — это набор HTTP-методов, с помощью которых можно отправлять запросы к серверу Telegram, получать ответы в формате JSON и управлять ботами.
• При использовании Bot API важно учитывать ограничения на количество запросов и соблюдать рекомендации по безопасности, чтобы избежать блокировок бота.
• Открытый API позволяет сторонним разработчикам использовать любые языки программирования для управления ботами.
• Работать напрямую с серверами Telegram сложно и не всегда рационально: код получается сложным, запутанным и надо самостоятельно реализовывать многие алгоритмы.
• В качестве альтернативы можно использовать готовые библиотеки на базе Bot API. Существуют библиотеки для разных языков программирования, но авторы и сообщество активно поддерживают только решения для Python и JavaScript.

Картинка с сайта: skillbox.ru

Курс: «Создание Telegram-бота и продвижение в мессенджерах»
Узнать больше

Бот в Telegram — это популярное решение для бизнесов и компаний, которые хотят автоматизировать коммуникацию с аудиторией, улучшить взаимодействие с клиентами в мессенджере или создать развлекательную площадку. Рассказываем, как сделать чат-бота в Телеграме, начиная от идеи и заканчивая его размещением на сервере.

• Что такое чат-боты и зачем они нужны?
• Руководство по разработке и запуску чат бота в Телеграм
  • Шаг 1: подготовка к созданию бота
  • Шаг 2: регистрация бота через BotFather
  • Шаг 3: установка Python и библиотек
  • Шаг 4: написание простого бота
  • Шаг 5: тестирование
• Как сделать бота Telegram более функциональным?
  • Кнопки и команды
  • Интеграция с внешними платформами
• Как развернуть Telegram-бота на сервере?

Что такое чат-боты и зачем они нужны?

Чат-бот в Телеграм — это программа, работающая внутри мессенджера Телеграм. Она может отвечать на сообщения, выполнять заранее установленные команды, отправлять уведомления и взаимодействовать с другими сервисами. На вопрос «Как работает чат-бот в Телеграме?» можно ответить просто: он использует Telegram Bot API для связи с пользователями в мессенджере.

Чат-боты многофункциональны, их можно использовать для решения разных задач:

• Бизнес-задачи. Автоматизация обработки заявок, сбор отзывов, автоворонки для продажи товаров и услуг.
• Развлечения. Игры, викторины или общение с ИИ-ботом.
• Образование. Виртуальные ассистенты с предписанными обучающими материалами.

Руководство по разработке и запуску чат бота в Телеграм

Если вам интересно, как написать чат-бота на Python в Телеграмме, следуйте пошаговой инструкции о том, как создать бот в Телеграмме самостоятельно, приведенному ниже.

Шаг 1: подготовка к созданию бота

Прежде чем начать, определитесь, какую бизнес-задачу решает ваш чат-бот и какой ему нужен функционал. Например, у информационного сервиса об актуальных погодных условиях и у бота для тестов на определения уровня депрессии разные задачи и функции. Первый должен высылать уведомления, тогда как второй предполагает несколько сценариев коммуникации.

Еще до начала создания Telegram-бота понадобится:

• Учетная запись Telegram.
• Знания Python, который можно освоить на курсе Python-разработчик.
• Хостинг для размещения бота (Heroku, AWS и т. д.).

Шаг 2: регистрация бота через BotFather

1. Найдите бота @BotFather в Telegram.
2. Отправьте команду /newbot.
3. Укажите имя и @username для бота. Username обязательно должен заканчиваться словом bot.
4. BotFather выдаст вам токен для доступа к Telegram Bot API.

Важно: токен должен храниться только у владельца бота, передавать его другим лицам нельзя. Если токен скомпрометирован, то необходимо пересоздать его. Для каждого бота нужно создавать отдельный токен.

Читайте также:
Что такое хостинг?

Шаг 3: установка Python и библиотек

Поскольку мы разрабатываем телеграм-бот на Python, нужно начать с настройки виртуального окружения и установки библиотеки для удобного создания ботов.

1. Скачайте Python с официального сайта (об установке Python детальнее написано здесь).
2. Установите библиотеку python-telegram-bot:

pip install python-telegram-bot

1. Если ваша ОС — Windows, убедитесь, что при установке вы отметили опцию «Add Python to PATH». Это упростит доступ к Python из командной строки.

В терминале выполните:

python -m venv myenv

Где myenv — это название виртуального окружения.

Активируйте окружение:

• На Windows:
  
myenv\Scripts\activate

• На macOS/Linux:
  
source myenv/bin/activate


После активации в командной строке должно появиться название окружения:

(myenv) C:\>

Шаг 4: написание простого бота

Самый простой из возможных ботов называется эхо-бот. Он просто повторяет сообщения, отправленные пользователем. Если пользователь пишет «Привет», бот отвечает «Привет». Это идеальная отправная точка для новичков в программировании ботов, поскольку он помогает понять, как работает взаимодействие между пользователем и ботом через Telegram Bot API.

На примере эхо-бота мы увидим:

• Как обрабатывать входящие сообщения.
• Как отправлять ответы пользователю.
• Как настроить основную структуру бота.

Вот пример простого эхо-бота, который отвечает на сообщения пользователя:

from telegram import Update
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters, CallbackContext

# Обработчик входящих сообщений

def echo(update: Update, context: CallbackContext):
    update.message.reply_text(update.message.text)

# Основная функция
def main():
    # Инициализация Updater
    updater = Updater("BOT_TOKEN")

    # Диспетчер для обработки входящих обновлений
    dp = updater.dispatcher

    # Добавляем обработчик сообщений
    dp.add_handler(MessageHandler(Filters.text & ~Filters.command, echo))

    # Запуск бота
    updater.start_polling()

    # Ожидаем завершения работы (например, через Ctrl+C)
    updater.idle()

if __name__ == '__main__':
    main()

Разберем ключевые части:

1. Импорт библиотек Updater, CommandHandler, MessageHandler, Filters, CallbackContext. Эти библиотеки предоставляют инструменты для взаимодействия с Telegram и для настройки логики бота.
2. Функция обработки сообщений:
   • update.message.text содержит текст сообщения, отправленного пользователем.
   • reply_text отправляет этот текст обратно пользователю.
3. Основная функция:
   • Updater: управляет обменом данными с Telegram.
   • Dispatcher (dp): распределяет задачи между обработчиками.
   • MessageHandler: отвечает за обработку текстовых сообщений.
   • start_polling: запускает цикл обработки новых сообщений.

Также интересно:
Как я писал telegram бот с админкой на Django

Шаг 5: тестирование

Запустите скрипт и отправьте сообщение вашему боту в Telegram. Он должен ответить, повторяя ваше сообщение. При тестировании нужно проверить каждую функцию вашего бота, чтобы убедиться в корректности его работы и избежать неприятных сюрпризов.

Как сделать бота Telegram более функциональным?

Эхо-бот — это лишь основа. После успешного тестирования вы можете:

• Добавить команды, например /start, /help.
• Разработать интерактивное меню с кнопками.
• Интегрировать API сторонних сервисов, чтобы бот мог, например, показывать погоду.
• Превратить его в полноценного чат-бота с искусственным интеллектом.

Кнопки и команды

Они упрощают взаимодействие чат-бота с пользователями в мессенджере, позволяя пользователю выбрать доступное действие из списка. Вот пример, как их можно создать:

from telegram import InlineKeyboardButton, InlineKeyboardMarkup

def start(update: Update, context: CallbackContext):
    keyboard = [[InlineKeyboardButton("Кнопка 1", callback_data='1'),
                 InlineKeyboardButton("Кнопка 2", callback_data='2')]]
    reply_markup = InlineKeyboardMarkup(keyboard)
    update.message.reply_text('Выберите опцию:', reply_markup=reply_markup)

Разберем ключевые части.

1. Импорты InlineKeyboardButton используются для создания кнопок с текстом и данными (callback_data). InlineKeyboardMarkup задает структуру клавиатуры для размещения кнопок.
2. Функция start активируется, когда пользователь вводит команду /start.
3. Переменная keyboard:
   • Список списков, где каждый вложенный список — это строка кнопок на клавиатуре.
   • Кнопка создается с помощью InlineKeyboardButton, ее текст отображается пользователю, а callback_data передается при нажатии для последующей обработки.
4. Переменная reply_markup используется для прикрепления кнопок к сообщению.
5. Метод reply_text отправляет сообщение пользователю вместе с разметкой клавиатуры (reply_markup), которая позволяет пользователю выбирать опции, нажимая на кнопки.

Интеграция с внешними платформами

Бота можно интегрировать с различными платформами, такими как CRM, социальными сетями и другими ресурсами. Например, добавим прогноз погоды через OpenWeather API:

1. Получите API-ключ на OpenWeather.
2. Напишите функцию:

import requests

def get_weather(city):
    api_key = "API_KEY"  # Замените на ваш ключ API из OpenWeather
    url = f"http://api.openweathermap.org/data/2.5/weather?q={city}&appid={api_key}&units=metric"

    try:
        response = requests.get(url)
        response.raise_for_status()  # Проверяем, нет ли ошибок HTTP
        data = response.json()

        if 'main' in data:
            return f"Температура в {city}: {data['main']['temp']}°C"
        else:
            return f"Не удалось получить данные о погоде для города: {city}. Убедитесь, что название введено правильно."
    except requests.exceptions.RequestException as e:
        return f"Произошла ошибка при запросе: {e}"

if __name__ == "__main__":
    city = input("Введите название города: ")  # Запрос ввода города у пользователя
    print(get_weather(city))

Как развернуть Telegram-бота на сервере?

Чтобы Telegram-бот работал 24/7, его нужно разместить на сервере. Один из самых простых способов — использовать Heroku. Heroku — это PaaS (Platform as a Service), то есть платформа как услуга, которая предоставляет готовую инфраструктуру для запуска приложений, включая серверы, базы данных и инструменты для деплоя. С помощью Heroku вы можете разместить своего Telegram-бота, чтобы он работал круглосуточно, без необходимости настраивать и поддерживать сервер самостоятельно. Сделать это несложно:

1. Зарегистрируйтесь на Heroku.
2. Создайте requirements.txt (список зависимостей вашего проекта), выполнив команду:
   python
pip freeze > requirements.txt

3. Установите Heroku CLI и загрузите свой код.

Не забудьте протестировать работу бота после разворачивания его на сервере.

Теперь вы знаете, как сделать бота в Telegram. Это не только полезный навык, но и увлекательный процесс. Научиться создавать Telegram-ботов, а также автоматизировать другие бизнес-задачи, можно на курсе Python-разработчика от компании Хекслет.