How to Build a Telegram Bot with Node.js (Beginner Tutorial)

Telegram bots are automated accounts that respond to messages, execute commands, send files, manage groups, and connect to external services. Unlike a regular Telegram account controlled by a person, a bot is controlled entirely by code you write.
This guide walks you through exactly how bots work and how to build a simple one using Node.js. If you want to see the finished bot before starting, you can try it here: ReverseLearningBot. Send it any text and it replies with the characters reversed.
What this covers:
How Telegram bots work under the hood
Registering a bot with BotFather
Building a working bot with Node.js
Hosting options to keep your bot online

How Telegram Bots Work

When a user sends a message to a bot, here is what happens:

The message arrives at Telegram's servers
Telegram forwards it to your running bot application via the Bot API
Your code processes the message
Your bot sends a reply back through the Bot API
Telegram delivers that reply to the user

The key piece in this flow is the Telegram Bot API, the HTTP interface your code uses to communicate with Telegram. Every action your bot takes, sending a message, serving a file, displaying a button, goes through this API.

What bots can do

Telegram bots are more capable than most people expect. A bot can reply to text messages, send images, videos, and documents, display inline keyboards and action buttons, moderate group chats, handle payments, connect to databases and external APIs, send scheduled notifications, and integrate with AI services.

Step 1: Register Your Bot with BotFather

Every Telegram bot is registered through an official bot called BotFather. Open Telegram, search for @BotFather, and start the chat.

Send this command:

/newbot

BotFather will ask for two things: a display name and a username. The username must end in bot.

Name: Reverse Learning Bot
Username: reverse_learning_bot

Once you confirm, BotFather hands you a bot token that looks like this:

7383828:AAHhshshs...

This token is your bot's API key. It authenticates every request your code makes to Telegram. Keep it private and never commit it to a public repository.

Step 2: Set Up the Project

Create a project folder and initialize a Node.js project:

mkdir telegram-bot-learning
cd telegram-bot-learning
npm init -y

Install the Telegram library:

npm install node-telegram-bot-api

Open package.json and add the module type so you can use ES module imports:

{
  "type": "module"
}

Step 3: Write the Bot

Create a file called index.js and add the following:

import TelegramBot from 'node-telegram-bot-api';

const token = 'PASTE_YOUR_TOKEN_HERE';

const bot = new TelegramBot(token, {
  polling: true,
});

console.log('Bot is running...');

bot.on('message', (msg) => {
  const chatId = msg.chat.id;
  const text = msg.text;

  const reversed = text.split('').reverse().join('');

  bot.sendMessage(chatId, reversed);
});

This bot listens for any incoming message and replies with the text reversed. Send it hello and it replies olleh.

Replace PASTE_YOUR_TOKEN_HERE with the actual token from BotFather:

const token = '123456:ABCxyz';

Step 4: Run and Test the Bot

Start the bot:

node index.js

You should see this in your terminal:

Bot is running...

Open Telegram, search for your bot's username, press Start, and send any message. The bot should reply with the reversed version of your text.

Note: The polling: true option tells your bot to continuously check Telegram's servers for new messages. This is fine for development. For production, webhooks are more efficient.

Hosting Your Bot

Your bot only works while the node index.js process is running. To keep it online continuously, you need to host it somewhere.

For beginners, platforms like Render and Railway are the easiest starting point. Both offer free tiers and support Node.js deployments without requiring server configuration. You push your code, set your TOKEN as an environment variable, and the platform keeps the process running.

If you want more control, a cheap VPS from DigitalOcean, Hetzner, or Linode gives you a Linux server where you can run your bot with a process manager like pm2 to keep it alive across restarts.

Key Takeaways

A Telegram bot is an automated account controlled by code via the Telegram Bot API
All bots are registered through BotFather, which issues the token your code uses to authenticate
polling: true is the simplest way to receive messages during development
Your bot needs a continuously running process to stay online, which means deploying to a hosting platform or a VPS
The node-telegram-bot-api library handles the API communication so you can focus on the logic

Conclusion

You now have a working Telegram bot built with Node.js. The reverse-text example is intentionally minimal, but the same structure applies to anything more complex: receive a message, process it with your logic (query a database, call an API, run a calculation), and send a response.

From here, you can extend the bot to handle specific commands using bot.onText(), serve structured menus with inline keyboards, or connect it to an external API to build something genuinely useful. If you want to see the finished version of what you just built, the live bot is available at t.me/ReverseLearningBot.

If you run into issues during setup or have questions about taking this further, drop them in the comments below.

What are you planning to build with your bot? Share your idea in the comments.