Introduction

Have you ever wanted to provide AI-powered services but found ChatGPT’s $20/month subscription too expensive for casual users? I built a Telegram bot that offers GPT-5 access for just 1 Telegram Star per request - making AI accessible and affordable for everyone.

In this article, I’ll walk you through building a monetized AI chatbot using Telegram’s native payment system (Telegram Stars), OpenAI’s GPT-5 API, and Python.

💡 The Idea

The concept is simple but powerful:

• Pay-per-use model: 1 Telegram Star = 1 AI request
• No subscriptions: Users only pay for what they use
• Lower barrier to entry: Much cheaper than $20/month ChatGPT Plus
• Built-in payments: Telegram Stars integration means no external payment processors

🛠 Tech Stack

Core Technologies

1. Python 3.7+ - Main programming language
2. pyTelegramBotAPI - Telegram Bot API wrapper
3. OpenAI Python SDK - For GPT-5 integration
4. SQLite3 - Lightweight database for user data and transactions
5. python-dotenv - Environment variable management
6. Telegram Stars - Native Telegram payment system

Why These Technologies?

• Python: Easy to read, fast to develop, excellent libraries
• SQLite: Zero configuration, perfect for small to medium scale
• Telegram Stars: No payment processor fees, instant transactions, built into Telegram
• OpenAI API: Direct access to GPT-5, simple REST API

📐 Architecture Overview

┌─────────────┐
│   User      │
│  (Telegram) │
└──────┬──────┘
│
▼
┌─────────────────┐
│  Telegram Bot   │
│   (bot.py)      │
└────┬──────┬─────┘
│      │
│      ▼
│  ┌──────────────┐
│  │  OpenAI API  │
│  │   (GPT-5)    │
│  └──────────────┘
│
▼
┌─────────────────┐
│  SQLite DB      │
│  - Users        │
│  - Requests     │
│  - Payments     │
└─────────────────┘

🔧 Implementation

1. Project Structure

chatgpt-telegram-bot/
├── bot.py           # Main bot logic
├── functions.py     # OpenAI API integration
├── db.py           # Database management
├── config.py       # Configuration loader
├── .env            # Environment variables
├── requirements.txt
└── README.md

2. Database Schema

# db.py
import sqlite3
from threading import Lock

class DatabaseManager:
def __init__(self, db_name='bot.db'):
self.db_name = db_name
self.lock = Lock()

def create_tables(self):
with self.lock, sqlite3.connect(self.db_name) as conn:
cursor = conn.cursor()

# Users table - unified balance
cursor.execute('''CREATE TABLE IF NOT EXISTS users (
id INTEGER PRIMARY KEY AUTOINCREMENT,
tg_id INTEGER UNIQUE NOT NULL,
requests INTEGER DEFAULT 3,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)''')

# Requests history with token metrics
cursor.execute('''CREATE TABLE IF NOT EXISTS results (
id INTEGER PRIMARY KEY AUTOINCREMENT,
tg_id INTEGER NOT NULL,
prompt TEXT NOT NULL,
result TEXT NOT NULL,
prompt_tokens INTEGER DEFAULT 0,
completion_tokens INTEGER DEFAULT 0,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)''')

# Payment transactions
cursor.execute('''CREATE TABLE IF NOT EXISTS payments (
id INTEGER PRIMARY KEY AUTOINCREMENT,
tg_id INTEGER NOT NULL,
amount INTEGER NOT NULL,
stars_paid INTEGER NOT NULL,
payment_id TEXT,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)''')

conn.commit()

Key Design Decisions:

• Unified balance: Single requests field instead of separate free/paid
• Token tracking: Monitor API usage for cost optimization
• Payment audit trail: Complete transaction history

3. OpenAI Integration

# functions.py
from openai import OpenAI
from config import AI_TOKEN

client = OpenAI(api_key=AI_TOKEN)

def get_openai_response(message: str, effort: str = "low",
verbosity: str = "low"):
"""
Get response from GPT-5 using new Responses API
Returns: (text, prompt_tokens, completion_tokens)
"""
try:
result = client.responses.create(
model="gpt-5",
input=message,
reasoning={"effort": effort},
text={"verbosity": verbosity},
)

text = result.output_text
usage = getattr(result, "usage", None)
prompt_tokens = getattr(usage, "input_tokens", 0)
completion_tokens = getattr(usage, "output_tokens", 0)

return text, prompt_tokens, completion_tokens

except Exception as e:
print(f"Error in OpenAI API: {e}")
return f"Error: {e}", 0, 0

Why the new Responses API?

• Simplified interface compared to Chat Completions
• Built-in reasoning control
• Better token management

4. Telegram Bot Core

# bot.py
import telebot
from telebot import types

bot = telebot.TeleBot(BOT_TOKEN)

# Dictionary to track users entering custom amounts
waiting_for_amount = {}

@bot.message_handler(commands=['start'])
def send_welcome(message):
db_manager.add_user(message.chat.id, initial_requests=3)
requests = db_manager.get_user_requests(message.chat.id)

welcome_text = (
"👋 Welcome! I'm your GPT-5 AI assistant.\n\n"
f"💰 Your balance: {requests} requests\n\n"
"Send me a message (min 10 characters) and I'll help!\n\n"
"Commands:\n"
"/start - start bot\n"
"/help - get help\n"
"/balance - check balance\n"
"/buy - purchase requests\n"
"/dev - about developer"
)
bot.reply_to(message, welcome_text)

5. Telegram Stars Payment Integration

@bot.message_handler(commands=['buy'])
def buy_requests(message):
markup = types.InlineKeyboardMarkup(row_width=3)

# Quick purchase options
buttons = [
types.InlineKeyboardButton("1 ⭐", callback_data="buy_1"),
types.InlineKeyboardButton("5 ⭐", callback_data="buy_5"),
types.InlineKeyboardButton("10 ⭐", callback_data="buy_10"),
types.InlineKeyboardButton("25 ⭐", callback_data="buy_25"),
types.InlineKeyboardButton("50 ⭐", callback_data="buy_50"),
types.InlineKeyboardButton("100 ⭐", callback_data="buy_100"),
]
markup.add(*buttons)

# Custom amount button
custom_button = types.InlineKeyboardButton(
"✏️ Custom Amount",
callback_data="buy_custom"
)
markup.add(custom_button)

bot.send_message(
message.chat.id,
"💳 Purchase Requests\n\n1 request = 1 ⭐ Telegram Star",
reply_markup=markup
)

@bot.callback_query_handler(func=lambda call: call.data.startswith('buy_'))
def process_buy(call):
if call.data == 'buy_custom':
waiting_for_amount[call.from_user.id] = True
bot.send_message(
call.message.chat.id,
"✏️ Enter amount (1-1000):"
)
return

amount = int(call.data.split('_')[1])
create_invoice(call.message.chat.id, call.from_user.id, amount)

def create_invoice(chat_id, user_id, amount):
"""Create Telegram Stars invoice"""
prices = [types.LabeledPrice(
label=f"{amount} requests",
amount=amount
)]

bot.send_invoice(
chat_id=chat_id,
title=f"Purchase {amount} requests",
description=f"Buy {amount} requests to GPT-5 bot",
invoice_payload=f"requests_{amount}_{user_id}",
provider_token="",  # Empty for Telegram Stars
currency="XTR",  # Telegram Stars currency code
prices=prices
)

@bot.pre_checkout_query_handler(func=lambda query: True)
def process_pre_checkout(pre_checkout_query):
"""Confirm payment"""
bot.answer_pre_checkout_query(pre_checkout_query.id, ok=True)

@bot.message_handler(content_types=['successful_payment'])
def process_successful_payment(message):
"""Handle successful payment"""
payment_info = message.successful_payment

# Parse payload
payload_parts = payment_info.invoice_payload.split('_')
amount = int(payload_parts[1])
user_id = int(payload_parts[2])

# Add requests to user
db_manager.add_requests(user_id, amount)

# Save payment record
db_manager.add_payment(
tg_id=user_id,
amount=amount,
stars_paid=amount,
payment_id=payment_info.telegram_payment_charge_id
)

requests = db_manager.get_user_requests(user_id)
bot.send_message(
message.chat.id,
f"✅ Payment successful!\n\n"
f"➕ Added: {amount} requests\n"
f"💰 New balance: {requests} requests"
)

Telegram Stars Benefits:

• No external payment processor needed
• No transaction fees (Telegram takes a small cut)
• Instant confirmation
• Built into Telegram app
• Supports custom amounts

6. Message Processing

@bot.message_handler(func=lambda message: True)
def generate_result(message):
# Check if waiting for custom amount input
if message.from_user.id in waiting_for_amount:
try:
amount = int(message.text.strip())
if 1 <= amount <= 1000:
del waiting_for_amount[message.from_user.id]
create_invoice(
message.chat.id,
message.from_user.id,
amount
)
else:
bot.send_message(
message.chat.id,
"❌ Invalid amount! Enter 1-1000:"
)
return
except ValueError:
bot.send_message(
message.chat.id,
"❌ Please enter a number:"
)
return

# Validate message length
if len(message.text) < 10:
bot.send_message(
message.chat.id,
"⚠️ Message too short (min 10 characters)"
)
return

if len(message.text) > 4000:
bot.send_message(
message.chat.id,
"⚠️ Message too long (max 4000 characters)"
)
return

# Check balance
requests = db_manager.get_user_requests(message.chat.id)
if requests <= 0:
bot.send_message(
message.chat.id,
"❌ No requests left! Use /buy to purchase more.\n"
"1 request = 1 ⭐ Telegram Star"
)
return

# Show typing indicator
bot.send_chat_action(message.chat.id, 'typing')

try:
# Get GPT-5 response
response_text, prompt_tokens, completion_tokens = \
get_openai_response(message.text)

# Deduct request
if db_manager.use_request(message.chat.id):
# Save to database
db_manager.add_result(
message.chat.id,
message.text,
response_text,
prompt_tokens,
completion_tokens
)

# Send response
bot.reply_to(message, response_text)

# Show remaining balance
requests = db_manager.get_user_requests(message.chat.id)
if requests > 0:
bot.send_message(
message.chat.id,
f"💰 Remaining: {requests} requests"
)
else:
bot.send_message(
message.chat.id,
"❌ No requests left! Use /buy to purchase more."
)
except Exception as e:
bot.reply_to(message, f"❌ Error: {str(e)}")

🎯 Key Features Implemented

1. Flexible Payment System

• Quick purchase buttons (1, 5, 10, 25, 50, 100 Stars)
• Custom amount input (1-1000)
• State management for user input flow

2. User Experience

• Typing indicator: Shows bot is processing
• Balance feedback: After each request
• Clear pricing: 1 Star = 1 Request
• Free trial: 3 free requests for new users

3. Admin Dashboard

@bot.message_handler(commands=['stats'])
def show_stats(message):
if message.from_user.id == ADMIN_ID:
total_users = db_manager.get_total_users()
total_requests = db_manager.get_total_requests()
total_revenue = db_manager.get_total_revenue()

bot.reply_to(
message,
f"📊 Bot Statistics:\n\n"
f"👥 Total users: {total_users}\n"
f"💬 Total requests: {total_requests}\n"
f"⭐ Revenue: {total_revenue} Stars"
)

📊 Performance & Scalability

Current Setup

• Database: SQLite with threading locks
• Suitable for: Up to 10,000 users
• Response time: 2-5 seconds (depends on OpenAI API)

Scaling Considerations

For larger scale, consider:

• PostgreSQL/MySQL: Better concurrent access
• Redis: For session management and caching
• Message Queue: For handling spike loads
• Load Balancer: Multiple bot instances

💰 Cost Analysis

Running Costs

• Server: $5-10/month (VPS)
• OpenAI API: ~$0.03-0.15 per request (GPT-5)
• Telegram Stars: ~30% commission to Telegram

Pricing Strategy

• 1 Star ≈ $0.013 (varies by region)
• Profit margin: ~20-40% after API costs
• Break-even: ~500 paid requests/month

🔒 Security Best Practices

1. Environment Variables: Never commit .env files
2. Input Validation: Check message length and content
3. Rate Limiting: Prevent abuse (can add)
4. Payment Verification: Always verify payment webhooks
5. Database Locks: Thread-safe operations
6. Error Handling: Graceful failure recovery

🚀 Deployment

Quick Deploy Script

#!/bin/bash

# Clone repository
git clone https://github.com/king-tri-ton/chatgpt-telegram-bot.git
cd chatgpt-telegram-bot

# Install dependencies
pip install -r requirements.txt

# Setup environment
cp .env.example .env
nano .env  # Edit with your tokens

# Run bot
python bot.py

Using systemd (Linux)

[Unit]
Description=GPT-5 Telegram Bot
After=network.target

[Service]
Type=simple
User=youruser
WorkingDirectory=/path/to/bot
ExecStart=/usr/bin/python3 bot.py
Restart=always

[Install]
WantedBy=multi-user.target

📈 Future Improvements

• [ ] Image generation support (DALL-E)
• [ ] Conversation history/context
• [ ] Referral system
• [ ] Subscription plans
• [ ] Multi-language support
• [ ] Voice message support
• [ ] Analytics dashboard
• [ ] A/B testing for pricing

🎓 Lessons Learned

1. Telegram Stars are game-changing: No payment processor hassle
2. SQLite is underrated: Perfect for MVPs
3. User experience matters: Clear pricing, instant feedback
4. Start simple: Can always add features later
5. Monitor costs: OpenAI API costs can add up

🤝 Contributing

The project is open-source under MIT license. Contributions welcome!

Ways to contribute:

• Report bugs
• Suggest features
• Submit pull requests
• Improve documentation
• Share feedback

📚 Resources

• Telegram Bot API
• Telegram Stars Documentation
• OpenAI API Reference
• pyTelegramBotAPI

🎉 Conclusion

Building a monetized AI bot with Telegram Stars is surprisingly straightforward. The combination of:

• Low entry barrier (1 Star per request)
• Built-in payments (no Stripe/PayPal)
• Powerful AI (GPT-5)
• Simple tech stack (Python + SQLite)

...makes this a viable micro-SaaS project.

The bot is live at @ChatGPTTlgrmBot - try it out!

Full source code: GitHub

---

Questions? Feedback? Drop a comment below or reach out on Telegram: @king_triton

If you found this helpful, please ⭐ the GitHub repo and share with others!

python #telegram #openai #gpt5 #bot #monetization #telegramstars #ai #chatbot #opensource