Telegram Bot API: An Introduction

Telegram is a messaging app that is similar to WhatsApp and Facebook Messenger. It was created by Russian entrepreneur Pavel Durov and is known for its emphasis on security and speed. Telegram allows users to send messages, photos, videos and other files to others and to create group chats with up to 200,000 members. It is available on a variety of platforms, including iOS, Android and desktop (Windows and OSX).

Why Use Telegram APIs?

The Telegram platform is a convenient tool overall, making it even easier for developers to use Telegram APIs for their specific needs. 

Security Measures

Telegram emphasizes security by using end-to-end encryption to keep chats private. Users also have the option to set up two-factor authentication. This reinforces the platform as a safe option for developers working with sensitive information. 

Reliable Communication

Telegram is decentralized by nature, having developed a blockchain known as The Open Network. This means users can communicate in real time while maintaining a strong connection, even on weaker networks and in areas with less reliable internet. 

Free and Open-Source APIs

While the Bot API isn’t technically open-source, all Telegram APIs are free to use and the Telegram API and Telegram Database Library are open-source. This gives developers more freedom to experiment without worrying about hefty costs.  

Various Ways to Engage Audiences

Telegram allows users to communicate with audiences through tools like automated responses, polls and CRM integrations. As a result, users can deliver fast and consistent updates to readers, customers and other audiences.    

Types of Telegram APIs

Telegram offers two kinds of APIs for developers. The Bot API allows you to easily create programs that use Telegram messages for an interface. The Telegram API and TDLib allow you to build your own customized Telegram clients.

We will be using the Bot API, which allows developers to connect bots to their applications and systems. Bots are special accounts that do not require a telephone number to set up and correspond to an interface for code running on one or multiple servers.

Note that several wrappers exist for the Bot API. These wrappers are written in various languages and let you interact programmatically with the API. For the purpose of this tutorial, we’ll be using the Python client.

More From Giorgos MyrianthousAPI for Dummies

Features of Telegram Bots

While there are clear advantages to using the Telegram platform, Telegram bots offer further upsides. Here are some key features of Telegram bots that establish them as a go-to option for many developers: 

• Easy setup: Creating Telegram bots is designed to be a simple process. Users just getting started with Telegram can turn to the Botfather for help with developing their first Telegram bot. 
• Detailed documentation: Telegram has developed an in-depth library of tutorials for building bots and exploring different use cases. Telegram also has a lively community of developers who can answer questions. 
• Variety of data: Telegram bots support a wide variety of data, including text, video, image and location data. This enables users to develop different types of content and perform advanced actions like hosting games.  
• Fast communication: Telegram bots are able to send and receive information in real time, avoiding typical latency issues. This ensures bots deliver timely notifications and messages.  
• Scalability: Some platforms place a limit on the number of bots a user can build, but this is not the case with Telegram. Users can develop an unlimited number of bots and scale their solutions as needed. 

Use Cases for Telegram Bot API

Telegram Bot API can be used for a variety of purposes, including the following use cases:

• Manipulating videos and images. 
• Setting up systems that are responsible for managing notifications. 
• Building interactive games. 
• Providing personalized news updates.

Additionally, the Telegram Bot API allows for the creation of bots that can be easily integrated with other services and interact with external APIs. For example, you could build a notification system that makes use of the Telegram Bot API that, in turn, calls the GitHub Actions API and informs you when a build has failed or succeeded.

How to Use the Telegram Bot API

Now that you have an idea of what the Telegram Bot API can be used for, here’s the process of how to set it up.

1. Install the Python Library

Python-telegram-bot is an asynchronous interface for the Telegram Bot API. First, let’s create a fresh virtual environment that we will use to install the dependencies required as part of this tutorial:

python3 -m vevn ~/telegram-tutorial-venv

Now that we have created the virtual environment, we can go ahead and activate it:

source ~/telegram-tutorial-venv/bin/activate

And finally, let’s install the Python wrapper for the Telegram Bot API using pip:

pip install python-telegram-bot --pre --upgrade

2. Get the Telegram Bot API Token

To make use of the Telegram Bot API, we first need to generate a token that will be used by subsequent requests to the API endpoint (this is going to be handled by the Python client, but we still have to pass this token once).

On your Telegram application (either on your mobile or desktop), search for the BotFather account (make sure to use the verified one):

Next, follow these steps:

• Click the Start button at the bottom of the screen.
• Type /newbot and click Enter
• Then choose a name for the bot.

• And, finally, pick a user name (this must be unique).

In the response, you should be able to access the token generated, which can be used to control our newly created bot. 

3. Build the Telegram Bot

Now that we have generated the token for our newly created Telegram bot, we can go ahead and start building its logic. To let users interact with our bot, we need to provide some commands.

First, let’s build a proper welcome message that will be presented to the users whenever they type /start:

from telegram import Update
from telegram.ext import Application, ContextTypes, CommandHandler


token = '<your-telegram-bot-token>'

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await context.bot.send_message(
     chat_id=update.effective_chat.id, 
     text='Hello and welcome to the BuiltIn Telegram bot!'
    )

if __name__ == '__main__':
    application = Application.builder().token(token).build()
    
    start_handler = CommandHandler('start', start)
    application.add_handler(start_handler)
    application.run_polling()

And now, let’s test this functionality:

Now, let’s build the /help command that will essentially list and inform the users about all the commands supported by the bot.

from telegram import Update
from telegram.ext import Application, ContextTypes, CommandHandler


token = '<your-telegram-bot-token>'

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await context.bot.send_message(
     chat_id=update.effective_chat.id, 
     text='Hello and welcome to the BuiltIn Telegram bot!'
    )

async def help(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await context.bot.send_message(
     chat_id=update.effective_chat.id, 
     text="""
     The BuiltIn Telegram bot supports the following commands:
      - /start: Welcoming users
      - /help: List of supported commands (you are here)
      - /first_name: Reports the user's first name
      - /last_name: Reports the user's last name
     """
    )

if __name__ == '__main__':
    application = Application.builder().token(token).build()
    
    start_handler = CommandHandler('start', start)
    application.add_handler(start_handler)

    help_handler = CommandHandler('help', help)
    application.add_handler(help_handler)

    application.run_polling()

And here’s the response whenever the user calls the /help command:

Finally, let’s build two additional handlers that can be used to report users’ first and last names whenever they get called:

from telegram import Update
from telegram.ext import Application, ContextTypes, CommandHandler


token = '<your-telegram-bot-token>'

async def start(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await context.bot.send_message(
     chat_id=update.effective_chat.id, 
     text='Hello and welcome to the BuiltIn Telegram bot!'
    )

async def help(update: Update, context: ContextTypes.DEFAULT_TYPE):
    await context.bot.send_message(
     chat_id=update.effective_chat.id, 
     text="""
     The BuiltIn Telegram bot supports the following commands:
      - /start: Welcoming users
      - /help: List of supported commands (you are here)
      - /first_name: Reports the user's first name
      - /last_name: Reports the user's last name
     """
    )

async def first_name(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
    await context.bot.send_message(
     chat_id=update.effective_chat.id, 
     text=f'Your first name is {update.message.from_user.first_name}'
    )


async def last_name(update: Update, context: ContextTypes.DEFAULT_TYPE) -> int:
    await context.bot.send_message(
     chat_id=update.effective_chat.id, 
     text=f'Your last name is {update.message.from_user.last_name}'
    )



if __name__ == '__main__':
    application = Application.builder().token(token).build()
    
    start_handler = CommandHandler('start', start)
    application.add_handler(start_handler)

    help_handler = CommandHandler('help', help)
    application.add_handler(help_handler)

    first_name_handler = CommandHandler('first_name', first_name)
    application.add_handler(first_name_handler)

    last_name_handler = CommandHandler('last_name', last_name)
    application.add_handler(last_name_handler)

    application.run_polling()

And here we go — let’s see our finalized bot in action:

More in Software DevelopmentAn Introduction to Terraform Environment Variables

Get Started With the Telegram Bot API

Telegram has been gaining traction and has now become one of the most popular messaging applications around the globe. In this tutorial, we demonstrated how to create a new Telegram bot, generate a token to be used for API calls and how to build functionality around it.

We’ve only touched a very small subset of the Telegram Bot API and the Python client. Make sure to read the documentation for a more comprehensive understanding of the full capabilities of the API and the client itself.

Frequently Asked Questions