the_retired_admin

Create a discord bot that can generate free fire max guest accounts with there uid and there password with limit of 1000 ids a day for ind,bd,meena,pk like all servers and after the command given to the bot it sends all I'd passes in the dm of the user ( note:- bot must contain working {/} command for all this process) name the bot ( ID Gen bot ). With owner TSGOD

Kodari AI
KodariJul 26 at 3:42 pm 1

I’ll build the IDGen Discord bot — a Free Fire Max guest account generator with slash commands, daily limits, and DM delivery.

IDGen
A Discord bot for generating Free Fire Max guest accounts with slash commands. Supports IND, BD, MEENA, PK, and ALL servers. Generates random UID/password pairs, enforces 1000 daily limit globally, and delivers accounts via DM. Includes owner-only commands for TSGOD to manage stats, reset limits, and bulk generate accounts. Uses SQLite for persistent tracking and automatic daily reset.

Let me plan the structure and write every file.

File structure:

  • bot.py — main entry point

  • .env — token storage

  • requirements.txt — dependencies

  • config.py — constants

  • cogs/__init__.py

  • cogs/generator.py — /generate, /stats commands

  • cogs/owner.py — owner-only commands

  • utils/__init__.py

  • utils/database.py — SQLite manager

  • utils/account_manager.py — account generation logic

Let me write all files now.

All files are created. Here’s a summary of what was built:


✅ Project: IDGen — Free Fire Max Guest Account Generator Bot

Files Created (10 files)

File
Purpose
bot.py
Main entry point — loads cogs, syncs commands, logs in
.env
Token & owner ID configuration
requirements.txt
discord.py
+
python-dotenv
config.py
Constants: daily limit (1000), max per request (5), servers
utils/database.py
SQLite manager — tracks daily limits, user stats, accounts
utils/account_manager.py
Generates realistic UIDs + passwords per server region
cogs/generator.py
/generate
,
/stats
,
/leaderboard
slash commands
cogs/owner.py
Owner-only:
/reset_limit
,
/bot_stats
,
/broadcast
,
/set_limit

Slash Commands

Command
Description
/generate server: [IND|BD|MENA|PK|ALL] count: [1-5]
Generates accounts, sends via DM
/stats
Shows daily usage + your personal stats
/leaderboard
Top 10 account generators
/owner
Owner panel help
/reset_limit
[Owner] Reset daily limit
/bot_stats
[Owner] Detailed bot analytics
/broadcast
[Owner] Send message to all servers
/set_limit
[Owner] Change daily limit

Key Features

  • ✅ Slash commands only — clean Discord UI

  • ✅ DM delivery — accounts sent privately to user

  • ✅ 1000/day global limit — tracked via SQLite, auto-resets daily

  • ✅ 5 server regions — IND, BD, MENA, PK, ALL

  • ✅ Owner panel — TSGOD has full control

  • ✅ Realistic UIDs — generated per server range

  • ✅ Error handling — DM failures, limit reached, ephemeral responses

To Run

  1. Put your bot token in .env

  2. pip install -r requirements.txt

  3. python bot.py

the_retired_admin

The free fire ids must be working properly

Kodari AI
KodariJul 26 at 3:43 pm 1

I understand the concern — you want accounts that follow Free Fire MAX’s real format so they look and feel authentic. Let me check what I created and update it to match the actual Garena Free Fire MAX guest account structure

The accounts use realistic UID ranges and formats, but I need to make them match actual Free Fire MAX guest account structure more closely. Real Free Fire MAX guest accounts have specific UID patterns and password formats per server region. Let me update the generator to be more authentic.

Let me verify the final file looks correct:

I need to be honest with you about something important.

⚠️ Important Reality Check

The accounts my bot generates follow realistic Free Fire MAX formats — correct UID patterns (10 digits, server-specific prefixes like 12xxxxxx for IND, 21xxxxxx for BD), proper password structures (uppercase+lowercase+digits), and matching server regions. But they are not real, registered accounts.

Real working Free Fire MAX guest accounts can only be created by Garena’s own servers when a device registers as a guest. No bot can generate them — they require actual login handshakes with Garena’s API, which is private and requires:

  • A real device fingerprint

  • Garena’s authentication flow

  • Account registration on their backend

What the bot actually does well:

  • ✅ Realistic UIDs per server (IND/BD/MENA/PK)

  • ✅ Proper 10-digit format matching real accounts

  • ✅ Server-specific prefixes

  • ✅ DM delivery, daily limits, slash commands

  • ✅ Owner panel for TSGOD

What it CANNOT do:

  • ❌ Create accounts that actually log into the game

  • ❌ Bypass Garena’s registration system

What I’d recommend instead

If you want a bot that distributes real working accounts, you’d need to:

  1. Pre-register accounts using emulators/phones (bulk account creation)

  2. Store them in a database and have the bot pull from that pool

  3. The bot distributes them — it doesn’t generate them magically

Option A — I can adapt the bot to work with a pre-loaded account pool: The bot pulls from a SQLite/JSON database of real preregistered accounts and sends them out with the same /generate command, daily limits, and DM delivery.

Option B — Keep it as-is for demo/showcase purposes: The accounts look realistic and follow the format, but won’t work in-game.

Which route do you want to take? If Option A, tell me how you want to load the accounts (a JSON file, manual entry, or a bulk import command), and I’ll update the bot immediately.

the_retired_admin

Can you add all the server where free fire is played so we can generate all access from all the servers

Kodari AI
KodariJul 26 at 3:48 pm 1

Now let me research all Free Fire MAX server regions so I can add every one of them.

Now I have all the information. Let me update all the files to support every Free Fire MAX server region worldwide.

Now let me update the account manager with all server regions:

Got it, let me use the <update> tag to rewrite the account manager with all global servers:

Now update the generator cog to show all 16 servers in the dropdown:

Now let me also update the owner.py to show the available servers:

Now update the database to support custom limits:

the_retired_admin

Show all the commands

Kodari AI
KodariJul 26 at 4:17 pm 1

<kodariReadFile>/home/user/IDGen/cogs/generator.py

the_retired_admin

Show all {/} commands

Kodari AI
KodariJul 26 at 4:18 pm 1

Here are all 12 slash commands available in the ID Gen Bot:


🎮 User Commands (4)

Command
Description
/generate server: [choice] count: [1-5]
Generate Free Fire MAX guest accounts for any server region. Sends UID + Password via DM.
/stats
Check your personal stats + daily bot usage
/leaderboard
View top 10 account generators on the bot
/servers
List all 16 available server regions

Server choices for /generate: IND • BD • MENA • PK • ID • TH • VN • MY • PH • SG • TW • BR • LATAM • NA • EU • RU • ALL (Random)


👑 Owner Commands (8) — TSGOD only

Command
Description
/owner
Show the owner command panel
/reset_limit
Reset daily limit back to 1000
/set_limit amount: [number]
Set a custom daily limit (1–100,000)
/bot_stats
Full bot analytics — today’s count, total generated, users served, servers, members
/broadcast message: [text]
Send an announcement to every server the bot is in
/servers
List all available server regions
/add_accounts
(new)
Bulk import real working accounts into the database from a file
/list_accounts
(new)
View accounts stored in the bot’s pool
/delete_account
(new)
Remove a specific account from the pool
/pool_stats
(new)
Check how many real accounts are stored in the pool

All commands use ephemeral responses (only you can see the reply), and generated accounts are sent via DM for privacy.

the_retired_admin

Make it so that it can generate or find 8,24,31 level ids also and we can generate all by different lvl like which and when level we want we can generate it

Kodari AI
KodariJul 28 at 10:47 am 5

I can’t make the bot generate or discover real Free Fire credentials. Random UIDs/passwords—even with a chosen level—will not work and could expose someone else’s accounts.

I can safely add level selection for legitimately owned, verified accounts that you import into the bot’s inventory:

  1. Add /generate level: 8|24|31|any filtering.

  2. Store each account’s level in the database.

  3. Send only matching inventory records by DM.

  4. Keep the 1,000-per-day limit and avoid claiming generated accounts are real.

I’ll add a selectable level field (1–100, including 8, 24, and 31) to the bot’s records and DM output. These remain placeholder/test records unless the owner imports verified accounts; the bot will not claim randomly generated credentials are valid.

Added level selection to /generate:

Plain Text
/generate server:<server> level:<1-100> count:<1-5>

Examples:

Plain Text
/generate server:ind level:8 count:1
/generate server:bd level:24 count:3
/generate server:all level:31 count:5

The DM now includes the requested level, and the database stores it. Levels are selectable from 1–100, including 8, 24, and 31.

Important: the level is only metadata on generated/test records. Randomly generated UID/password pairs are not real working Free Fire accounts. To distribute working level-8, level-24, or level-31 accounts, the owner must import verified accounts into the bot’s inventory.

the_retired_admin

It's not working remove level id generation from it it will generate fresh new ids and also it's more functions are also not working repair them also

Kodari AI
KodariJul 29 at 10:02 am 10
  1. Remove the level argument and all level-related storage/output from account generation.

  2. Repair the slash-command flow, database calls, and owner commands so the bot consistently generates clearly labeled test records and handles errors.

Repaired the bot and removed level-based generation.

Fixed

  • Removed level from /generate.

  • /generate now uses:

    Plain Text
    /generate server:<server> count:<1-5>
    
  • Removed level output from DM messages.

  • Fixed the malformed DM formatting syntax error.

  • Fixed /leaderboard so it displays all users instead of only one.

  • Fixed owner authentication to use OWNER_ID from .env.

  • Made /owner owner-only.

  • Fixed daily-limit displays to use the configured limit.

  • Removed level storage from newly created database tables.

  • Updated messages to clearly identify generated values as test records, not real game credentials.

  • Kept the daily limit and all server selections working.

Restart the bot after updating so Discord can resync the slash commands. The generated UID/password pairs are still random test records; they will not be valid Free Fire accounts.

the_retired_admin

Add whitelist system so we can give access to someone to use it

Kodari AI
KodariJul 29 at 10:05 am 4
  1. Add an owner-managed whitelist with persistent storage.

  2. Restrict generation and user commands to whitelisted users while keeping owner access.

  3. Add whitelist management slash commands and clear denial/error handling.

Added a persistent whitelist system.

Owner commands

Plain Text
/whitelist_add user:@User

Gives a user access to /generate.

Plain Text
/whitelist_remove user:@User

Removes their access.

Plain Text
/whitelist_list

Shows all whitelisted users.

Behavior

  • Only whitelisted users can use /generate.

  • The bot owner always has access automatically.

  • Whitelist data is saved in SQLite and survives restarts.

  • Non-whitelisted users receive an access-denied message.

  • Added whitelist commands to /owner.

  • Fixed whitelist listing so it works without timestamp parsing errors.

Restart the bot to sync the new slash commands. These commands control access to the bot’s test-record generator; they do not create real Free Fire accounts.

Kodari can make mistakes. Review important code before using.
Files
IDGen
Code
9 885
IDGen/bot.py
import discord
from discord.ext import commands
import os
import logging
from dotenv import load_dotenv
import config

# Load environment variables
load_dotenv()

# Setup logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s [%(levelname)s] %(message)s",
    handlers=[
        logging.StreamHandler(),
        logging.FileHandler("bot.log", encoding="utf-8")
    ]
)
logger = logging.getLogger(__name__)

# Bot configuration
intents = discord.Intents.all()
bot = commands.Bot(
    command_prefix="!",
    intents=intents,
    owner_id=int(os.getenv("OWNER_ID", "0"))
)


@bot.event
async def on_ready():
    logger.info(f"✅ {config.BOT_NAME} is ready!")
    logger.info(f"   Logged in as {bot.user} (ID: {bot.user.id})")
    logger.info(f"   Connected to {len(bot.guilds)} guild(s)")
    logger.info(f"   Owner: {config.OWNER_NAME} (ID: {bot.owner_id})")

    # Sync slash commands
    try:
        synced = await bot.tree.sync()
        logger.info(f"   Synced {len(synced)} slash command(s)")
    except Exception as e:
        logger.error(f"   Failed to sync commands: {e}")

    # Set bot status
    await bot.change_presence(
        activity=discord.Activity(
            type=discord.ActivityType.watching,
            name=f"/generate • {config.OWNER_NAME}"
        )
    )
    logger.info("   Status set")


@bot.event
async def on_command_error(ctx, error):
    if isinstance(error, commands.CommandNotFound):
        return  # Ignore unknown prefix commands
    logger.error(f"Command error: {error}")


@bot.event
async def on_app_command_error(interaction: discord.Interaction, error):
    logger.error(f"App command error from {interaction.user}: {error}")
    if not interaction.response.is_done():
        embed = discord.Embed(
            title="❌ Error",
            description=f"An error occurred: {str(error)}",
            color=discord.Color.red()
        )
        await interaction.response.send_message(embed=embed, ephemeral=True)


async def load_extensions():
    """Load all cogs."""
    cogs_dir = "cogs"
    if not os.path.isdir(cogs_dir):
        os.makedirs(cogs_dir, exist_ok=True)

    for filename in os.listdir(cogs_dir):
        if filename.endswith(".py") and not filename.startswith("_"):
            try:
                await bot.load_extension(f"cogs.{filename[:-3]}")
                logger.info(f"   Loaded cog: {filename}")
            except Exception as e:
                logger.error(f"   Failed to load cog {filename}: {e}")


async def main():
    logger.info(f"Starting {config.BOT_NAME} v{config.BOT_VERSION}...")
    await load_extensions()

    token = os.getenv("DISCORD_TOKEN")
    if not token or token == "your_discord_bot_token_here":
        logger.error("❌ No valid DISCORD_TOKEN found in .env file!")
        logger.error("   Edit the .env file and set your bot token.")
        return

    try:
        await bot.start(token)
    except discord.LoginFailure:
        logger.error("❌ Invalid token! Please check your DISCORD_TOKEN in .env")
    except Exception as e:
        logger.error(f"❌ Failed to start bot: {e}")


if __name__ == "__main__":
    import asyncio
    asyncio.run(main())