Built for webhook & long-polling bots

Telegram Bot VPS with a valid HTTPS endpoint, static IP, and 24/7 uptime

Telegram bots aren't Discord bots: there's no persistent gateway. Your bot lives or dies by whether setWebhook can reach a public HTTPS URL, or whether your long-polling loop stays alive. We hand you both: open :443, Let's Encrypt on tap, systemd already loaded.

setWebhook · live
200 OK
Telegram MTProtoPOST /webhook
47 ms
TLS 1.3Let's Encrypt · valid 84d
nginxproxy_pass → :8443
aiogramdispatcher.feed_update()
Your botsendMessage
38 ms

p50 rtt

42 ms

cert

valid

restarts

0

Webhooks or long-polling: the hosting requirements are completely different.

Discord bots hold a WebSocket open. Telegram bots either sit in a getUpdates loop or expose a public HTTPS endpoint. Which one you pick changes the infrastructure you need, so we support both, properly.

Webhook

Telegram pushes to you

Telegram POSTs each update to an HTTPS endpoint you register with setWebhook. Requires a valid TLS certificate on port 443, 80, 88 or 8443, a static IP, and always-on reachability. Fastest option, with no idle polling.

  • Static public IP + open :443
  • Free Let's Encrypt certificate
  • Nginx / Caddy reverse proxy preinstalled
  • setWebhook one-liner after deploy
Long polling

Your bot pulls from Telegram

getUpdates keeps a persistent request open until Telegram has something to send. No inbound port or SSL cert needed, but the process must stay running 24/7, and duplicate handlers will drop updates.

  • Zero TLS setup: start in one command
  • Perfect while prototyping
  • Any outbound-only firewall works
  • systemd keeps the poll loop alive

Telegram will refuse to talk to a plain HTTP endpoint.

setWebhook rejects http://, self-signed certs with unknown roots, and any endpoint outside ports 443, 80, 88 or 8443. On a home connection that means dynamic DNS, port forwarding, and a fragile setup. On our VPS, one certbot command hands you a valid Let's Encrypt cert with auto-renew.

Let's Encrypt preinstalled
Static IPv4 + IPv6
nginx & Caddy ready
HTTP/2 + TLS 1.3
bot.example.com · ~/deploy.sh
# 1. TLS cert (free, auto-renew)
$ sudo certbot --nginx -d bot.example.com
Successfully deployed certificate for bot.example.com

# 2. Register webhook with Telegram
$ curl -F "url=https://bot.example.com/tg/{secret}" \
       https://api.telegram.org/bot$TOKEN/setWebhook
{"ok":true,"result":true, "description":"Webhook was set"}

# 3. Boot bot under systemd
$ sudo systemctl enable --now mybot.service
● mybot.service · active (running)
  Restart=always · 0 restarts today

python-telegram-bot, aiogram, grammY: all first-class.

Every popular Telegram framework runs the same way here: root SSH, pick your stack, wire systemd, done.

python-telegram-bot

v21 · asyncio

The reference Python framework. ConversationHandler, JobQueue, PicklePersistence: all preinstalled with pip, ready to run under systemd with Restart=always.

aiogram

3.x · fully async

Modern async-first framework loved for FSM state, dependency injection, and clean routers. Ships nicely with uvicorn + FastAPI when running webhook mode.

Telegraf / grammY

Node.js 20 / 22

Node bots deploy behind pm2 in seconds. TypeScript, middleware, session stores, and the same devx as express. grammY's runner scales one bot across CPU cores.

Telethon / Pyrogram

MTProto userbots

Full MTProto access for userbot automation, channel scraping, and multi-account setups. Persistent session files, floodwait handling, and Redis-backed state work out of the box.

The bots that show up here most often.

E-commerce & order bots

Payment links, order lookup, live shipping status. Sub-second webhook response keeps checkout snappy.

Alerts & notifications

Price alerts, monitoring pings, deploy notifications. A dedicated VPS means no cold-starts and no delivery gaps.

Community & group admin

Anti-spam, captcha gatekeeping, welcome flows across dozens of groups. Redis-backed rate limits ride on the same box.

MTProto userbot automation

Telethon or Pyrogram jobs running on a static IP. Safer than a home network, and it won't get flagged for constant re-logins.

Run one bot today, ten from the same VPS tomorrow.

Add bots as separate systemd units, share one nginx or Caddy in front, and let a single Redis instance handle sessions and rate-limit state across all of them.

Reverse proxy

nginx or Caddy on :443 with SNI routing per subdomain. One cert per bot via certbot's -d flag.

Bot processes

One systemd unit per bot. Restart=always, User=bot, EnvironmentFile= for tokens. Logs go to journalctl.

Shared state

Redis for FSM state and dedup, Postgres for orders and users. Both idle at < 100 MB.

Choose Your Plan

All plans include DDoS protection, full admin access, and 24/7 support.

Basic

Entry-level remote desktop

$.$7.99/mo
CPU2 Cores
RAM6 GB ECC
Storage40GB NVMe
Network1G→10G
Support SLA6 hours
Order Now

Standard

Balanced performance

$.$14.99/mo
CPU4 Cores
RAM8 GB ECC
Storage70GB NVMe
Network1G→10G
Support SLA6 hours
Order Now

Pro

Most popular choice

Popular
$.$27.99/mo
CPU6 Cores
RAM12 GB ECC
Storage90GB NVMe
Network1G→10G
Support SLA6 hours
Order Now

Advanced

Heavy workloads

$.$36.99/mo
CPU12 Cores
RAM24 GB ECC
Storage150GB NVMe
Network1G→10G
Support SLAPremium
Order Now

Everything you'd ask before pointing setWebhook at us.

A Telegram bot works exactly as well as the machine it's on. On a laptop or home PC you'll close the lid, restart for Windows Update, lose Wi-Fi, or get a new dynamic IP, and every one of those is a silent outage. Worse, if you're running webhook mode Telegram will retry a failed delivery for up to 24 hours but will pause new updates when your endpoint is unreachable. A VPS gives you a static IP, systemd, and a machine that never sleeps.

Long-polling is the fast path while you're building: getUpdates works from anywhere with outbound internet, no domain or TLS cert needed. For anything production, webhooks are lower-latency and cheaper in resources: Telegram pushes updates to your HTTPS endpoint instead of your bot idling in a getUpdates loop. Webhooks require a valid TLS certificate (Let's Encrypt is fine) on port 443, 80, 88 or 8443, plus a stable public IP, which is exactly what a VPS gives you.

Point a subdomain like bot.yourdomain.com at your VPS's IPv4, then run certbot with the Nginx or Caddy plugin: one command, free 90-day cert, auto-renew via cron. Caddy will do it in a single Caddyfile line with `bot.yourdomain.com { reverse_proxy localhost:8443 }`. If you don't own a domain, you can use Cloudflare's free tier and terminate TLS at their edge, though direct is simpler.

Yes. Each bot has its own token, its own process, and its own port (in webhook mode). We recommend one systemd unit per bot with Restart=always, and a shared nginx or Caddy reverse proxy fronting them all on :443. Webhook Pro (4 GB RAM, 2 vCPU) comfortably runs 3–5 modestly-sized bots; Multi-Bot handles ten with Redis and Postgres on the same box.

For Python bots, a 10-line systemd unit with `Restart=always` and `RestartSec=5` is the standard: your bot is back online in under 5 seconds after a crash or reboot. For Node bots, pm2 does the same job and adds log rotation and cluster mode. Both come preinstalled on our Ubuntu 22.04 image, and we can wire a healthcheck endpoint to Uptime Kuma so you get pinged the moment anything looks off.

The Bot API caps outbound at ~30 messages/second per bot globally and 1 message/second per chat, with bursts allowed. Group-wide announcements need to be spaced. python-telegram-bot's AIORateLimiter and aiogram's throttling middleware handle this automatically. On the VPS side you never hit any limit; the constraint is Telegram's.

Absolutely. Userbots use MTProto (not the Bot API), so they run alongside your Bot API workers without conflict. The Userbot / MTProto plan is sized for scenarios where you're keeping several sessions warm: 8 vCPU / 16 GB is enough for a healthy handful of concurrent Telethon workers plus a Redis session store. Static IPs help here: Telegram is less likely to flag account re-logins from a consistent address.

Linux. Ubuntu 22.04 or Debian 12 is what every Telegram bot framework ships against: pip, apt, systemd, nginx, certbot, docker compose, all preinstalled or one command away. Windows is available if you need it, but every tutorial and framework's docs assumes Linux.

Card checkout activates in under 5 minutes with root SSH creds emailed instantly. Crypto payments (BTC, USDT, XMR) come online on first confirmation, usually 10–20 minutes. After that: `git clone`, `pip install`, `systemctl start`, `curl -F url=…` to setWebhook, and you're live.

Give your Telegram bot a real address on the internet.

Static IP, valid TLS cert, and a systemd unit that survives every reboot. Ready in five minutes.

Deploy Telegram Bot VPS