What it really costs to run a Telegram trading bot on Solana

Everyone who has shipped a Telegram bot has heard the pitch: create a bot with @BotFather, call the HTTP API, done. The Bot API really is free. No per-message invoice, no seat license, no API key plan. That is true for a weather bot and true for a Solana trading bot.

What is not free is everything that makes a trading bot useful: a process that stays up, an RPC that does not rate-limit you mid-snipe, a stream that sees the pool before the next block, compute and tips so the swap lands, storage for users and orders, and a human who answers when something breaks at 3am. This article is the honest stack cost for Solana builders, not a marketing calculator.

Click to zoom

What "a Telegram trading bot" actually is

For this piece, a trading bot means: users talk to Telegram; your backend parses commands or buttons; your backend builds and signs (or co-signs) Solana transactions; you submit them for landing; you report fills and balances back in chat. That is the BonkBot / Trojan / Photon-class product shape, and also the personal-only sniper you run for yourself.

Architecture in one line:

Telegram client
    │  Bot API (webhook or long poll)  →  $0
    ▼
Your bot process (always on)
    │  DB, secrets, queues
    ▼
Solana data plane
    │  RPC + optional gRPC / shreds
    ▼
Landing path
    │  sendTransaction / Jito bundles + tips
    ▼
Chain + DEXes / routers
    │  base fee + priority fee + protocol fees
    ▼
Reply in Telegram

Telegram is the UX shell. Almost every dollar and every failure mode lives below it.

Layer 0: Telegram itself ($0, with caveats)

Official FAQ: bots message users at no cost, subject to rate limits. Practical caps you will hit in production:

• About 1 message per second into a single private chat (bursts allowed; sustained overage becomes 429s).
• About 20 messages per minute into a group.
• About 30 messages per second global for bulk notifications across chats.

If you need to blast every user at once (product launch, incident, market alert), Telegram offers paid broadcasts: up to 1,000 msg/s, charged at 0.1 Stars per message above the free 30/s, with eligibility gates (large Stars balance + high monthly active users). Most trading bots never enable this. They rate-limit alerts and queue replies instead.

Delivery choices: long polling is fine for a single process on a VPS. Webhooks want TLS and a stable HTTPS endpoint (ports 443/80/88/8443). Webhooks are usually cheaper at scale because you are not holding open poll connections, and they fit serverless better. For a 24/7 trading process, either works; reliability of your host matters more than the transport.

Budget: $0 for the API. Budget Stars only if you deliberately choose paid broadcast scale.

Layer 1: Hosting (always-on process)

A trading bot is not a weekend Lambda. Missed webhooks, cold starts, and sleep schedules lose money. You want a process that never stops, health checks, restart on crash, and preferably two regions if users trust you with flow.

Ballpark monthly (2026):

• Hetzner / small VPS: roughly $5–25 for 2–4 GB RAM with Docker or systemd. You own TLS, patches, backups.
• DigitalOcean / Lightsail-class: ~$6–48 depending on size.
• Railway / Render / Fly-class PaaS: often $5–40 for a small always-on service once free tiers and idle tricks are gone; usage and egress can surprise you.
• Multi-instance + queue + staging: $50–200+ before anything Solana-specific.

Database: SQLite on the same box is fine for a personal bot. Multi-user product needs Postgres (managed ~$0–25 hobby, $15–80 serious) plus backups. Redis or an in-memory queue helps for order fan-out and rate limiting Telegram replies.

Budget: hobby $5–20; product $30–120; production multi-region $100–400.

Layer 2: Solana RPC (where the first real bill appears)

The public endpoint (api.mainnet-beta.solana.com) is for demos. Production trading on it is self-harm. Shared paid RPC is the first non-zero line item most teams feel.

Helius-style shared plans (public pricing as of mid-2026; always recheck dashboards):

Plan            Monthly    Credits    RPS     sendTx/s   Notes
Free            $0         1M         10      1          Test only
Developer       $49        10M        50      5          Staked connections
Business        $499       100M       200     50         gRPC + sendBundle
Professional    $999       200M       500     100        Scale + support
Dedicated       from ~$2,900         custom   custom     Colocate / custom

Other providers (QuickNode, Triton, FluxRPC, Alchemy, etc.) price differently but land in the same bands: free or tens of dollars for light use, hundreds for multi-user products, thousands for dedicated. See our RPC providers comparison and latency benchmarks for method-level differences.

What a trading bot actually spends credits on: getAccountInfo / balances, quote simulation, sendTransaction, confirmation polls, token metadata, sometimes DAS. A quiet personal bot can live on free or $49. A popular multi-user bot that confirms every swap and refreshes portfolios will burn credits fast; $499 is common once you leave "friends and family."

Budget: $0–49 hobby; $49–499 indie product; $499–999+ shared production; dedicated when latency or rate caps force it.

Layer 3: Streaming and market data (the silent multiplier)

Polling RPC for every pool and wallet does not scale. Real-time bots use WebSocket subscriptions or, better, Yellowstone-style gRPC (Geyser). That is the same plane as indexers and MEV searchers. Read Yellowstone gRPC / Geyser for the protocol shape.

Cost shape:

• Basic WSS on a paid RPC plan: often included; enough for account and signature notifications at moderate volume.
• Production gRPC (LaserStream-class): typically unlocked on higher shared tiers (~$499+). Bandwidth add-ons for heavy streams are often hundreds to thousands per month (example public bands: multi-TB data add-ons from roughly $400–$4,500/mo).
• Raw shred delivery: for teams that want data before full block reconstruction. Public list prices around $800–$1,000 per IP per month are common. This is competitive infrastructure, not a hobby line item.
• Oracle / price APIs (Pyth, Switchboard, CEX books if you hybrid-trade): often free tiers, then usage. For pure on-chain Solana spot routers you may lean on DEX quotes instead.

If your bot only reacts to user commands ("buy this mint with 1 SOL"), you can skip shreds and maybe skip gRPC. If it watches thousands of wallets or pools continuously, streaming becomes the bill.

Budget: $0–50 hobby (poll + light WSS); $0–500 product (gRPC on shared plan); $400–5,000+ when data volume or shreds enter.

Layer 4: On-chain fees and tips (usage-scaled, not rent)

Infra is fixed-ish. Inclusion cost scales with how hard you trade.

• Base fee: 5,000 lamports per signature (~0.000005 SOL). Negligible per tx.
• Priority fee (CU price): bid for inclusion in local fee markets. Quiet conditions: fractions of a cent. Contested mints and congested markets: cents to more. You pay for the CU limit you request, not only CU used.
• Jito tip: separate auction for bundles. Minimum tips are tiny; competitive tips during launches are not. Telegram retail bots are a known tip-flow category precisely because users spam buys under contention. Details and when to tip: priority fees in 2026 and Jito block engine.
• Failed transactions still cost money when they land and revert, or when you burn priority fees on attempts that never land. Bad retry loops are a cost bug, not just a UX bug.
• Protocol fees: DEX / router fees (often bps of notional) dominate unit economics for a product bot. That is revenue share or user cost, not "infra," but it is what users compare you on.

Worked example (order-of-magnitude, not a guarantee). Assume SOL at $150 for dollarization:

1,000 user swaps / day
Base fee only:     1,000 × 0.000005 SOL ≈ 0.005 SOL/day   (~$0.75/mo)
+ modest priority: +0.00002 SOL each  ≈ 0.02 SOL/day    (~$3/mo)
+ contested tips:  +0.001–0.01 SOL on 10% of txs
                   → 0.1–1 SOL/day on that slice alone
                   → tens to hundreds of $/mo, spikes much higher

100k swaps / day at launch-week tip levels:
tips can exceed your entire RPC bill by 10–100×

Product bots usually pass tips and priority through to the user wallet (or take a platform fee that covers them). Personal bots pay from the operator wallet. Either way, treat tips as variable COGS, not as "Solana is cheap so ignore it."

Budget: near-zero for light personal use; tens to hundreds $/mo for active multi-user retail; unbounded under sustained contention if you subsidize landing.

Layer 5: Keys, custody, and not getting drained

This is the cost line that does not show on a SaaS invoice until it destroys you.

• Personal bot, hot key on disk: $0 until the VPS is compromised. Expected loss if compromised: entire hot wallet.
• Multi-user non-custodial: users sign (session keys, deep links, or external wallets). Your infra cost stays lower; UX is harder. Session key design and wallet infra still cost eng time.
• Multi-user custodial or semi-custodial: you hold or can move funds. You need encrypted key stores, strict host isolation, withdrawal policies, audit logs, maybe HSM/KMS, maybe a real custody vendor. Dollar cost: tens to thousands per month for tooling, plus engineering. Liability cost: unbounded.

Practical minimum for anything that holds value for others: secrets out of git, separate hot wallets with low float, automated transfer of profits to cold storage, rate limits on withdrawals, anomaly alerts, and an incident plan. If that list feels heavy, stay non-custodial or personal-only.

Budget: $0–20 tools for a careful solo; $50–500+/mo for managed secrets + monitoring at product scale; enterprise custody is a different category.

Layer 6: Observability, uptime, and human time

Uptime monitoring (Better Stack, Healthchecks, Grafana Cloud free tiers, etc.): $0–30. Error tracking (Sentry): $0–26+. Log retention: $0–50 depending on volume. Status page: optional.

The real number is engineering hours. A personal bot might take a weekend to ship and an hour a month to keep alive. A multi-user trading bot is an always-on product: dependency bumps, RPC incidents, Telegram API blips, DEX program upgrades, fee market regime changes, abuse (spam commands, drain attempts), and support DMs. If you value eng time at even a modest contractor rate, one on-call evening a week dominates the VPS bill.

Rough people cost (opportunity cost, not payroll accounting):

• Hobby maintain: 2–5 hours/month
• Indie product: 20–80 hours/month
• Production: dedicated owner or team rotation

Three budgets, fully rolled up

Numbers are mid-2026 order-of-magnitude for Solana. Exchange-only bots that never touch a chain replace RPC/tips with CEX API fees and different rate limits; the Telegram and hosting layers stay similar.

A. Personal sniper / portfolio helper

Telegram API              $0
VPS / PaaS                $5–15
RPC                       $0–49
Streaming                 $0 (poll or light WSS)
DB                        $0 (SQLite)
Monitoring                $0–10
On-chain fees/tips        $1–50 (your volume)
Keys                      self-managed hot wallet
────────────────────────────────
Typical total             ~$10–80 / month
Plus: your time           weekend build + light keep-alive

B. Indie multi-user product (thousands of users, not unicorn scale)

Telegram API              $0 (queue broadcasts; avoid paid blast)
Hosting + staging         $30–100
Postgres + Redis          $20–60
RPC                       $49–499
gRPC / enhanced APIs      often bundled at $499 tier
Monitoring + errors       $20–50
Domain, email, extras     $5–20
Platform fee wallet float keep enough SOL for retries
On-chain (user-paid)      pass through tips/priority
Keys / custody design     eng-heavy; tooling $0–200
────────────────────────────────
Typical total             ~$150–800 / month infra
Dominated by:             RPC tier + eng time + support

C. Competitive trading / high-volume product

Multi-region compute      $100–500+
RPC shared top tier       $999
  or dedicated nodes      $1,500–5,000+
gRPC data add-ons         $400–2,500+
Shreds (optional)         $800–1,000 / IP
Colo / low-latency net    variable
Jito path + tip budget    variable; can dwarf infra
Custody / security        $100s–$1000s + audit
On-call eng               real salary line
────────────────────────────────
Typical total             $1k–10k+ / month
Before:                   tip wars and protocol fee share

Where teams waste money

• Public RPC in production. Saves $49 until the first failed launch, then costs reputation.
• Overpaying CU limits and tips on every retry. Cap retries, backoff, and use fee APIs / recent percentiles instead of a fixed panic number. See priority fee recipe.
• Polling what should be a subscription. Burns credits and loses races.
• Custodial design without float limits. One bug is a full drain. Limit hot wallet balance aggressively.
• Ignoring Telegram 429s. A successful on-chain swap with a failed user notification creates support load and double-submit risk. Queue outbound messages.
• Shreds and dedicated nodes too early. Buy them when measured latency or rate limits prove shared plans lose money, not because a Twitter thread said so.

Where to spend first

1. Reliable hosting + process manager so the bot is up.
2. Paid RPC with staked send path once you leave experiments. Landing rate is product quality.
3. Sane fee and tip policy with budgets and metrics (cost per landed swap, fail rate).
4. Key and withdrawal hygiene before you market to strangers.
5. Streaming when command-driven polling is clearly the bottleneck.
6. Shreds / dedicated / colo only with a competitive reason and measurement.

Compliance and product risk (not a legal opinion)

Multi-user bots that execute trades, hold funds, or take fees can trigger money-transmission, broker-dealer, or local fintech rules depending on jurisdiction and design. Non-custodial UX and careful geo/product choices reduce some surfaces; they do not erase all of them. Budget for counsel if you take real volume. A single enforcement action dwarfs a year of Helius bills.

Also budget reputation: Telegram is full of drainers that look like trading bots. Clear branding, open docs, rate limits, and never asking users to export seed phrases are table stakes.

Bottom line

Running a Telegram bot is free. Running a Telegram trading bot costs whatever your Solana data plane, landing path, and operational seriousness require. For a personal tool, think tens of dollars a month. For an indie product, think low hundreds to under a thousand in infra before tips and people. For anything competing on speed at scale, think thousands, with tips and engineering as the open end.

If you only remember one ratio: the Bot API will not be your largest line item. RPC, streaming, inclusion, and the cost of being wrong about keys will.

Resources

• Telegram Bot API
• Telegram Bots FAQ (rate limits and paid broadcasts)
• Helius pricing (example shared + dedicated Solana infra)
• Solana transaction fees docs
• Jito docs (bundles, tips, low-latency send)
• Related on devrels.xyz: RPC providers compared, priority fees, Jito block engine, Yellowstone gRPC, MEV and Paladin, Helius webhooks