Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/tucnak/telebot/llms.txt

Use this file to discover all available pages before exploring further.

Anything that can be delivered through b.Send() must implement the Sendable interface. This lets you define custom compound types that send themselves across multiple messages.

​
The Sendable interface

type Sendable interface {
    Send(*Bot, Recipient, *SendOptions) (*Message, error)
}
Passing a Sendable to b.Send() calls its Send method directly: 
func (b *Bot) Send(to Recipient, what interface{}, opts ...interface{}) (*Message, error) {
    // ...
    switch object := what.(type) {
    case string:
        return b.sendText(to, object, sendOpts)
    case Sendable:
        return object.Send(b, to, sendOpts)
    }
}

​
Built-in sendable types

Photo

A JPEG/PNG/WebP image. Supports Caption, HasSpoiler, CaptionAbove.

Audio

An MP3/M4A file. Supports Title, Performer, Duration, Thumbnail.

Video

A video file. Supports Width, Height, Duration, Streaming, Cover.

Document

A generic file. Supports FileName, Thumbnail, DisableTypeDetection.

Voice

An OGG voice note. Supports Caption, Duration.

VideoNote

A round video note. Supports Duration, Length, Thumbnail.

Animation

A GIF or MP4 without sound. Requires FileName to send as animation.

Sticker

A WebP/animated sticker. Supports Emoji.

Location

Geographic coordinates with optional live tracking (LivePeriod).

Venue

A location with name, address and optional Foursquare/Google Place ID.

Contact

A phone contact with PhoneNumber, FirstName, optionally VCard.

Dice

An animated dice. Available types: Cube, Dart, Ball, Goal, Slot, Bowl.

Poll

A poll with PollRegular or PollQuiz type.

Game

A Telegram game identified by Name (short name).

Invoice

A payment invoice. See the Payments guide.

​
The Recipient interface

Anything with a Recipient() string method can receive messages. Telebot implements this for *User and *Chat: 
type Recipient interface {
    Recipient() string // Telegram chat_id or @username
}
Pass a *tele.User, *tele.Chat, or any custom type that implements the interface: 
b.Send(c.Sender(), "Hello user!")
b.Send(c.Chat(), "Hello chat!")

​
SendOptions

SendOptions gives full control over how a message is delivered: 
type SendOptions struct {
    ReplyTo              *Message
    ReplyMarkup          *ReplyMarkup
    DisableWebPagePreview bool
    DisableNotification  bool
    ParseMode            ParseMode
    Entities             Entities
    AllowWithoutReply    bool
    Protected            bool
    ThreadID             int
    HasSpoiler           bool
    ReplyParams          *ReplyParams
    BusinessConnectionID string
    EffectID             string
    Payload              string
    AllowPaidBroadcast   bool
}
Pass it directly or use shorthand Option flags: 
// Full SendOptions
b.Send(chat, "Secret message", &tele.SendOptions{
    Protected:           true,
    DisableNotification: true,
    ParseMode:           tele.ModeHTML,
})

// Shorthand flags (can be mixed)
b.Send(chat, "Quiet message", tele.Silent, tele.Protected)

​
Option flags

FlagEquivalent SendOptions field
tele.SilentDisableNotification: true
tele.NoPreviewDisableWebPagePreview: true
tele.ProtectedProtected: true
tele.AllowWithoutReplyAllowWithoutReply: true
tele.ForceReplyReplyMarkup.ForceReply: true
tele.OneTimeKeyboardReplyMarkup.OneTimeKeyboard: true
tele.RemoveKeyboardReplyMarkup.RemoveKeyboard: true

​
Parse modes

Control how Telegram renders message text: 
// HTML
b.Send(chat, "<b>Bold</b> and <i>italic</i>", tele.ModeHTML)

// Markdown (legacy)
b.Send(chat, "*Bold* and _italic_", tele.ModeMarkdown)

// MarkdownV2 (current spec)
b.Send(chat, "*Bold* and _italic_", tele.ModeMarkdownV2)
Set a global default in Settings to avoid repeating it on every send: 
b, _ := tele.NewBot(tele.Settings{
    Token:     "TOKEN",
    ParseMode: tele.ModeHTML,
    Poller:    &tele.LongPoller{Timeout: 10 * time.Second},
})

// All sends now use HTML by default
b.Send(chat, "<b>Hello!</b>")

​
Albums

Album is a []Inputtable slice. Send it with b.SendAlbum(): 
type Album []Inputtable

func (b *Bot) SendAlbum(to Recipient, a Album, opts ...interface{}) ([]Message, error)
Example: 
msgs, err := b.SendAlbum(chat, tele.Album{
    &tele.Photo{
        File:    tele.FromDisk("cover.jpg"),
        Caption: "Album caption goes here",
    },
    &tele.Video{File: tele.FromDisk("clip.mp4")},
    &tele.Photo{File: tele.FromURL("https://example.com/extra.jpg")},
})
Only the first album item can have a caption. SendAlbum only respects the tele.Silent option.

​
Custom Sendable

Implement Sendable to create reusable compound message types: 
type WelcomeCard struct {
    Username string
    PhotoURL string
}

func (w *WelcomeCard) Send(b *tele.Bot, to tele.Recipient, opt *tele.SendOptions) (*tele.Message, error) {
    photo := &tele.Photo{
        File:    tele.FromURL(w.PhotoURL),
        Caption: "Welcome, " + w.Username + "!",
    }
    return photo.Send(b, to, opt)
}

// Usage
b.Send(chat, &WelcomeCard{Username: "Alice", PhotoURL: "https://example.com/welcome.jpg"})

Build docs developers (and LLMs) love

Get started for freeTalk to us