Letgram Bot API

The Letgram Bot API allows you to build bots that interact with users through the Letgram messaging platform. Bots are special accounts operated by software, capable of responding to messages, managing groups, processing payments, running inline queries, and much more.

What are bots?

Bots are third-party applications that run inside Letgram. Users can interact with bots by sending them messages, commands, and inline requests. Bot developers can use the Letgram Bot API to send text messages, media, keyboards, and more in response.

Bots can:

• Send and receive messages in private chats, groups, and channels
• Provide custom keyboards and inline buttons
• Accept payments from users
• Run Mini Apps (Web Apps) inside the Letgram client
• Respond to inline queries from any chat
• Post, edit, and delete stories
• Manage group and channel settings

How to create a bot

To create a new bot, start a conversation with @BotGod in Letgram. Send the command /newbot and follow the instructions. You will receive an API token that authenticates your bot and grants access to the Bot API.

Other useful commands for @BotGod:

• /mybots — list your bots
• /setname — change bot display name
• /setdescription — change bot description
• /setabouttext — change bot about info
• /setuserpic — change bot profile photo
• /setcommands — set command list
• /deletebot — delete a bot
• /token — generate a new token
• /revoke — revoke current token

Authentication

Each bot is identified by a unique token in the format:

123456789:ABCDefgh-IJKLmnop_QRSTuvwxyz1234567

The token is a string composed of the bot's numeric ID, a colon, and a random alphanumeric string. Keep your token secure — anyone with the token can control your bot.

Making Requests

All API requests are made via HTTPS POST or GET to:

https://api.letgram.ru/bot<token>/METHOD_NAME

Parameters can be passed as:

• URL query string
• application/x-www-form-urlencoded
• application/json (except for file uploads)
• multipart/form-data (required for file uploads)

All method names are case-insensitive.

Example request

curl -X POST "https://api.letgram.ru/bot123456:ABC-DEF/sendMessage" \
  -H "Content-Type: application/json" \
  -d '{"chat_id": 12345, "text": "Hello from Letgram!"}'

import requests

TOKEN = "123456:ABC-DEF"
url = f"https://api.letgram.ru/bot{TOKEN}/sendMessage"

response = requests.post(url, json={
    "chat_id": 12345,
    "text": "Hello from Letgram!"
})
print(response.json())

const TOKEN = "123456:ABC-DEF";

const res = await fetch(
  `https://api.letgram.ru/bot${TOKEN}/sendMessage`,
  {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      chat_id: 12345,
      text: "Hello from Letgram!"
    })
  }
);
const data = await res.json();
console.log(data);

Response Format

All responses are JSON objects. A successful response has the following structure:

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

An error response:

{
  "ok": false,
  "error_code": 400,
  "description": "Bad Request: chat not found"
}

The result field contains the response data. Its type depends on the method called. The error_code field corresponds to HTTP status codes.

Getting Updates

There are two ways to receive updates from Letgram: long polling via getUpdates, or webhooks via setWebhook. Only one method can be active at a time.

getUpdates

Use this method to receive incoming updates using long polling. Returns an Array of Update objects.

curl "https://api.letgram.ru/bot<token>/getUpdates?timeout=30&offset=0"

response = requests.get(f"https://api.letgram.ru/bot{TOKEN}/getUpdates", params={
    "timeout": 30,
    "offset": 0
})

const res = await fetch(
  `https://api.letgram.ru/bot${TOKEN}/getUpdates?timeout=30&offset=0`
);
const updates = await res.json();

setWebhook

Use this method to specify a URL and receive incoming updates via an outgoing webhook. Whenever there is an update, Letgram will send an HTTPS POST request to the specified URL containing a JSON-serialized Update. Returns True on success.

deleteWebhook

Use this method to remove webhook integration. Returns True on success.

getWebhookInfo

Use this method to get current webhook status. Requires no parameters. Returns a WebhookInfo object.

The WebhookInfo object contains fields: url, has_custom_certificate, pending_update_count, ip_address, last_error_date, last_error_message, last_synchronization_error_date, max_connections, allowed_updates.

Update Object

This object represents an incoming update. At most one of the optional parameters can be present in any given update.

Available Types

All types used in the Bot API are described below. Optional fields may not be present in every object.

User

This object represents a Letgram user or bot.

Chat

This object represents a chat.

Message

This object represents a message.

MessageEntity

This object represents one special entity in a text message (hashtag, username, URL, etc.).

Media Types

PhotoSize

Audio

Document

Video

Animation

Voice

VideoNote

Contact, Location, Venue

Contact

Location

Venue

Poll

PollOption

Keyboards

InlineKeyboardMarkup

This object represents an inline keyboard that appears right next to the message it belongs to.

InlineKeyboardButton

ReplyKeyboardMarkup

This object represents a custom keyboard with reply options.

KeyboardButton

ReplyKeyboardRemove

Removes the current custom keyboard and displays the default letter-keyboard.

CallbackQuery

WebApp Types

WebAppInfo

WebAppData

Available Methods

getMe

A simple method for testing your bot's authentication token. Requires no parameters. Returns basic information about the bot in form of a User object.

curl "https://api.letgram.ru/bot<token>/getMe"

response = requests.get(f"https://api.letgram.ru/bot{TOKEN}/getMe")
print(response.json())

const res = await fetch(`https://api.letgram.ru/bot${TOKEN}/getMe`);
const me = await res.json();

logOut

Use this method to log out from the cloud Bot API server. Returns True on success. You must log out the bot before running it locally.

close

Use this method to close the bot instance. Returns True on success. Use before moving a bot from one local server to another.

sendMessage

Use this method to send text messages. On success, the sent Message is returned.

curl -X POST "https://api.letgram.ru/bot<token>/sendMessage" \
  -H "Content-Type: application/json" \
  -d '{
    "chat_id": 12345678,
    "text": "Hello! This is a *bold* message with an [inline link](https://letgram.ru)",
    "parse_mode": "MarkdownV2"
  }'

import requests

TOKEN = "YOUR_BOT_TOKEN"
url = f"https://api.letgram.ru/bot{TOKEN}/sendMessage"

response = requests.post(url, json={
    "chat_id": 12345678,
    "text": "Hello! This is a bold message",
    "parse_mode": "HTML",
    "reply_markup": {
        "inline_keyboard": [[
            {"text": "Visit Letgram", "url": "https://letgram.ru"},
            {"text": "Click me", "callback_data": "btn_click"}
        ]]
    }
})
print(response.json())

const TOKEN = "YOUR_BOT_TOKEN";

const res = await fetch(`https://api.letgram.ru/bot${TOKEN}/sendMessage`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    chat_id: 12345678,
    text: "Hello! This is a bold message",
    parse_mode: "HTML",
    reply_markup: {
      inline_keyboard: [[
        { text: "Visit Letgram", url: "https://letgram.ru" },
        { text: "Click me", callback_data: "btn_click" }
      ]]
    }
  })
});
console.log(await res.json());

forwardMessage

Use this method to forward messages of any kind. On success, the sent Message is returned.

copyMessage

Use this method to copy messages of any kind. The method is analogous to forwardMessage, but the copied message doesn't have a link to the original. Returns the MessageId of the sent message.

Send Media

sendPhoto

Use this method to send photos. On success, the sent Message is returned.

# Send photo by URL
curl -X POST "https://api.letgram.ru/bot<token>/sendPhoto" \
  -H "Content-Type: application/json" \
  -d '{"chat_id": 12345678, "photo": "https://example.com/photo.jpg", "caption": "Beautiful photo!"}'

# Upload photo file
curl -X POST "https://api.letgram.ru/bot<token>/sendPhoto" \
  -F "chat_id=12345678" \
  -F "photo=@/path/to/photo.jpg" \
  -F "caption=Uploaded photo!"

# Send by URL
requests.post(f"https://api.letgram.ru/bot{TOKEN}/sendPhoto", json={
    "chat_id": 12345678,
    "photo": "https://example.com/photo.jpg",
    "caption": "Beautiful photo!"
})

# Upload file
with open("photo.jpg", "rb") as f:
    requests.post(f"https://api.letgram.ru/bot{TOKEN}/sendPhoto",
        data={"chat_id": 12345678, "caption": "Uploaded!"},
        files={"photo": f}
    )

// Send by URL
await fetch(`https://api.letgram.ru/bot${TOKEN}/sendPhoto`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    chat_id: 12345678,
    photo: "https://example.com/photo.jpg",
    caption: "Beautiful photo!"
  })
});

sendAudio

Use this method to send audio files (mp3 format, up to 50 MB). On success, the sent Message is returned. For voice messages, use sendVoice instead.

sendDocument

Use this method to send general files (up to 50 MB). On success, the sent Message is returned.

sendVideo

Use this method to send video files (up to 50 MB). On success, the sent Message is returned.

sendAnimation

Use this method to send animation files (GIF or H.264/MPEG-4 AVC video without sound, up to 50 MB). On success, the sent Message is returned.

sendVoice

Use this method to send audio files as a playable voice message (OPUS in OGG container, up to 50 MB). On success, the sent Message is returned.

sendVideoNote

Use this method to send video messages (round videos, up to 1 minute). On success, the sent Message is returned.

sendSticker

Use this method to send static .WEBP, animated .TGS, or video .WEBM stickers. On success, the sent Message is returned.

sendMediaGroup

Use this method to send a group of photos, videos, documents, or audios as an album. On success, an Array of Messages is returned.

sendLocation

Use this method to send a point on the map. On success, the sent Message is returned.

sendVenue

Use this method to send information about a venue. On success, the sent Message is returned.

sendContact

Use this method to send phone contacts. On success, the sent Message is returned.

sendPoll

Use this method to send a native poll. On success, the sent Message is returned.

sendDice

Use this method to send an animated emoji that will display a random value. On success, the sent Message is returned.

sendChatAction

Use this method to tell the user that something is happening on the bot's side. The status is set for 5 seconds or less. Returns True on success.

User & Files

getUserProfilePhotos

Use this method to get a list of profile pictures for a user. Returns a UserProfilePhotos object.

getFile

Use this method to get basic information about a file and prepare it for downloading. The file can then be downloaded from https://api.letgram.ru/file/bot<token>/<file_path>. Files up to 20 MB in size can be downloaded.

# Step 1: Get file path
curl "https://api.letgram.ru/bot<token>/getFile?file_id=AgACAgIA..."

# Step 2: Download the file
curl "https://api.letgram.ru/file/bot<token>/photos/file_0.jpg" -o downloaded.jpg

# Get file info
file_info = requests.get(f"https://api.letgram.ru/bot{TOKEN}/getFile",
    params={"file_id": "AgACAgIA..."}).json()

# Download
file_path = file_info["result"]["file_path"]
file_data = requests.get(f"https://api.letgram.ru/file/bot{TOKEN}/{file_path}")
with open("downloaded.jpg", "wb") as f:
    f.write(file_data.content)

// Get file info
const info = await fetch(
  `https://api.letgram.ru/bot${TOKEN}/getFile?file_id=AgACAgIA...`
).then(r => r.json());

// Download
const filePath = info.result.file_path;
const fileData = await fetch(
  `https://api.letgram.ru/file/bot${TOKEN}/${filePath}`
).then(r => r.blob());

Chat Administration

banChatMember

Use this method to ban a user in a group, supergroup, or channel. The bot must be an administrator with the appropriate rights. Returns True on success.

unbanChatMember

Use this method to unban a previously banned user in a supergroup or channel. Returns True on success.

restrictChatMember

Use this method to restrict a user in a supergroup. The bot must be an administrator with can_restrict_members rights. Returns True on success.

promoteChatMember

Use this method to promote or demote a user in a supergroup or channel. Returns True on success.

setChatTitle

Use this method to change the title of a chat. Returns True on success.

setChatDescription

Use this method to change the description of a group, supergroup, or channel. Returns True on success.

setChatPhoto

Use this method to set a new profile photo for the chat. Returns True on success.

pinChatMessage

Use this method to add a message to the list of pinned messages in a chat. Returns True on success.

unpinChatMessage

Use this method to remove a message from the list of pinned messages. Returns True on success.

Chat Info

leaveChat

Use this method for your bot to leave a group, supergroup, or channel. Returns True on success.

getChat

Use this method to get up-to-date information about the chat. Returns a Chat object.

getChatAdministrators

Use this method to get a list of administrators in a chat (non-bots). Returns an Array of ChatMember objects.

getChatMemberCount

Use this method to get the number of members in a chat. Returns Integer.

getChatMember

Use this method to get information about a member of a chat. Returns a ChatMember object.

Bot Commands

setMyCommands

Use this method to change the list of the bot's commands. Returns True on success.

curl -X POST "https://api.letgram.ru/bot<token>/setMyCommands" \
  -H "Content-Type: application/json" \
  -d '{
    "commands": [
      {"command": "start", "description": "Start the bot"},
      {"command": "help", "description": "Show help message"},
      {"command": "settings", "description": "Open settings"}
    ]
  }'

requests.post(f"https://api.letgram.ru/bot{TOKEN}/setMyCommands", json={
    "commands": [
        {"command": "start", "description": "Start the bot"},
        {"command": "help", "description": "Show help message"},
        {"command": "settings", "description": "Open settings"}
    ]
})

await fetch(`https://api.letgram.ru/bot${TOKEN}/setMyCommands`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    commands: [
      { command: "start", description: "Start the bot" },
      { command: "help", description: "Show help message" },
      { command: "settings", description: "Open settings" }
    ]
  })
});

getMyCommands

Use this method to get the current list of the bot's commands. Returns an Array of BotCommand.

deleteMyCommands

Use this method to delete the list of the bot's commands for the given scope and language. Returns True on success.

Editing Messages

editMessageText

Use this method to edit text and game messages. On success, if the edited message is not an inline message, the edited Message is returned.

editMessageCaption

Use this method to edit captions of messages. On success, if the edited message is not an inline message, the edited Message is returned.

editMessageReplyMarkup

Use this method to edit only the reply markup of messages. On success, if the edited message is not an inline message, the edited Message is returned.

deleteMessage

Use this method to delete a message. The bot must have the appropriate rights. Returns True on success.

answerCallbackQuery

Use this method to send answers to callback queries sent from inline keyboards. On success, True is returned.

curl -X POST "https://api.letgram.ru/bot<token>/answerCallbackQuery" \
  -H "Content-Type: application/json" \
  -d '{"callback_query_id": "123456789", "text": "Button clicked!", "show_alert": false}'

requests.post(f"https://api.letgram.ru/bot{TOKEN}/answerCallbackQuery", json={
    "callback_query_id": callback_query.id,
    "text": "Button clicked!",
    "show_alert": False
})

await fetch(`https://api.letgram.ru/bot${TOKEN}/answerCallbackQuery`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    callback_query_id: callbackQuery.id,
    text: "Button clicked!",
    show_alert: false
  })
});

Inline Mode

Bots can be called from any chat via inline queries. Users type @botusername query in the text input field, and the bot receives the query and returns results that appear in a dropdown above the text field. When the user selects a result, it is sent to the chat.

To enable inline mode, send the /setinline command to @BotGod and provide a placeholder text that will be shown in the input field when the user types the bot's name.

InlineQuery

This object represents an incoming inline query. When the user sends an empty query, your bot could return some default or trending results.

answerInlineQuery

Use this method to send answers to an inline query. No more than 50 results per query are allowed. Returns True on success.

curl -X POST "https://api.letgram.ru/bot<token>/answerInlineQuery" \
  -H "Content-Type: application/json" \
  -d '{
    "inline_query_id": "query123",
    "results": [
      {
        "type": "article",
        "id": "1",
        "title": "Result Title",
        "input_message_content": {
          "message_text": "This is the result message"
        },
        "description": "A short description"
      }
    ]
  }'

requests.post(f"https://api.letgram.ru/bot{TOKEN}/answerInlineQuery", json={
    "inline_query_id": inline_query.id,
    "results": [
        {
            "type": "article",
            "id": "1",
            "title": "Result Title",
            "input_message_content": {
                "message_text": "This is the result message"
            },
            "description": "A short description"
        }
    ],
    "cache_time": 60
})

await fetch(`https://api.letgram.ru/bot${TOKEN}/answerInlineQuery`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    inline_query_id: inlineQuery.id,
    results: [{
      type: "article",
      id: "1",
      title: "Result Title",
      input_message_content: {
        message_text: "This is the result message"
      },
      description: "A short description"
    }],
    cache_time: 60
  })
});

InlineQueryResult Types

The following types of InlineQueryResult are supported:

• InlineQueryResultArticle — A link to an article or web page.
• InlineQueryResultPhoto — A link to a photo. The photo must be in JPEG format.
• InlineQueryResultGif — A link to an animated GIF file.
• InlineQueryResultMpeg4Gif — A link to a video animation (H.264/MPEG-4 AVC without sound).
• InlineQueryResultVideo — A link to a page containing an embedded video player or a video file.
• InlineQueryResultAudio — A link to an MP3 audio file.
• InlineQueryResultVoice — A link to a voice recording in an OGG container.
• InlineQueryResultDocument — A link to a file (PDF or ZIP).
• InlineQueryResultLocation — A location on a map.
• InlineQueryResultVenue — A venue with location.
• InlineQueryResultContact — A contact with a phone number.
• InlineQueryResultGame — A Game.
• InlineQueryResultCachedPhoto — A photo stored on the Letgram servers.
• InlineQueryResultCachedGif — A GIF stored on the Letgram servers.
• InlineQueryResultCachedMpeg4Gif — An MPEG4 GIF stored on the Letgram servers.
• InlineQueryResultCachedSticker — A sticker stored on the Letgram servers.
• InlineQueryResultCachedDocument — A document stored on the Letgram servers.
• InlineQueryResultCachedVideo — A video stored on the Letgram servers.
• InlineQueryResultCachedVoice — A voice note stored on the Letgram servers.
• InlineQueryResultCachedAudio — An audio file stored on the Letgram servers.

All InlineQueryResult types share common fields: type (String), id (String, up to 64 bytes), and optionally reply_markup (InlineKeyboardMarkup). Each type also has its own specific fields. See the individual type definitions for details.

Mini Apps (Web Apps)

Mini Apps allow bots to present rich, interactive web interfaces to users directly within the Letgram client. They run as embedded web pages with full access to HTML5, CSS, and JavaScript, and can communicate with the Letgram client through a dedicated JavaScript SDK.

Launching a Mini App

There are several ways to launch a Mini App:

• Keyboard button — Add a web_app field to a KeyboardButton
• Inline button — Add a web_app field to an InlineKeyboardButton
• Bot Menu Button — Configure via @BotGod with /setmenubutton
• Inline mode — Return a button with a web_app field in inline query results
• Direct link — https://letgram.ru/botusername/app

Letgram JS SDK Reference

Include the Letgram JS SDK in your Mini App:

<script src="https://letgram.ru/js/webapp.js"></script>

Once loaded, a window.Letgram.WebApp object becomes available.

WebApp Object

MainButton

BackButton

HapticFeedback

Events

The Mini App can subscribe to events from the Letgram client using Letgram.WebApp.onEvent(eventType, callback):

initData Format

The init data is a query string that contains the following fields:

Example Mini App

<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>My Mini App</title>
  <script src="https://letgram.ru/js/webapp.js"></script>
  <style>
    body {
      font-family: -apple-system, sans-serif;
      background: var(--tg-theme-bg-color, #fff);
      color: var(--tg-theme-text-color, #000);
      padding: 20px;
    }
    .btn {
      background: var(--tg-theme-button-color, #6B5CD9);
      color: var(--tg-theme-button-text-color, #fff);
      border: none;
      padding: 12px 24px;
      border-radius: 8px;
      font-size: 16px;
      cursor: pointer;
    }
  </style>
</head>
<body>
  <h1>Welcome to My Mini App</h1>
  <p>Hello, <span id="name"></span>!</p>
  <button class="btn" onclick="submitData()">Submit</button>

  <script>
    const webapp = window.Letgram.WebApp;
    webapp.ready();
    webapp.expand();

    // Display user name
    const user = webapp.initDataUnsafe.user;
    if (user) {
      document.getElementById("name").textContent = user.first_name;
    }

    // Configure main button
    webapp.MainButton.setText("Confirm");
    webapp.MainButton.show();
    webapp.MainButton.onClick(() => {
      webapp.sendData(JSON.stringify({ action: "confirmed" }));
    });

    // Back button
    webapp.BackButton.show();
    webapp.BackButton.onClick(() => {
      webapp.close();
    });

    // Haptic feedback on button click
    function submitData() {
      webapp.HapticFeedback.impactOccurred("medium");
      webapp.showAlert("Data submitted successfully!");
    }
  </script>
</body>
</html>

Payments

Letgram bots can accept payments from users. The payment flow involves sending an invoice, handling shipping queries (if applicable), and confirming pre-checkout queries.

sendInvoice

Use this method to send invoices. On success, the sent Message is returned.

curl -X POST "https://api.letgram.ru/bot<token>/sendInvoice" \
  -H "Content-Type: application/json" \
  -d '{
    "chat_id": 12345678,
    "title": "Premium Subscription",
    "description": "Monthly premium access",
    "payload": "premium_monthly_001",
    "provider_token": "YOUR_PROVIDER_TOKEN",
    "currency": "RUB",
    "prices": [{"label": "Premium", "amount": 29900}]
  }'

requests.post(f"https://api.letgram.ru/bot{TOKEN}/sendInvoice", json={
    "chat_id": 12345678,
    "title": "Premium Subscription",
    "description": "Monthly premium access",
    "payload": "premium_monthly_001",
    "provider_token": "YOUR_PROVIDER_TOKEN",
    "currency": "RUB",
    "prices": [{"label": "Premium", "amount": 29900}]
})

await fetch(`https://api.letgram.ru/bot${TOKEN}/sendInvoice`, {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    chat_id: 12345678,
    title: "Premium Subscription",
    description: "Monthly premium access",
    payload: "premium_monthly_001",
    provider_token: "YOUR_PROVIDER_TOKEN",
    currency: "RUB",
    prices: [{ label: "Premium", amount: 29900 }]
  })
});

createInvoiceLink

Use this method to create a link for an invoice. Returns the created invoice link as a String on success.

answerShippingQuery

Use this method to reply to shipping queries. If you sent an invoice requesting a shipping address and set is_flexible to True, the Bot API will send an Update with a shipping_query field. Returns True on success.

answerPreCheckoutQuery

Use this method to respond to pre-checkout queries. Returns True on success.

Stickers

Bots can create and manage sticker sets, and send stickers to users.

sendSticker

Use this method to send static .WEBP, animated .TGS, or video .WEBM stickers. See Send Media section for full parameter table.

getStickerSet

Use this method to get a sticker set. Returns a StickerSet object.

createNewStickerSet

Use this method to create a new sticker set owned by a user. Returns True on success.

addStickerToSet

Use this method to add a new sticker to an existing set. Returns True on success.

Games

Letgram games are a platform for HTML5-based games that can be launched inside Letgram chats. Use @BotGod to create a game and get its short name.

sendGame

Use this method to send a game. On success, the sent Message is returned.

setGameScore

Use this method to set the score of the specified user in a game message. On success, if the message is not an inline message, the Message is returned.

getGameHighScores

Use this method to get data for high score tables. Returns an Array of GameHighScore objects.

Stories

Bots with the appropriate permissions can post, edit, and delete stories on behalf of channels they administer.

postStory

Use this method to post a new story to a channel. Returns the posted Story object on success.

curl -X POST "https://api.letgram.ru/bot<token>/postStory" \
  -F "chat_id=@mychannel" \
  -F "content=@story_photo.jpg" \
  -F "caption=Check out our new update!" \
  -F "period=86400"

with open("story_photo.jpg", "rb") as f:
    requests.post(f"https://api.letgram.ru/bot{TOKEN}/postStory",
        data={
            "chat_id": "@mychannel",
            "caption": "Check out our new update!",
            "period": 86400
        },
        files={"content": f}
    )

const formData = new FormData();
formData.append("chat_id", "@mychannel");
formData.append("content", fileBlob, "story.jpg");
formData.append("caption", "Check out our new update!");
formData.append("period", "86400");

await fetch(`https://api.letgram.ru/bot${TOKEN}/postStory`, {
  method: "POST",
  body: formData
});

editStory

Use this method to edit a previously posted story. Returns the edited Story object on success.

deleteStory

Use this method to delete a previously posted story. Returns True on success.

Changelog

v1.0 — March 2026

Initial release of the Letgram Bot API with full feature set:

• 100+ methods for bot interaction
• Full messaging support: text, media, location, contacts, polls, dice
• Inline mode with 20+ InlineQueryResult types
• Mini Apps (Web Apps) platform with JS SDK
• Payment processing with flexible shipping options
• Sticker set creation and management
• HTML5 game platform with high scores
• Stories API: post, edit, delete stories for channels
• Full chat administration: ban, restrict, promote members
• Webhook and long polling update delivery
• Message editing, forwarding, and copying
• Custom keyboards (inline and reply)
• Bot command management with scoping
• File upload and download (up to 50 MB upload, 20 MB download)

Letgram Bot API v1.0 — letgram.ru — © 2026 Letgram