Telegram is a great platform with lots of great users (I’m a Telegram user myself). And what would be the best way for Telegram users to receive notifications? We can’t know for sure. Maybe they like email or something else. But we can guess that sending notifications to Telegram would be pretty convenient.

If you would like to send Telegram notifications from your application, you’ve come to the right place. I’ve added this feature to my application and I love it.

One quick note. In this article I provide examples of code in Python. But the ideas are not Python-specific and can be translated into another language without any hastle.

So without further ado, let’s dive into how we can do it.

Create a Telegram bot

First of all, you need to create a Telegram bot. To do this you need to use another Telegram bot, BotFather. Just talk to him (press start).

Now you see what it can do. But what interests us is creating a new bot, so that’s what we’re going to choose (/newbot).

You’re quickly going to find out that bot’s name should end with “bot”. And since you’re like me and coming to the game too late, most bot names are already taken.

But eventually, you’re going to find a name for your bot and get an access token we’re going to need.

Now that you have a bot, Telegram users can find and use it. But there is one problem — you can’t associate users that come from Telegram to the users in your application. Let me show you why.

Once a user presses the “Start” button on your bot, you will receive an “update”. You can check all bot’s updates even in your browser by visiting the following URL https://api.telegram.org/bot{bot_token}/getUpdates (don’t forget to use your access token in the URL). Here’s what I got:

Can’t read anything? Don’t worry. You can fix it by installing some JSON prettifier extension in your browser. I use JSON Formatter for Chrome. It looks so much better.

So as you can see we don’t get that much information about the person. From this information, we can get their full name. But it would be lucky if the user would provide their full name in your application, and doesn’t guarantee uniqueness of it. So we can’t use that to find a user in your applications.

Another piece of information we get is the username. That is more useful as it is unique between all Telegram users. But most likely you don’t have that available in your applications. So we would need to ask a user to enter their username somewhere in the application. It’s just too much work that I’m not sure anyone would do.

Another option to associate a user would be to ask them to provide the email that they used in your application to the bot. But this has too many flaws: the user can make a typo while entering the email, the user can enter the email of another user and exploit the system. This is just too bad.

Can we do better?

Associating a user

Of course we can. To associate the user, we’ll use a technique called deep linking.

First, you need to create a random unique token for each user. I’ve used the following code to generate the token using Python:

from secrets import token_urlsafetoken = token_urlsafe(8)token# => 'uEDbtJFHxKc'

Then you need to save that token to be able to find a user with it later. You can save it to your database or use some other place like a cache for example. I have a Notification model so I added a field to a model’s table.

class Notification(models.Model):    user = models.ForeignKey(User, on_delete=models.CASCADE)    # ...    connect_token = models.CharField(max_length=64, null=True)

So we’ve generated uEDbtJFHxKc token and saved it. Now we need to use this token in a URL to the telegram bot which the user needs to click to make it all work:

telegram_url = 'https://www.telegram.me'bot_name = 'music_notification_bot'token = 'uEDbtJFHxKc'url = f'{telegram_url}/{bot_name}?start={token}'

Now that we have our URL, 'https://telegram.me/music_notification_bot?start=uEDbtJFHxKc', it’s time to show it to the user. Just display it in any place of your application and wait for the user to click on it.

Once the user takes the bait and clicks “Start” you should receive another update:

{    "ok": true,    "result": [        // ...        // previous updates           // ...        {            "update_id": 599162365,            "message": {                "message_id": 174,                "from": { ... },                "chat": { ... },                "date": 1549788357,                "text": "/start uEDbtJFHxKc",                "entities": [ ... ]            }        }    ]}

We can finally identify our user. The text field now contains our user token. Let’s go ahead and take it out of this field:

bot_token = 'your_bot_token'updates_url = f'https://api.telegram.org/bot{bot_token}/getUpdates'import requestsresponse = requests.get(updates_url).json()text = response['result'][0]['message']['text']text# => '/start uEDbtJFHxKc'splitted_text = text.split(' ')# => ['/start', 'uEDbtJFHxKc']token = splitted_text[-1]# => 'uEDbtJFHxKc'

This token can be used to find the user. Your implementation depends on the way you saved the token in the first place. But here’s how I do it:

notification = Notification.objects.get(channel='telegram', connect_token=token)user = notification.user

So the user had pressed the “Start” button. But they see that nothing happened. Let’s welcome them at least.

To welcome the user we need to discover that the user had started a conversation with our bot. There are two options for how we can do that: polling and webhooks.

You already know what polling is. You’ve already done it. Or at least have seen me do it. Once we’ve checked out the https://api.telegram.org/bot{bot_token}/getUpdates page we did one poll. Polling is checking for updates constantly, every 2 seconds for example. This way we can always know when someone interacted with the bot.

Webhooks take a bit of a different direction. Instead of checking every 2 seconds for updates, we just wait for an update to happen. And when it happens Telegram will send a request with the update data to a URL that we specify. This way we can give both our and Telegram servers some rest and just wait for the update to come.

Polling can be better if you’ve got high traffic but, unfortunately, it’s rather an exception so I’ve decided to go with the webhook.

Webhooks

Setting a webhook in Telegram is very easy. You just need to send a request to https://api.telegram.org/bot{bot_token}/setWebhook?url={your_server_url}. Opening this link in your browser works too. your_server_url is the URL Telegram will send updates to. Here’s what you should get in the response:

{    "ok": true,    "result": true,    "description": "Webhook was set"}

If you don’t trust yourself you can visit https://api.telegram.org/bot{bot_token}/getWebhookInfo just to doublecheck that everything is OK. You should see something like this:

{    "ok": true,    "result": {        "url": "https://example.com/your_server_endpoint",        "has_custom_certificate": false,        "pending_update_count": 0,        "max_connections": 40    }}

Now. If something is not OK (like you’ve set a wrong URL) you can always delete the webhook by visiting [https://api.telegram.org/bot{bot_token}/deleteWebhook](https://api.telegram.org/bot{bot_token}/deleteWebhook) and then setting the webhook again.

Local development

Before continuing I would like to say a few words about local development. Webhooks are not very suitable for it. Webhooks are sent to a URL and most likely you don’t know your computer’s URL. Also, a Telegram webhook requires the URL to be secure (HTTPS).

But there is a solution to this problem: ngrok. ngrok is a tool that exposes your local environment to the world. Download ngrok, install it and start it with the port your server is running on. My server is running on 8000 port so I would need to run in a console

/path/to/ngrok http 8000

Then ngrok should give you a URL that you can use to set a webhook up.

Welcoming a user

Now that you’re ready to develop, let’s welcome our user — they’re waiting for it.

Once the user clicks “Start”, your Telegram will send an update to your server’s URL. The interesting parts of the update should look like this:

{    "message": {        "chat": {            "id": 457        },        "text": "/start uEDbtJFHxKc",    }}

This is a perfect time to associate the user using message text. There is also an interesting piece of information, chat ID. Chat ID is what we need to send a message to that user. Telegram has an API endpoint to send a message that looks like this https://api.telegram.org/bot{bot_token}/sendMessage?chat_id={chat_id}&text={text}. I’m not sure I need to explain how to use it but here’s what my code that processes the webhook looks like:

import jsonimport requestsdef callback(request):    body = json.loads(request.body)    text = body['message']['text']    token = text.split(' ')[-1]    associate_user_by_token(token)    bot_key = os.environ.get('TELEGRAM_API_KEY')    chat_id = body['message']['chat']['id']    text = "Welcome!"    send_message_url = f'https://api.telegram.org/bot{bot_key}/sendMessage?chat_id={chat_id}&text={text}'    requests.post(send_message_url)

If we send a welcome message after the user clicked the famous “Start” button, the user won’t have any second thoughts whether everything is working or not.

Pushing notifications

Finally, we get to the point why we’re doing all of this — push notifications. You may want to notify the user about some information that happened in your application. For example, someone liked the user’s post or whatever. I use Telegram to notify about new music releases from the user’s favorite artists.

You already know how to send notifications. You just need to send a message using [https://api.telegram.org/bot{bot_token}/sendMessage?chat_id={chat_id}&text={notification_text}](https://api.telegram.org/bot{bot_token}/sendMessage?chat_id={chat_id}&text={notification_text}.).

Of course, if you’re planning to send notifications not only when the user interacts with the bot, you need to save chat_id in your database.

You might also want to include links or some other formatting in your message. In this case, you would need to add another parameter to the send message URL, parse_mode. There are 2 parsing options: Markdown or HTML. I use Markdown since I find it simpler to use. If you’re not familiar with Markdown you can use HMTL, but I would recommend reading how easy Markdown is.

Here’s how the send message URL looks with parse_mode parameter [https://api.telegram.org/bot{bot_token}/sendMessage?chat_id={chat_id}&text={notification_text}&parse_mode=markdown](https://api.telegram.org/bot{bot_token}/sendMessage?chat_id={chat_id}&text={notification_text}&parse_mode=markdown.).

I add links to new releases to the notifications text like so {release.date}: {release.artist.name} - [{release.title}]({release.url}). You can read more about how to format you messages here.

Also, there are more parameters available for the send message URL like disable_notification. There is always a place to explore.

Conclusion

Now you should know how to

• create a bot in Telegram using BotFather
• check for updates (and what is a better way — webhooks or polling)
• associate user using deep linking
• send a welcome message and continue sending notifications
• format messages you send

Hopefully, this article was useful to you. This is the fifth part of a series of articles about the MuN. Stay tuned for part 6. You can find the code of this project, as well as my other projects, on my GitHub page. Leave your comments down below and follow me if you liked this article.

Originally published at https://kholinlabs.com/telegram-push-notifications on February 12, 2019.

I built a Telegram chatbot that sends out a SOS to rescuers when someone is stranded in the rain. It’s written in Python using AWS Lambda, Zappa and Flask.

You can try it here. I haven’t added in persistence yet ? but I think some of this here might be useful to anyone else interested in a similar project.

I normally have a hard time getting my fiancée to discuss technology. It’s come to a point where she can’t help but stifle a yawn once I say “code”.

Imagine my surprise this weekend when she asked me — pretty much out of the blue — how much it would cost to make a mobile app.

After losing it for a bit, here’s what I found out.

The problem

My fiancée’s workplace is close to two MRT stations but there aren’t any covered paths from the MRT stations to her building. When it rains, people without umbrellas get stranded at the stations. She and her colleagues often head down to help friends out, but there are often more people stranded there than they expected.

Her colleagues were discussing if an app could help solve this. Well, I thought that a chatbot might be able to have the same functions (such as sending out request for umbrellas, location sharing, getting replies). And you could avoid convincing people to download another app.

Since I’d been meaning to try out Telegram’s bot APIs for awhile now, I volunteered to help build out a prototype so we could see how interesting this might actually be.

The chatbot

I started working on this on Saturday afternoon and went to bed at 2am on Sunday. But I’m really happy to have gone from knowing nothing about the bot APIs to being able to make something like this.

Anyone can request an umbrella. The bot asks where the person is, how many umbrellas he/she might need, and when they’d like to be picked up (the options are limited so we don’t tax our rescuers too much).

This is what the chatbot does when you request an umbrella

People can register to be rescuers. A little good karma goes a long way ?

This is how someone becomes a rescuer

Rescuers get notified whenever someone near them is stranded in the rain. I wanted to make it clear to rescuers whether they were responsible for the request once they had pressed “Yes”.

This is how a rescuer receives and answers a request

In the process I learned a few tricks about making the development a lot faster. I spent almost six hours before I managed to find the right tools and a development workflow that worked for me. Building the bot logic took me a much shorter time.

What I used

AWS Lambda

Instead of running a server 24/7, you can host functions in Lambda so that the server only lasts for the lifecycle of the request. It’s great for prototypes since you get 1 million free requests a month.

Zappa

This automates the steps needed to get your local Python code onto AWS Lambda. It also configures Amazon’s API Gateway so you have a nice HTTPS endpoint to host your chatbot functions.

ngrok

This makes any local servers reachable via the internet. It’s a great way to prototype web-hooks before actually deploying them to the cloud.

These tools helped me avoid a lot of the headache that goes into making a chatbot (e.g. renting a server, configuring it for HTTPS, figuring out how to make the server non-blocking since this is a chatbot).

Today I’ll show you how I used these tools to develop the chatbot above. Hope this will help someone else on a similar journey.

Walkthrough

This tutorial assumes that you’re making a chatbot with no knowledge of how Telegram’s bot API works, but with a working knowledge of Flask and Python. If anything seems too simple for you, feel free to skip ahead!

Create a Telegram bot

Visit the Botfather. Type /newbot and follow his instructions to set up a new bot.

And just like this we have a chatbot setup on Telegram!

⚡ Pro tip: save the token somewhere, we’ll be using it soon!

Feel free to play around with the bot’s profile picture, about text, and description to give it whatever personality you want. Typing /help with the Botfather gives you the full list of settings you can tweak for your bot.

Set up a development server with Flask

I worked with pipenv to manage my project’s Python dependencies. If you’re still using pip and virtualenv I encourage you guys to give this a try. There’s installation instructions at the link.

Next we’ll install Flask. We’ll also use the awesome requests library. In your command line type:

pipenv install flaskpipenv install requests

After flask is installed, we’ll set up a basic server to test our bot. Copy the following text into a file called server.py .

⚡ Pro tip: Make sure you replace <your-bot-token> with the API token we got from the Botfather.

Let’s break down what this is doing. Telegram’s API works this way. Firstly, when someone sends your bot a message, that message gets sent to Telegram’s servers. Telegram then forwards us that message to whatever we specify as our web-hook as a POST request.

The function process_update() and the decorator above it says that when anyone POSTs to the domain [http://127.0.0.1:5000](http://127.0.0.1:5000)/<your-bot-token> , we will extract the JSON data from it. If it’s a normal text message, it will have the key message in the JSON. We check for that and if it’s a normal message, we reply using process_message(update) .

The function process_message() constructs the payload that the Telegram API is expecting if we want to reply to the message. We basically need to specify our reply text in data["text"] and the chat we’re replying to in data["chat_id"] .

Finally, we send a POST request with this payload to the Telegram API endpoint for the sendMessage method. This allows us to send a message programmatically.

Time to run the server. Now in your command prompt type:

pipenv shell

This activates the virtual environment and gives us access to Flask. Now we need to run the server locally. Type in the command prompt:

export FLASK_APP=server.pyflask run

We have a running server! If you didn’t mess with the defaults, this is running at http://127.0.0.1:5000/.

Read more at the Flask documentation and quick-start.

But this is running locally, and Telegram’s bot API can’t send its POST requests to a local URL. Hence we’ll use ngrok to expose this local server to the internet.

Use ngrok to make the local server accessible on the internet

Get the package for your operating system from this link on the ngrok website. Once you’ve downloaded and installed it, go to the directory that you unzipped the file into and run the following command in the command prompt.

./ngrok http 5000

You’ll see something similar in your command prompt. Now whatever server you’re running on localhost:5000 is exposed at the following URLs.

⚡ Pro tip: Copy the https url, we’re going to use it soon.

Time to let Telegram know what our web-hook address is. We’ll use the Telegram API again to set our web-hook.

Create a file called webhook.py with the following content:

⚡ Pro tip: Remember to replace <your-bot-token>; and <your-https-url> !

pprint lets us print out nicely formatted JSON data. We send our web-hook URL as a POST request to the [setWebhook](https://core.telegram.org/bots/api#setwebhook) endpoint of the Telegram API. Now run the following lines in your command prompt:

pipenv install pprintpython webhook.py

You should see 200 and a JSON block with 'ok': True .

Test out your chatbot

Now we’re done with setting up our server. Head over to your bot in Telegram, and say hello! If everything’s been set up correctly, you’ll see it reply I can hear you!

In the next part of this tutorial, we’ll learn how to deploy this server onto the internet using Zappa and AWS Lambda. Give this a couple of claps if this was helpful for you — I’d love to know if it was. Thanks ?