Version 4.8.0 Update

New Features Overview

The version 4.8.0 update introduces several powerful enhancements to improve your bot development experience:

1. New Account Class: Direct access to account-level operations through the globally accessible Account variable.

2. Enhanced Resource Management: New accountRes class for managing account-level resources.

3. Improved Server Stability: Enhanced server maintenance and durability.

4. Command Aliases: Support for command aliases in the upcoming UI update.

5. Bot Recovery System: Ability to recover deleted bots within 90 days.

6. Coming Soon - Bot Store: A marketplace for discovering, sharing, and deploying pre-made bots.

7. Coming Soon - Points Faucet: System to obtain unlimited points for running your bots.

Advertising and Points System

Points System Enhancements

Telebot Creator continues to offer one of the most generous free bot hosting solutions available:

• Initial Allocation: New accounts receive 100,000 points upon creation.

• Command Cost: Each command execution costs just 1 point.

• Free Additional Points: Users can request additional points at any time by contacting admins in the TBC Help Group.

• Upcoming Points Faucet: In the next update, a points faucet system will allow users to obtain unlimited points.

Ad Policy Clarification

Telebot Creator maintains a minimal advertising approach to keep the platform free while ensuring a great user experience:

• Low Frequency: Advertisements appear only 2-4 times per month.

• Non-Intrusive Format: Ads are delivered as a single broadcast message, not as continuous spam.

• User-Friendly: This approach ensures that bot users enjoy an uninterrupted experience.

New Account Class

The 4.8.0 update introduces the powerful Account class, giving developers direct access to account-level operations. This class allows for comprehensive management of bots, commands, statistics, and more from a centralized interface.

Accessing the Account Class

The Account class is globally accessible in your bot code through the Account variable, similar to how you access the Bot and User classes:

# The Account variable is directly available in your bot code
result = Account.get_bots_list()
if result["ok"]:
    for bot_info in result["result"]:
        Bot.sendMessage(f"Bot: {bot_info['name']}")

No initialization is needed as the variable is automatically created with the correct authentication and database connections.

Account Data Management Methods

saveData

Stores data at the account level, accessible across all bots.

Account.saveData(name, data)

Parameters:

• name (Required): Name identifier for the data.

• data (Required): The data to store (limited to 10MB).

Example:

result = Account.saveData("global_settings", {"theme": "dark", "notifications": True})
Bot.sendMessage(f"Save result: {result['result']}")

Example Output:

{
  "ok": "true",
  "result": "Added new data"
}

getData

Retrieves previously stored account data.

Account.getData(name)

Parameters:

• name (Required): Name of the data to retrieve.

Example:

settings = Account.getData("global_settings")
if settings:
    Bot.sendMessage(f"Theme: {settings['theme']}")
else:
    Bot.sendMessage("No settings found")

Example Output:

{
  "theme": "dark",
  "notifications": true
}

deleteData

Deletes account data by name.

Account.deleteData(name)

Parameters:

• name (Required): Name of the data to delete.

Example:

result = Account.deleteData("temp_data")
Bot.sendMessage(f"Delete result: {result['result']}")

Example Output:

{
  "ok": "true",
  "result": "deleted"
}

getDataFile

Returns account data as a file that can be sent to users.

Account.getDataFile(name, output_format="txt")

Parameters:

• name (Required): Name of the data to retrieve.

• output_format (Optional): Format of the output file (currently supports "txt").

Example:

try:
    file = Account.getDataFile("report_data")
    Bot.sendDocument(file)
except ValueError as e:
    Bot.sendMessage(f"Error: {str(e)}")

Example Output:

# Returns a file-like object that can be directly passed to Bot.sendDocument()
# The file contains the stored data in text format

getAllData

Retrieves all account data entries, optionally filtered by name pattern.

Account.getAllData(name=None, output_format="json")

Parameters:

• name (Optional): Name pattern to filter data.

• output_format (Optional): Format of the output file (currently supports "json").

Example:

data_file = Account.getAllData("config_")
Bot.sendDocument(data_file)

Example Output:

# Returns a file-like object containing JSON data in the format:
# [
#   {
#     "name": "config_user",
#     "data": {"setting1": "value1", "setting2": "value2"},
#     "time": "2023-05-15 14:30:22"
#   },
#   {
#     "name": "config_bot",
#     "data": {"timeout": 30, "retry": true},
#     "time": "2023-05-16 09:15:43"
#   }
# ]

deleteAllData

Deletes all account data, with optional exclusions and bot data inclusion.

Account.deleteAllData(except_data=None, include_bot_data=False)

Parameters:

• except_data (Optional): List of data names to preserve.

• include_bot_data (Optional): Whether to also delete bot-level data.

Example:

result = Account.deleteAllData(except_data=["important_settings"], include_bot_data=True)
Bot.sendMessage(f"Data cleared: {result['result']}")

Example Output:

{
  "ok": "true",
  "result": "deleted"
}

info

Returns basic account information.

Account.info()

Example:

info = Account.info()
Bot.sendMessage(f"Account plan: {info.plan}, Points left: {info.points_left}")

Example Output:

{
  "email": "[email protected]",
  "plan": "Premium",
  "points_resetAt": "2023-06-01 00:00:00",
  "points_left": 8500,
  "ep": 1000
}

Bot Management Methods

start_bot

Starts a bot by setting its webhook.

Account.start_bot(botid)

Parameters:

• botid (Required): ID of the bot to start.

Example:

result = Account.start_bot("1234567")
Bot.sendMessage(f"Start result: {result['result']}")

Example Output:

{
  "ok": true,
  "result": "Bot started successfully"
}

stop_bot

Stops a bot by removing its webhook.

Account.stop_bot(botid)

Parameters:

• botid (Required): ID of the bot to stop.

Example:

result = Account.stop_bot("1234567")
Bot.sendMessage(f"Stop result: {result['result']}")

Example Output:

{
  "ok": true,
  "result": "Bot stopped successfully"
}

restart_bot

Restarts a bot by stopping and then starting it.

Account.restart_bot(botid)

Parameters:

• botid (Required): ID of the bot to restart.

Example:

result = Account.restart_bot("1234567")
Bot.sendMessage(f"Restart result: {result['result']}")

Example Output:

{
  "ok": true,
  "result": "Bot started successfully"
}

create_bot

Creates a new bot with the given token.

Account.create_bot(bot_token, bot_name=None, bot_username=None)

Parameters:

• bot_token (Required): Telegram bot token.

• bot_name (Optional): Name for the bot (retrieved from Telegram if not provided).

• bot_username (Optional): Username for the bot (retrieved from Telegram if not provided).

Example:

result = Account.create_bot("123456789:ABCDEF-ghijklmnopqrstuvwxyz")
if result["ok"]:
    Bot.sendMessage(f"Created bot with ID: {result['botid']}")
else:
    Bot.sendMessage(f"Error: {result['result']}")

Example Output:

{
  "ok": true,
  "result": "Bot created successfully",
  "botid": "7654321"
}

delete_bot

Deletes a bot (temporarily or permanently).

Account.delete_bot(botid, permanent=False)

Parameters:

• botid (Required): ID of the bot to delete.

• permanent (Optional): Whether to permanently delete or keep for recovery.

Example:

result = Account.delete_bot("1234567")
Bot.sendMessage(f"Delete result: {result['result']}")

Example Output:

{
  "ok": true,
  "result": "Bot deleted successfully"
}

recover_bot

Recovers a previously deleted bot.

Account.recover_bot(botid, new_token=None)

Parameters:

• botid (Required): ID of the bot to recover.

• new_token (Optional): New token if the original is no longer valid.

Example:

result = Account.recover_bot("1234567")
Bot.sendMessage(f"Recovery result: {result['result']}")

Example Output:

{
  "ok": true,
  "result": "Bot recovered successfully"
}

get_deleted_bots

Retrieves a list of deleted bots that can be recovered.

Account.get_deleted_bots()

Example:

bots = Account.get_deleted_bots()
if bots["ok"] and bots["result"]:
    for bot_info in bots["result"]:
        Bot.sendMessage(f"Bot {bot_info['name']} - Days remaining: {bot_info['days_remaining']}")

Example Output:

{
  "ok": true,
  "result": [
    {
      "botid": "1234567",
      "name": "Customer Support Bot",
      "username": "customer_support_bot",
      "deleted_at": "2023-05-01T14:30:22Z",
      "commands_count": 15,
      "days_remaining": 60,
      "recoverable": true
    },
    {
      "botid": "7654321",
      "name": "Quiz Bot",
      "username": "quiz_master_bot",
      "deleted_at": "2023-04-15T09:12:45Z",
      "commands_count": 8,
      "days_remaining": 44,
      "recoverable": true
    }
  ]
}

get_deleted_bots_stats

Provides statistics about deleted bots, including counts and expiration information.

Account.get_deleted_bots_stats()

Example:

stats = Account.get_deleted_bots_stats()
if stats["ok"]:
    result = stats["result"]
    Bot.sendMessage(f"Total deleted: {result['total']}, Recoverable: {result['recoverable']}")

Example Output:

{
  "ok": true,
  "result": {
    "total": 5,
    "recoverable": 3,
    "expired": 2,
    "expiring_soon": [
      {
        "botid": "2345678",
        "name": "Test Bot",
        "days_remaining": 15
      }
    ]
  }
}

permanent_delete_bot

Permanently removes a deleted bot from the recovery system.

Account.permanent_delete_bot(botid)

Parameters:

• botid (Required): ID of the deleted bot to permanently remove.

Example:

result = Account.permanent_delete_bot("1234567")
Bot.sendMessage(f"Permanent deletion result: {result['result']}")

Example Output:

{
  "ok": true,
  "result": "Bot permanently deleted"
}

clear_expired_bots

Admin-only method to clear expired bots (deleted over 90 days ago).

Account.clear_expired_bots()

Example:

result = Account.clear_expired_bots()
Bot.sendMessage(f"Cleared expired bots: {result['result']}")

Example Output:

{
  "ok": true,
  "result": "Cleared 3 expired bots"
}

clone_bot

Creates a clone of an existing bot.

Account.clone_bot(botid, new_token=None)

Parameters:

• botid (Required): ID of the bot to clone.

• new_token (Optional): Token for the new bot.

Example:

result = Account.clone_bot("1234567", "987654321:ABCDEF-ghijklmnopqrstuvwxyz")
if result["ok"]:
    Bot.sendMessage(f"Created clone with ID: {result['botid']}")

Example Output:

{
  "ok": true,
  "result": "Bot cloned successfully",
  "botid": "8765432"
}

get_bots_list

Retrieves a list of all bots in the account.

Account.get_bots_list()

Example:

bots = Account.get_bots_list()
if bots["ok"] and bots["result"]:
    for bot_info in bots["result"]:
        Bot.sendMessage(f"Bot {bot_info['name']} - Status: {bot_info['status']}")

Example Output:

{
  "ok": true,
  "result": [
    {
      "botid": "1234567",
      "name": "Support Bot",
      "username": "support_bot",
      "status": "working",
      "creation_date": "14:30:22 01:05:2023",
      "has_token": true
    },
    {
      "botid": "7654321",
      "name": "Quiz Bot",
      "username": "quiz_master_bot",
      "status": "stopped",
      "creation_date": "09:15:43 16:04:2023",
      "has_token": true
    }
  ]
}

get_bot_info

Retrieves detailed information about a specific bot.

Account.get_bot_info(botid)

Parameters:

• botid (Required): ID of the bot to get information for.

Example:

info = Account.get_bot_info("1234567")
if info["ok"]:
    bot_info = info["result"]
    Bot.sendMessage(f"Bot {bot_info['name']}: {bot_info['user_count']} users, {bot_info['command_count']} commands")

Example Output:

{
  "ok": true,
  "result": {
    "botid": "1234567",
    "name": "Support Bot",
    "username": "support_bot",
    "status": "working",
    "creation_date": "14:30:22 01:05:2023",
    "has_token": true,
    "command_count": 12,
    "user_count": 278,
    "points_used": 5432
  }
}

get_bot_status

Checks the status of a bot.

Account.get_bot_status(botid)

Parameters:

• botid (Required): ID of the bot to check.

Example:

status = Account.get_bot_status("1234567")
if status["ok"]:
    Bot.sendMessage(f"Bot status: {status['result']['status']}")

Example Output:

{
  "ok": true,
  "result": {
    "status": "online"
  }
}

get_bot_data

Retrieves stored global data for a specific bot.

Account.get_bot_data(botid, name)

Parameters:

• botid (Required): ID of the bot to get data for.

• name (Required): Name of the data to retrieve.

Example:

data = Account.get_bot_data("1234567", "bot_settings")
if data["ok"]:
    Bot.sendMessage(f"Bot settings: {data['result']}")

Example Output:

{
  "ok": true,
  "result": {
    "welcome_msg": "Hello!",
    "timeout": 30,
    "language": "en"
  }
}

set_bot_data

Stores global data for a specific bot.

Account.set_bot_data(botid, name, data)

Parameters:

• botid (Required): ID of the bot to store data for.

• name (Required): Name identifier for the data.

• data (Required): The data to store (limited to 10MB).

Example:

result = Account.set_bot_data("1234567", "bot_settings", {"welcome_msg": "Hello!"})
Bot.sendMessage(f"Save result: {result['result']}")

Example Output:

{
  "ok": true,
  "result": "Data saved successfully"
}

Command Management Methods

create_command

Creates a new command for a bot.

Account.create_command(botid, command, code)

Parameters:

• botid (Required): ID of the bot to create the command for.

• command (Required): Name of the command.

• code (Required): Code for the command.

Example:

result = Account.create_command("1234567", "/hello", "Bot.sendMessage('Hello, world!')")
Bot.sendMessage(f"Command creation result: {result['result']}")

Example Output:

{
  "ok": true,
  "result": "Command created successfully"
}

delete_command

Deletes a command from a bot.

Account.delete_command(botid, command)

Parameters:

• botid (Required): ID of the bot to delete the command from.

• command (Required): Name of the command to delete.

Example:

result = Account.delete_command("1234567", "/hello")
Bot.sendMessage(f"Command deletion result: {result['result']}")

Example Output:

{
  "ok": true,
  "result": "Command deleted successfully"
}

edit_command

Updates the code of an existing command.

Account.edit_command(botid, command, code)

Parameters:

• botid (Required): ID of the bot to edit the command for.

• command (Required): Name of the command to edit.

• code (Required): New code for the command.

Example:

result = Account.edit_command("1234567", "/hello", "Bot.sendMessage('Updated hello message!')")
Bot.sendMessage(f"Command update result: {result['result']}")

Example Output:

{
  "ok": true,
  "result": "Command updated successfully"
}

get_command_list

Retrieves a list of all commands for a bot.

Account.get_command_list(botid)

Parameters:

• botid (Required): ID of the bot to get commands for.

Example:

commands = Account.get_command_list("1234567")
if commands["ok"] and commands["result"]:
    for cmd in commands["result"]:
        Bot.sendMessage(f"Command: {cmd['command']}, Has code: {cmd['has_code']}")

Example Output:

{
  "ok": true,
  "result": [
    {
      "command": "/start",
      "code_length": 256,
      "has_code": true
    },
    {
      "command": "/help",
      "code_length": 128,
      "has_code": true
    },
    {
      "command": "/settings",
      "code_length": 512,
      "has_code": true
    }
  ]
}

get_command_info

Retrieves detailed information about a specific command.

Account.get_command_info(botid, command)

Parameters:

• botid (Required): ID of the bot the command belongs to.

• command (Required): Name of the command to get information for.

Example:

info = Account.get_command_info("1234567", "/hello")
if info["ok"]:
    cmd_info = info["result"]
    Bot.sendMessage(f"Command code: {cmd_info['code']}")

Example Output:

{
  "ok": true,
  "result": {
    "command": "/hello",
    "code": "Bot.sendMessage('Hello, world!')",
    "code_length": 31,
    "stats": {
      "executions": 342,
      "last_executed": "2023-05-15T14:30:22Z"
    }
  }
}

get_command_usage

Retrieves usage statistics for a specific command.

Account.get_command_usage(botid, command, period="all")

Parameters:

• botid (Required): ID of the bot the command belongs to.

• command (Required): Name of the command to get usage for.

• period (Optional): Time period for statistics ("hour", "day", "week", "month", "all").

Example:

usage = Account.get_command_usage("1234567", "/hello", "week")
if usage["ok"]:
    Bot.sendMessage(f"Command usage: {usage['result']}")

Example Output:

{
  "ok": true,
  "result": {
    "command": "/hello",
    "count": 123,
    "update_types": {
      "message": 85,
      "callback_query": 38
    },
    "execution_types": {
      "direct": 95,
      "celery": 28
    },
    "period": "week"
  }
}

User Management Methods

blockUser

Blocks a user from using a specific bot.

Account.blockUser(user_id)

Parameters:

• user_id (Required): ID of the user to block.

Example:

result = Account.blockUser("123456789")
Bot.sendMessage(f"Block result: {result['result']}")

Example Output:

{
  "ok": true,
  "result": "User blocked successfully"
}

unblockUser

Unblocks a previously blocked user.

Account.unblockUser(user_id)

Parameters:

• user_id (Required): ID of the user to unblock.

Example:

result = Account.unblockUser("123456789")
Bot.sendMessage(f"Unblock result: {result['result']}")

Example Output:

{
  "ok": true,
  "result": "User unblocked successfully"
}

getBlockedUsers

Retrieves a list of blocked users for a specific bot.

Account.getBlockedUsers(botid)

Parameters:

• botid (Required): ID of the bot to get blocked users for.

Example:

users = Account.getBlockedUsers("1234567")
if users["ok"] and users["result"]:
    for user in users["result"]:
        Bot.sendMessage(f"Blocked user: {user['user_id']}, Date: {user['blocked_date']}")

Example Output:

{
  "ok": true,
  "result": [
    {
      "user_id": "123456789",
      "blocked_date": "2023-05-10T14:30:22Z"
    },
    {
      "user_id": "987654321",
      "blocked_date": "2023-05-12T09:15:43Z"
    }
  ]
}

getBlockedUsersFile

Generates a file containing blocked users information.

Account.getBlockedUsersFile(botid=None, output_format="csv")

Parameters:

• botid (Optional): ID of the bot to get blocked users for. If omitted, gets all blocked users.

• output_format (Optional): Format of the output file ("csv" or "json").

Example:

file = Account.getBlockedUsersFile("1234567", "json")
Bot.sendDocument(file)

Example Output:

# Returns a file-like object that can be directly passed to Bot.sendDocument()
# For CSV format, the file contains columns: user_id, blocked_date
# For JSON format, the file contains an array of objects with user_id and blocked_date fields

Statistics and Reporting Methods

get_bot_stats

Retrieves comprehensive statistics for a specific bot.

Account.get_bot_stats(botid)

Parameters:

• botid (Required): ID of the bot to get statistics for.

Example:

stats = Account.get_bot_stats("1234567")
if stats["ok"]:
    bot_stats = stats["result"]
    Bot.sendMessage(f"Bot {bot_stats['name']}: {bot_stats['users']['total']} users, {bot_stats['users']['active_30d']} active")

Example Output:

{
  "ok": true,
  "result": {
    "botid": "1234567",
    "name": "Support Bot",
    "username": "support_bot",
    "status": "working",
    "users": {
      "total": 1250,
      "active_30d": 450,
      "new_7d": 75,
      "blocked": 12
    },
    "commands": {
      "total": 15,
      "usage": {
        "start": 523,
        "help": 186,
        "settings": 94
      }
    },
    "points_used": 8765,
    "all_time_users": 1584
  }
}

get_bot_usage

Retrieves detailed usage statistics for a specific bot.

Account.get_bot_usage(botid, period="all")

Parameters:

• botid (Required): ID of the bot to get usage for.

• period (Optional): Time period for statistics ("day", "week", "month", "all").

Example:

usage = Account.get_bot_usage("1234567", "month")
if usage["ok"]:
    Bot.sendMessage(f"Bot usage: {usage['result']}")

Example Output:

{
  "ok": true,
  "result": {
    "commands": {
      "/start": {
        "count": 523,
        "update_types": {
          "message": 400,
          "callback_query": 123
        },
        "execution_types": {
          "direct": 450,
          "celery": 73
        }
      },
      "/help": {
        "count": 186,
        "update_types": {
          "message": 150,
          "callback_query": 36
        },
        "execution_types": {
          "direct": 160,
          "celery": 26
        }
      }
    },
    "period": "month",
    "bot": {
      "botid": "1234567",
      "name": "Support Bot",
      "username": "support_bot",
      "status": "working"
    }
  }
}

get_bots_stats

Retrieves statistics for all bots in the account.

Account.get_bots_stats()

Example:

stats = Account.get_bots_stats()
if stats["ok"]:
    all_stats = stats["result"]
    Bot.sendMessage(f"Total bots: {all_stats['total_bots']}, Total users: {all_stats['total_users']}")

Example Output:

{
  "ok": true,
  "result": {
    "total_bots": 5,
    "total_users": 2584,
    "total_active_users": 943,
    "total_commands": 68,
    "bots": [
      {
        "botid": "1234567",
        "name": "Support Bot",
        "username": "support_bot",
        "status": "working",
        "users": 1250,
        "active_users": 450,
        "commands": 15,
        "points_used": 5432,
        "blocked_users": 12
      },
      {
        "botid": "7654321",
        "name": "Quiz Bot",
        "username": "quiz_master_bot",
        "status": "working",
        "users": 856,
        "active_users": 312,
        "commands": 8,
        "points_used": 2345,
        "blocked_users": 5
      }
    ]
  }
}

get_stats

Retrieves comprehensive account-level statistics.

Account.get_stats()

Example:

stats = Account.get_stats()
if stats["ok"]:
    account_stats = stats["result"]
    Bot.sendMessage(f"Account stats: {account_stats['bots']['total']} bots, {account_stats['users']['total']} users")

Example Output:

{
  "ok": true,
  "result": {
    "email": "[email protected]",
    "plan": "Premium",
    "points_left": 8500,
    "points_used": 23450,
    "points_reset_at": "2023-06-01",
    "account_created": "2022-11-15 09:30:45",
    "bots": {
      "total": 5,
      "botids": ["1234567", "7654321", "2345678", "8765432", "3456789"]
    },
    "users": {
      "total": 2584,
      "active_30d": 943
    },
    "commands": {
      "total": 68
    }
  }
}

Import/Export Methods

export_bot

Exports a bot's configuration and commands as a JSON file.

Account.export_bot(botid)

Parameters:

• botid (Required): ID of the bot to export.

Example:

try:
    file = Account.export_bot("1234567")
    Bot.sendDocument(file)
except ValueError as e:
    Bot.sendMessage(f"Export error: {str(e)}")

Example Output:

# Returns a file-like object that can be directly passed to Bot.sendDocument()
# The file contains a JSON object with the following structure:
# {
#   "bot": {
#     "botid": "1234567",
#     "bot_name": "Support Bot",
#     "bot_username": "support_bot",
#     "creation_date": "2023-05-01 14:30:22",
#     "_export_date": "2023-05-20 10:15:43"
#   },
#   "commands": [
#     {"command": "/start", "code": "Bot.sendMessage('Welcome!')"},
#     {"command": "/help", "code": "Bot.sendMessage('Help info')"}
#   ],
#   "global_data": [
#     {"name": "settings", "data": {"language": "en"}}
#   ],
#   "export_info": {
#     "date": "2023-05-20 10:15:43",
#     "exporter": "[email protected]",
#     "version": "1.0"
#   }
# }

import_bot

Imports a bot from an export file.

Account.import_bot(import_data, new_token=None)

Parameters:

• import_data (Required): The JSON data from an exported bot.

• new_token (Optional): Token for the new bot.

Example:

# Assuming import_data contains valid bot export data
result = Account.import_bot(import_data, "123456789:ABCDEF-ghijklmnopqrstuvwxyz")
if result["ok"]:
    Bot.sendMessage(f"Imported bot with ID: {result['botid']}")

Example Output:

{
  "ok": true,
  "result": "Bot imported successfully",
  "botid": "8765432",
  "command_count": 12
}

API Management

revoke_api

Revokes the current API key and generates a new one.

Account.revoke_api()

Example:

result = Account.revoke_api()
if result["ok"]:
    Bot.sendMessage(f"New API key: {result['api_key']}")

Example Output:

{
  "ok": true,
  "result": "API key revoked successfully and new key generated",
  "api_key": "abcdef1234567890abcdef1234567890"
}

Enhanced Resource Management

New accountRes Class

The 4.8.0 update introduces a new accountRes class for managing account-level resources, complementing the existing resource management system.

res = libs.Resources.accountRes(name)

Parameters:

• name (Required): The name of the resource to manage.

Resource Management Methods

All methods from the BaseRes class are available:

• value(): Gets the current value of the resource.

• add(value): Adds to the resource value.

• cut(value): Subtracts from the resource value.

• set(value): Sets the resource to a specific value.

• reset(): Resets the resource value to zero.

Example:

# Create an account-level resource
account_points = libs.Resources.accountRes("subscription_points")

# Add points
new_value = account_points.add(100)
Bot.sendMessage(f"Added points. New value: {new_value}")

# Check current value
current = account_points.value()
Bot.sendMessage(f"Current points: {current}")

# Use points
account_points.cut(50)
Bot.sendMessage(f"Used 50 points. Remaining: {account_points.value()}")

Example Output:

# For add():
100.0  # Returns the new value after addition

# For value():
100.0  # Returns the current value

# For cut():
50.0  # Returns the new value after subtraction

# For set():
200.0  # Returns the value that was set

# For reset():
0.0  # Always returns zero

Server Improvements

The 4.8.0 update includes significant server-side improvements:

1. Enhanced Stability: Improved error handling and recovery mechanisms to prevent service disruptions.

2. Optimized Performance: Reduced response times and better resource allocation for smoother operation under high load.

3. Improved Webhook Handling: Faster and more reliable webhook processing for better bot responsiveness.

4. Advanced Monitoring: Better monitoring systems to detect and address issues before they affect users.

These improvements ensure that your bots remain operational and responsive, even during peak usage times or when handling complex commands.

Command Aliases

The upcoming UI update will introduce support for command aliases, allowing multiple command triggers to execute the same code. This powerful feature will enable:

1. Multi-language Support: Create different command names for different languages.

2. Command Variations: Support both full and abbreviated versions of commands.

3. Intuitive Interactions: Allow users to trigger commands with natural language variations.

The alias system will be fully integrated into the command management system and accessible through both the UI and API.

Bot Recovery System

The new bot recovery system allows users to recover accidentally deleted bots within 90 days, with features including:

1. Temporary Deletion: Bots are moved to a recovery collection rather than being permanently deleted.

2. 90-Day Recovery Window: Generous timeframe to recover deleted bots.

3. Statistics Tracking: Monitor how many bots you've deleted and how many can be recovered.

4. Expiration Management: Clear visibility into when deleted bots will expire.

Example:

# Get list of deleted bots
deleted_bots = Account.get_deleted_bots()
for bot_info in deleted_bots["result"]:
    Bot.sendMessage(f"Bot: {bot_info['name']}, Days remaining: {bot_info['days_remaining']}")

# Recover a bot
Account.recover_bot("1234567")

# Get stats about deleted bots
stats = Account.get_deleted_bots_stats()
Bot.sendMessage(f"Total deleted: {stats['result']['total']}, Recoverable: {stats['result']['recoverable']}")

Coming Soon Features

Bot Store

The upcoming Bot Store will revolutionize how users discover and implement Telegram bots:

• Pre-made Bot Templates: Access a library of ready-to-use bot templates for various industries and use cases.

• Community Sharing: Share your own bot creations with the TBC community.

• One-Click Deployment: Deploy complete bots with just a single click, without any coding required.

• Categorized Listings: Browse bots by category, popularity, or functionality.

• Custom Modifications: Use templates as starting points and customize them to your specific needs.

This feature will significantly reduce the time and effort needed to create powerful bots, making advanced bot functionality accessible to users of all skill levels.

Points Faucet

The Points Faucet system will ensure that all users have unlimited access to points for running their bots:

• Unlimited Points: Obtain as many points as you need to run your bots without restrictions.

• Completely Free: All points remain 100% free, with no hidden costs or premium tiers.

• Automated System: Request points automatically through the faucet system without needing to contact admins.

• Instant Credits: Points are credited instantly to your account.

• No Usage Limits: Create and run as many bots as you want without worrying about running out of points.

This system reinforces Telebot Creator's commitment to providing a completely free platform for bot creation and hosting.

Both of these features are currently in final development and will be released in an upcoming update. Stay tuned to the TBC announcements channel for release dates and additional information.