const channels = [
  "@Mrnull9"
]

const ik = [];

for (const c of channels) {
  ik.push([
    {
      text: "Join to " + c,
      url: "tg://resolve?domain=" + c.slice(1)
    }
  ]);
}

ik.push([
  {
    text: "I Joined",
    callback_data: "check_join"
  }
]);

Api.sendMessage({
  text: "Please join our channel to continue.*\n\n_Join first, then tap “I Joined”._",
  reply_markup: {
    inline_keyboard: ik
  }
});

const ik = []; // again???
const res = await Libs.mcl.check(user.id, channels);
const allJoined = res.all_joined;

const text = allJoined
  ? "*Verification Complete!*\n\n_You may continue now._"
  : "*You have not joined yet.*\n\n_Please join first, then tap “Check Again”._";

for (const c of channels) {
  ik.push([
    {
      text: "Join to " + c,
      url: "tg://resolve?domain=" + c.slice(1)
    }
  ]);
}

ik.push([
  {
    text: "Check again",
    callback_data: "check_join"
  }
]);

Api.editMessageText({
  text,
  message_id: request?.message?.message_id,
  parse_mode: "Markdown",
  reply_markup: {
    inline_keyboard: !allJoined ? ik : undefined 
  }
});

Api.call("getChat", {
  chat_id: -1007657565746
})

✅ Free hosting platform
✅ Bot runs 24×7
✅ No VPS, no server tension
✅ Beginner-friendly

It is an AI assistant designed specially for:
• Telegram Bot Development 
• TeleBot Lang (TBL) 
• Automation & Bot Logic 

// /emojiid command handler
if (!params) {
  Api.sendMessage({
    text: "❗ <b>Usage</b>:\n<code>/emojiid &lt;message with premium emoji&gt;</code>",
    parse_mode: "HTML"
  });
  return;
}

let text = "❌ No premium/custom emojis found.";

// Check entities
if (request.entities && Array.isArray(request.entities)) {

  let ids = [];

  for (const entity of request.entities) {
    if (
      entity.type === "custom_emoji" &&
      entity.custom_emoji_id
    ) {
      ids.push(entity.custom_emoji_id);
    }
  }

  if (ids.length > 0) {
    text = "🆔 <b>Premium Emoji IDs</b>:\n\n";

    ids.forEach(id => {
      text += `<tg-emoji emoji-id="${id}"></tg-emoji>  <code>${id}</code>\n`;
    });

    text += "\n📌 <b>Usage</b>:\n";
    text += "<b>HTML:</b>\n";
    text += `<code>&lt;tg-emoji emoji-id="EMOJI_ID"&gt;&lt;/tg-emoji&gt;</code>\n\n`;

    text += "<b>MarkdownV2:</b>\n";
    text += `<code>![emoji](tg://emoji?id=EMOJI_ID)</code>`;
  }
}

Api.sendMessage({
  text: text,
  parse_mode: "HTML"
});

// custom emoji ID
const EMOJI_ID = "5474667187258006816"

Api.sendMessage({
  text: "<b>🔥 New Button UI</b>\n\nInline + Keyboard colors & icons",
  parse_mode: "HTML",
  reply_markup: {
    inline_keyboard: [

      // Row 1
      [
        { text: "Normal", callback_data: "*" },
        { text: "Primary", callback_data: "*", style: "primary" }
      ],

      // Row 2
      [
        { text: "Success", callback_data: "*", style: "success" },
        { text: "Danger", callback_data: "*", style: "danger" }
      ],

      // Row 3 (Icon)
      [
        {
          text: "Icon Button",
          callback_data: "*",
          icon_custom_emoji_id: EMOJI_ID
        }
      ]
    ]
  }
})


// ---------- KEYBOARD ----------

Api.sendMessage({
  chat_id: chat.id,
  text: "⌨️ Keyboard Button Test",
  reply_markup: {
    keyboard: [

      [
        { text: "Normal KB" },
        { text: "Primary KB", style: "primary" }
      ],

      [
        { text: "Success KB", style: "success" },
        { text: "Danger KB", style: "danger" }
      ],

      [
        {
          text: "Icon KB",
          icon_custom_emoji_id: EMOJI_ID
        }
      ]
    ],
    resize_keyboard: true
  }
})

let res = await HTTP.get(
  "https://telebothost.com/logo.png",
  {
    headers: {
      "x-response-type": "buffer"
    }
  }
);

const buffer = res.data;

Api.setChatPhoto({
//chat_id: "id" , //default is current chat
  photo: buffer,
});

//Use the all event Lister commnad * 

const ADMIN_ID = 5723455420;

function getOriginalUserIdByMessageId(messageId) {
  let hiddenUserId = Bot.get("pvt" + messageId);
  return hiddenUserId;
}

if(!msg) return;
if(chat.type != "private") return;
// to ensure that it's a message update and private chat

//forward any message from user to admin
if(chat.id != ADMIN_ID) {
  let forwardResult = await Api.forwardMessage({
    chat_id: ADMIN_ID,
    from_chat_id: chat.id,
    message_id: msg.message_id //msg is update.message
  });
  
  if(forwardResult?.result?.forward_origin?.type == "hidden_user") {
    // Logic: When user has privacy mode enabled (hidden_user), 
    // store mapping between forwarded message ID and original user ID
    // This allows admin to reply to hidden users by referencing the stored ID
    Bot.set("pvt" + forwardResult?.result?.message_id, user.id);
  }
  
  msg.reply("*✅ Message successfully sent to Admin*");
}

if(chat.id == ADMIN_ID && request?.reply_to_message) {
  
  // if admin reply to forwarded message, send copy to user
  let originalChatId = request.reply_to_message?.forward_from?.id || 
                       getOriginalUserIdByMessageId(request.reply_to_message.message_id);
  
  Api.copyMessage({
    chat_id: originalChatId,
    from_chat_id: ADMIN_ID,
    message_id: msg.message_id
  });
}

let query = message

if (!query) {
  Bot.sendMessage("Please enter a search query.")
  return
}

User.set("q", query, "string")

let res = await HTTP.post({
  url: "https://pinterest-api-bay.vercel.app/v5/pins/search",
  body: {
    query: query,
    count: 10,
    compact: true
  }
})

if (!res.ok) {
  Bot.sendMessage("Request failed. Please try again later.")
  return
}

let data

try {
  data = res.data
} catch (e) {
  Bot.sendMessage("Failed to parse response.")
  return
}

if (!data.items || data.items.length === 0) {
  Bot.sendMessage("No results found.")
  return
}

let savedQuery = User.get("q") || "Result"
let botName = bot.name

for (let i = 0; i < data.items.length; i++) {
  let item = data.items[i]

  let title = item.title ? item.title : savedQuery
  let image = item.image
  let link = item.url ? item.url : ""

  let buttons = []

  if (link) {
    buttons.push([{ text: "View on Pinterest", url: link }])
  }

  buttons.push([{ text: "Copy Image URL", copy_text: { text: image } }])

  let caption =
    "<b>" + title + "</b>\n" +
    "<i>Query:</i> " + savedQuery + "\n" +
    "<i>Searched by:</i> @" + botName

  await Api.sendPhoto({
    chat_id: user.telegramid,
    photo: image,
    caption: caption,
    parse_mode: "HTML",
    disable_web_page_preview: true,
    reply_markup: {
      inline_keyboard: buttons
    }
  })
}

const GROQ_API_KEY =
  "Api_Key"

const MODEL =
  "llama-3.1-8b-instant"

const TOKEN = bot.token

async function editInline(id, text) {

  return await HTTP.post({
    url:
      "https://api.telegram.org/bot" +
      TOKEN +
      "/editMessageText",

    body: {
      inline_message_id: id,
      text: text
    }
  })

}

if (update.chosen_inline_result) {

  try {

    let query =
      update.chosen_inline_result.query

    let inlineMessageId =
      update.chosen_inline_result.inline_message_id

    if (!query || !inlineMessageId)
      return

    await editInline(
      inlineMessageId,
      "Thinking..."
    )

    let ai = await HTTP.post({

      url:
        "https://api.groq.com/openai/v1/chat/completions",

      headers: {
        Authorization:
          "Bearer " +
          GROQ_API_KEY
      },

      body: {
        model: MODEL,

        messages: [
          {
            role: "user",
            content: query
          }
        ]
      }

    })

    let reply =
      ai.data.choices[0].message.content

    await editInline(
      inlineMessageId,
      reply || "No response"
    )

  } catch (e) {

    await editInline(
      update.chosen_inline_result
        .inline_message_id,
      "API Error"
    )

  }

}

try {

  let query = request.query

  if (!query || query.trim() === "") {

    return await Api.answerInlineQuery({
      inline_query_id: request.id,
      results: [],
      cache_time: 1
    })

  }

  query = query.slice(0, 256)

  await Api.answerInlineQuery({

    inline_query_id: request.id,

    cache_time: 1,

    is_personal: true,

    results: [
      {
        type: "article",

        id: String(Date.now()),

        title: "Ask AI",

        description: query,

        input_message_content: {
          message_text: "Thinking... ▌"
        },

        reply_markup: {
          inline_keyboard: [
            [
              {
                text: "⬤",
                callback_data: "loading"
              }
            ]
          ]
        }

      }
    ]

  })

} catch (e) {}

TBH Helper Ai is a Expert:
• TeleBot Lang (TBL) 
• trained on TBH Docs docs.telebothost.com

/* Command: /ephemeral */

// Get target user and chat info
let targetUserId = user.id;
let groupId = chat.id;
let userName = user.first_name || "User";

// 1. Send Ephemeral Text Message
await Api.sendMessage({
  chat_id: groupId,
  text: "🎯 This message is only visible to you, " + userName + "!",
  receiver_user_id: targetUserId,
  parse_mode: "HTML"
});

// 2. Send Ephemeral Photo
await Api.sendPhoto({
  chat_id: groupId,
  photo: "https://telegram.org/img/t_logo.png",
  caption: "📸 <b>Private Photo</b>\n\nOnly you can see this!",
  receiver_user_id: targetUserId,
  parse_mode: "HTML"
});

// 3. Send Ephemeral Sticker
await Api.sendSticker({
  chat_id: groupId,
  sticker: "CAACAgIAAxkBAAIxM2pbn6j6YZCWRUsSdh6sen7nBmJbAAL8HgACuNHQSheZ4BUjnIebPQQ",
  receiver_user_id: targetUserId
});

// Command: * or /handle_guest_message 

if (!update.guest_message) return

let msg = update.guest_message
let userText = msg.text || ""

if (!msg.text) return

// User info from global `user` object
let fullName = user.full_name || user.first_name || "User"
let userId = user.id || "Unknown"
let username = user.username ? "@" + user.username : "Not set"
let language = user.language_code || "Unknown"
let isBot = user.is_bot ? "Yes" : "No"
let isPremium = user.is_premium ? "✅ Yes" : "❌ No"

// Fetch profile photos
let photoFileIds = []
let mediaItems = []
let photoHtml = ""

try {
  let photos = await Api.getUserProfilePhotos({
    user_id: userId,
    limit: 50
  })
  
  if (photos.ok && photos.result && photos.result.photos && photos.result.photos.length > 0) {
    let allPhotos = photos.result.photos
    let maxPhotos = Math.min(allPhotos.length, 50)
    
    for (let i = 0; i < maxPhotos; i++) {
      let photo = allPhotos[i]
      if (photo && photo.length > 0) {
        let fileId = photo[photo.length - 1].file_id
        let mediaId = "photo_" + i
        photoFileIds.push(fileId)
        
        mediaItems.push({
          id: mediaId,
          media: {
            type: "photo",
            media: fileId
          }
        })
      }
    }
    
    if (photoFileIds.length > 0) {
      let slideshowImages = photoFileIds.map(function(id, index) {
        return '<img src="tg://photo?id=photo_' + index + '"/>'
      }).join('\n  ')
      
      let captionText = photoFileIds.length === 1 
        ? "📸 1 profile photo" 
        : "📸 " + photoFileIds.length + " profile photos"
      
      photoHtml = `
<tg-slideshow>
  ${slideshowImages}
  <figcaption>${captionText}</figcaption>
</tg-slideshow>
`
    }
  }
} catch (e) {
  photoHtml = `<p><i>Could not fetch profile photos</i></p>`
}

if (!photoFileIds.length) {
  photoHtml = `<p><i>No profile photos found</i></p>`
}

// Build rich message
let profileHtml = `
<details>
<summary><b>👤 User Info — ${fullName}</b></summary>

<h2>Basic Info</h2>
<ul>
  <li><b>ID:</b> <code>${userId}</code></li>
  <li><b>Name:</b> ${fullName}</li>
  <li><b>Username:</b> ${username}</li>
  <li><b>Language:</b> ${language}</li>
</ul>

<h2>Status</h2>
<ul>
  <li><b>Bot:</b> <code>${isBot}</code></li>
  <li><b>Premium:</b> <code>${isPremium}</code></li>
</ul>

${photoHtml}

</details>
`

let richMessage = {
  html: profileHtml
}

if (mediaItems.length > 0) {
  richMessage.media = mediaItems
}

await Api.call("answerGuestQuery", {
  guest_query_id: msg.guest_query_id,
  result: JSON.stringify({
    type: "article",
    id: String(Date.now()),
    title: "👤 User Info",
    input_message_content: {
      rich_message: richMessage
    }
  })
})